_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q51900
|
instanceIndex
|
train
|
function instanceIndex(context) {
for (var i = 0; i < instances.length; i++) {
var instance = instances[i];
if (instance.conversionContext === context ||
instance.executionContext === context) {
return i;
}
}
return -1;
}
|
javascript
|
{
"resource": ""
}
|
q51901
|
train
|
function(requisition) {
if (instanceIndex(requisition.conversionContext) !== -1) {
throw new Error('Remote existing mapping before adding a new one');
}
instances.push({
conversionContext: requisition.conversionContext,
executionContext: requisition.executionContext,
mapping: { requisition: requisition }
});
}
|
javascript
|
{
"resource": ""
}
|
|
q51902
|
train
|
function(option) {
if (arg.text.length === 0) {
// If someone hasn't typed anything, we only show top level commands in
// the menu. i.e. sub-commands (those with a space in their name) are
// excluded. We do this to keep the list at an overview level.
if (option.name.indexOf(' ') === -1) {
predictions.push(option);
}
}
else {
// If someone has typed something, then we exclude parent commands
// (those without an exec). We do this because the user is drilling
// down and doesn't need the summary level.
if (option.value.exec != null) {
predictions.push(option);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51903
|
tweakI18nStrings
|
train
|
function tweakI18nStrings(data) {
// Rip off the CommonJS header/footer
var output = '';
data.replace(outline, function(m, inner) {
// Remove the trailing spaces
output += inner.replace(/ *$/, '');
});
if (output === '') {
throw new Error('Mismatch in lib/gcli/nls/strings.js');
}
var strings = [];
// Convert each of the string definitions
var reply = output.replace(singleString, function(m, note, x, name, value) {
strings.push({
note: note,
noteAlsoFor: [],
name: name,
value: value
});
return '';
});
console.log('reply="' + reply + '"');
strings = strings.filter(function(string) {
return ignoreStrings.indexOf(string.name) === -1;
});
// All strings should have a note, but sometimes we describe several strings
// with one note, so if a string has no note then we add it to noteAlsoFor
// in the last string with a note
var lastStringWithNote = -1;
strings.forEach(function(string, i) {
if (string.note === '') {
strings[lastStringWithNote].noteAlsoFor.push(string.name);
}
else {
lastStringWithNote = i;
}
});
// Make a single one line string from the the multi-line JS comments
strings.forEach(function(string) {
if (string.note !== '') {
string.note = string.note.replace(/\n? *\/\/ */g, ' ')
.replace(/^ /, '')
.replace(/\n$/, '');
}
});
// Add the 'LOCALIZATION NOTE' and word wrap
strings.forEach(function(string) {
if (string.note !== '') {
string.noteAlsoFor.unshift(string.name);
var names = '';
if (string.noteAlsoFor.length > 1) {
names = ' (' + string.noteAlsoFor.join(', ') + ')';
}
string.note = 'LOCALIZATION NOTE' + names + ': ' + string.note;
string.note = '\n# ' + wordWrap(string.note, 77).join('\n# ') + '\n';
}
});
// The values were escaped JavaScript strings to be property values they
// need unescaping
strings.forEach(function(string) {
string.value = string.value.replace(/\\\\/g, '\\').replace(/\\'/g, '\'');
});
// Join to get the output
output = strings.map(function(string) {
return string.note + string.name + '=' + string.value + '\n';
}).join('');
return '' +
'# This Source Code Form is subject to the terms of the Mozilla Public\n' +
'# License, v. 2.0. If a copy of the MPL was not distributed with this\n' +
'# file, You can obtain one at http://mozilla.org/MPL/2.0/.\n' +
'\n' +
'# LOCALIZATION NOTE These strings are used inside the Web Console\n' +
'# command line which is available from the Web Developer sub-menu\n' +
'# -> \'Web Console\'.\n' +
'# The correct localization of this file might be to keep it in\n' +
'# English, or another language commonly spoken among web developers.\n' +
'# You want to make that choice consistent across the developer tools.\n' +
'# A good criteria is the language in which you\'d find the best\n' +
'# documentation on web development on the web.\n' +
'\n' +
'# For each command there are in general two strings. As an example consider\n' +
'# the \'pref\' command.\n' +
'# commandDesc (e.g. prefDesc for the command \'pref\'): this string contains a\n' +
'# very short description of the command. It\'s designed to be shown in a menu\n' +
'# alongside the command name, which is why it should be as short as possible.\n' +
'# commandManual (e.g. prefManual for the command \'pref\'): this string will\n' +
'# contain a fuller description of the command. It\'s diplayed when the user\n' +
'# asks for help about a specific command (e.g. \'help pref\').\n' +
output;
}
|
javascript
|
{
"resource": ""
}
|
q51904
|
wordWrap
|
train
|
function wordWrap(input, length) {
// LOOK! Over there! Is it an airplane?
var wrapper = new RegExp('.{0,' + (length - 1) + '}([ $|\\s$]|$)', 'g');
return input.match(wrapper).slice(0, -1).map(function(s) {
return s.replace(/ $/, '');
});
// Ah, no - it's just superman, anyway, on with the code ...
}
|
javascript
|
{
"resource": ""
}
|
q51905
|
nodeFromDataToString
|
train
|
function nodeFromDataToString(data, conversionContext) {
var node = util.createElement(conversionContext.document, 'p');
node.textContent = data.toString();
return node;
}
|
javascript
|
{
"resource": ""
}
|
q51906
|
train
|
function(javascript) {
try {
return Promise.resolve({
input: javascript,
output: eval(javascript),
exception: null
});
}
catch (ex) {
return Promise.resolve({
input: javascript,
output: null,
exception: ex
});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51907
|
train
|
function(start) {
if (!this.requisition.isUpToDate()) {
return;
}
var newAssignment = this.requisition.getAssignmentAt(start);
if (newAssignment == null) {
return;
}
if (this.assignment !== newAssignment) {
if (this.assignment.param.type.onLeave) {
this.assignment.param.type.onLeave(this.assignment);
}
// This can be kicked off either by requisition doing an assign or by
// terminal noticing a cursor movement out of a command, so we should
// check that this really is a new assignment
var isNew = (this.assignment !== newAssignment);
this.assignment = newAssignment;
this.terminal.updateCompletion().catch(util.errorHandler);
if (isNew) {
this.updateHints();
}
if (this.assignment.param.type.onEnter) {
this.assignment.param.type.onEnter(this.assignment);
}
}
else {
if (this.assignment && this.assignment.param.type.onChange) {
this.assignment.param.type.onChange(this.assignment);
}
}
// Warning: compare the logic here with the logic in fieldChanged, which
// is slightly different. They should probably be the same
var error = (this.assignment.status === Status.ERROR);
this.focusManager.setError(error);
}
|
javascript
|
{
"resource": ""
}
|
|
q51908
|
train
|
function() {
this.lastText = this.assignment.arg.text;
var field = this.terminal.field;
if (field) {
field.onFieldChange.remove(this.terminal.fieldChanged, this.terminal);
field.destroy();
}
var fields = this.terminal.system.fields;
field = this.terminal.field = fields.get(this.assignment.param.type, {
document: this.terminal.document,
requisition: this.requisition
});
this.focusManager.setImportantFieldFlag(field.isImportant);
field.onFieldChange.add(this.terminal.fieldChanged, this.terminal);
field.setConversion(this.assignment.conversion);
// Filled in by the template process
this.terminal.errorEle = undefined;
this.terminal.descriptionEle = undefined;
var contents = this.terminal.tooltipTemplate.cloneNode(true);
domtemplate.template(contents, this.terminal, {
blankNullUndefined: true,
stack: 'terminal.html#tooltip'
});
util.clearElement(this.terminal.tooltipElement);
this.terminal.tooltipElement.appendChild(contents);
this.terminal.tooltipElement.style.display = 'block';
field.setMessageElement(this.terminal.errorEle);
}
|
javascript
|
{
"resource": ""
}
|
|
q51909
|
train
|
function() {
// If the user is on a valid value, then we increment the value, but if
// they've typed something that's not right we page through predictions
if (this.assignment.getStatus() === Status.VALID) {
return this.requisition.nudge(this.assignment, 1).then(function() {
this.textChanged();
this.focusManager.onInputChange();
return true;
}.bind(this));
}
return Promise.resolve(false);
}
|
javascript
|
{
"resource": ""
}
|
|
q51910
|
train
|
function(input) {
// Deny RETURN unless the command might work
if (this.requisition.status !== Status.VALID) {
return Promise.resolve(false);
}
this.terminal.history.add(input);
this.terminal.unsetChoice().catch(util.errorHandler);
this.terminal._previousValue = this.terminal.inputElement.value;
this.terminal.inputElement.value = '';
return this.requisition.exec().then(function() {
this.textChanged();
return true;
}.bind(this));
}
|
javascript
|
{
"resource": ""
}
|
|
q51911
|
train
|
function(value) {
this.terminal._caretChange = Caret.NO_CHANGE;
return this.requisition.update(value).then(function(updated) {
// Abort UI changes if this UI update has been overtaken
if (!updated) {
return RESOLVED;
}
this.textChanged();
return this.terminal.unsetChoice();
}.bind(this));
}
|
javascript
|
{
"resource": ""
}
|
|
q51912
|
train
|
function(cursor) {
this._caretChange = Caret.NO_CHANGE;
this._processCaretChange({
typed: this.terminal.inputElement.value,
cursor: cursor
});
}
|
javascript
|
{
"resource": ""
}
|
|
q51913
|
train
|
function() {
var input = this.terminal.getInputState();
var start = input.cursor.start;
var index = this.terminal.getChoiceIndex();
return this.requisition.getStateData(start, index).then(function(data) {
// Calculate the statusMarkup required to show wavy lines underneath the
// input text (like that of an inline spell-checker) which used by the
// template process for completer.html
// i.e. s/space/ /g in the string (for HTML display) and status to an
// appropriate class name (i.e. lower cased, prefixed with gcli-in-)
data.statusMarkup.forEach(function(member) {
member.string = member.string.replace(/ /g, '\u00a0'); // i.e.
member.className = 'gcli-in-' + member.status.toString().toLowerCase();
}, this);
return data;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q51914
|
train
|
function(ev) {
if (ev.output.hidden) {
return;
}
var template = this.commandDom.cloneNode(true);
var templateOptions = { stack: 'terminal.html#outputView' };
var context = this.requisition.conversionContext;
var data = {
onclick: context.update,
ondblclick: context.updateExec,
language: this,
output: ev.output,
promptClass: (ev.output.error ? 'gcli-row-error' : '') +
(ev.output.completed ? ' gcli-row-complete' : ''),
// Elements attached to this by template().
rowinEle: null,
rowoutEle: null,
throbEle: null,
promptEle: null
};
domtemplate.template(template, data, templateOptions);
ev.output.promise.then(function() {
var document = data.rowoutEle.ownerDocument;
if (ev.output.completed) {
data.promptEle.classList.add('gcli-row-complete');
}
if (ev.output.error) {
data.promptEle.classList.add('gcli-row-error');
}
util.clearElement(data.rowoutEle);
return ev.output.convert('dom', context).then(function(node) {
this.terminal.scrollToBottom();
data.throbEle.style.display = ev.output.completed ? 'none' : 'block';
if (node == null) {
data.promptEle.classList.add('gcli-row-error');
// TODO: show some error to the user
}
this._linksToNewTab(node);
data.rowoutEle.appendChild(node);
var event = document.createEvent('Event');
event.initEvent('load', true, true);
event.addedElement = node;
node.dispatchEvent(event);
}.bind(this));
}.bind(this)).catch(console.error);
this.terminal.addElement(data.rowinEle);
this.terminal.addElement(data.rowoutEle);
this.terminal.scrollToBottom();
this.focusManager.outputted();
}
|
javascript
|
{
"resource": ""
}
|
|
q51915
|
train
|
function(element) {
var links = element.querySelectorAll('*[href]');
for (var i = 0; i < links.length; i++) {
links[i].setAttribute('target', '_blank');
}
return element;
}
|
javascript
|
{
"resource": ""
}
|
|
q51916
|
cloneState
|
train
|
function cloneState(state) {
return {
options: state.options,
stack: state.stack.slice(),
nodes: state.nodes.slice()
};
}
|
javascript
|
{
"resource": ""
}
|
q51917
|
processString
|
train
|
function processString(state, value, data) {
return value.replace(TEMPLATE_REGION, function(path) {
var insert = envEval(state, path.slice(2, -1), data, value);
return state.options.blankNullUndefined && insert == null ? '' : insert;
});
}
|
javascript
|
{
"resource": ""
}
|
q51918
|
maybeImportNode
|
train
|
function maybeImportNode(state, node, doc) {
return node.ownerDocument === doc ? node : doc.importNode(node, true);
}
|
javascript
|
{
"resource": ""
}
|
q51919
|
handleError
|
train
|
function handleError(state, message, ex) {
logError(message + ' (In: ' + state.stack.join(' > ') + ')');
if (ex) {
logError(ex);
}
}
|
javascript
|
{
"resource": ""
}
|
q51920
|
Settings
|
train
|
function Settings(types, settingValues) {
this._types = types;
// Where we store the settings that we've created
this._settings = {};
// Where the values for the settings are stored while in use.
this._settingValues = settingValues || {};
// Where the values for the settings are persisted for next use.
this._settingStorage = new LocalSettingStorage();
this._settingStorage.load(this._settingValues);
// Event for use to detect when the list of settings changes
this.onChange = util.createEvent('Settings.onChange');
}
|
javascript
|
{
"resource": ""
}
|
q51921
|
Setting
|
train
|
function Setting(settings, name, type, description, defaultValue) {
this._settings = settings;
this.name = name;
this.type = type;
this.description = description;
this._defaultValue = defaultValue;
this.onChange = util.createEvent('Setting.onChange');
this.setDefault();
}
|
javascript
|
{
"resource": ""
}
|
q51922
|
onEnter
|
train
|
function onEnter(assignment) {
// TODO: GCLI doesn't support passing a context to notifications of cursor
// position, so onEnter/onLeave/onChange are disabled below until we fix this
assignment.highlighter = new Highlighter(context.environment.window.document);
assignment.highlighter.nodelist = assignment.conversion.matches;
}
|
javascript
|
{
"resource": ""
}
|
q51923
|
removeItemsFromFront
|
train
|
function removeItemsFromFront(system, front) {
system.commands.getAll().forEach(function(command) {
if (command.front === front) {
system.commands.remove(command);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q51924
|
getChainConverter
|
train
|
function getChainConverter(first, second) {
if (first.to !== second.from) {
throw new Error('Chain convert impossible: ' + first.to + '!=' + second.from);
}
return {
from: first.from,
to: second.to,
exec: function(data, conversionContext) {
var intermediate = first.exec(data, conversionContext);
return second.exec(intermediate, conversionContext);
}
};
}
|
javascript
|
{
"resource": ""
}
|
q51925
|
train
|
function(ev) {
if (fireHoldCount > 0) {
heldEvents.push(ev);
if (eventDebug) {
console.log('Held fire: ' + name, ev);
}
return;
}
if (eventDebug) {
console.group('Fire: ' + name + ' to ' + handlers.length + ' listeners', ev);
}
// Use for rather than forEach because it step debugs better, which is
// important for debugging events
for (var i = 0; i < handlers.length; i++) {
var handler = handlers[i];
if (eventDebug) {
console.log(nameFunction(handler));
}
handler.func.call(handler.scope, ev);
}
if (eventDebug) {
console.groupEnd();
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51926
|
toDate
|
train
|
function toDate(str) {
var millis = Date.parse(str);
if (isNaN(millis)) {
throw new Error(l10n.lookupFormat('typesDateNan', [ str ]));
}
return new Date(millis);
}
|
javascript
|
{
"resource": ""
}
|
q51927
|
isDate
|
train
|
function isDate(thing) {
return Object.prototype.toString.call(thing) === '[object Date]'
&& !isNaN(thing.getTime());
}
|
javascript
|
{
"resource": ""
}
|
q51928
|
train
|
function(err) {
console.log('SOCKET ' + command +
'(' + debugStr(request.data, 30) + ') Exception');
util.errorHandler(err);
socket.emit('reply', {
id: request.id,
exception: '' + err
});
}
|
javascript
|
{
"resource": ""
}
|
|
q51929
|
debugStr
|
train
|
function debugStr(obj) {
var summary = JSON.stringify(obj) || '';
return summary.length > 40 ? summary.substr(0, 39) + '…' : summary;
}
|
javascript
|
{
"resource": ""
}
|
q51930
|
Commands
|
train
|
function Commands(types, location) {
this.types = types;
this.location = location;
// A lookup hash of our registered commands
this._commands = {};
// A sorted list of command names, we regularly want them in order, so pre-sort
this._commandNames = [];
// A lookup of the original commandSpecs by command name
this._commandSpecs = {};
// Enable people to be notified of changes to the list of commands
this.onCommandsChange = util.createEvent('commands.onCommandsChange');
}
|
javascript
|
{
"resource": ""
}
|
q51931
|
stringify
|
train
|
function stringify(data, action) {
try {
return JSON.stringify(data);
}
catch (ex) {
console.error('Performing "' + action + '". Failed to stringify', data);
util.errorHandler(ex);
data = {
code: -1,
data: ex.toString()
};
return JSON.stringify(data);
}
}
|
javascript
|
{
"resource": ""
}
|
q51932
|
WebsocketConnection
|
train
|
function WebsocketConnection(socket, url) {
this.socket = socket;
this.url = url;
this.deferreds = {};
this.nextRequestId = 0;
this.onReply = this.onReply.bind(this);
this.onEvent = this.onEvent.bind(this);
}
|
javascript
|
{
"resource": ""
}
|
q51933
|
addParamGroups
|
train
|
function addParamGroups(command) {
Object.defineProperty(command, 'paramGroups', {
get: function() {
var paramGroups = {};
this.params.forEach(function(param) {
var groupName = param.option || l10n.lookup('canonDefaultGroupName');
if (paramGroups[groupName] == null) {
paramGroups[groupName] = [];
}
paramGroups[groupName].push(param);
});
return paramGroups;
},
enumerable: true
});
}
|
javascript
|
{
"resource": ""
}
|
q51934
|
getSubCommands
|
train
|
function getSubCommands(context, command) {
var commands = cli.getMapping(context).requisition.system.commands;
var subcommands = commands.getAll().filter(function(subcommand) {
return subcommand.name.indexOf(command.name) === 0 &&
subcommand.name !== command.name &&
!subcommand.hidden;
});
subcommands.sort(function(c1, c2) {
return c1.name.localeCompare(c2.name);
});
subcommands = subcommands.map(function(subcommand) {
return subcommand.toJson();
});
return subcommands;
}
|
javascript
|
{
"resource": ""
}
|
q51935
|
loadFirebaseRc
|
train
|
function loadFirebaseRc() {
const rcFilePath = `${process.cwd()}/.firebaserc`;
if (!fs.existsSync(rcFilePath)) {
throw new Error('.firebaserc file not found');
}
try {
const fileStr = fs.readFileSync(rcFilePath);
return JSON.parse(fileStr);
} catch (err) {
console.log('Error loading .firebaserc: ', err); // eslint-disable-line no-console
throw err;
}
}
|
javascript
|
{
"resource": ""
}
|
q51936
|
getEnvNameFromConfig
|
train
|
function getEnvNameFromConfig(cypressConfig) {
if (!cypressConfig.env || !cypressConfig.env.envName) {
return 'local';
}
return cypressConfig.env.envName;
}
|
javascript
|
{
"resource": ""
}
|
q51937
|
getParsedEnvVar
|
train
|
function getParsedEnvVar(varNameRoot) {
const val = envVarBasedOnCIEnv(varNameRoot);
const prefix = getEnvPrefix();
const combinedVar = `${prefix}${varNameRoot}`;
if (!val) {
error(
`${chalk.cyan(
combinedVar,
)} not found, make sure it is set within environment variables.`,
);
}
try {
if (isString(val)) {
return JSON.parse(val);
}
return val;
} catch (err) {
error(`Error parsing ${combinedVar}`);
return val;
}
}
|
javascript
|
{
"resource": ""
}
|
q51938
|
validateDeep
|
train
|
function validateDeep(map) {
if (!(map instanceof Map)) {
throw new Error(`Invalid graph: Expected Map instead found ${typeof map}`);
}
map.forEach((value, key) => {
if (typeof value === 'object' && value instanceof Map) {
validateDeep(value);
return;
}
if (typeof value !== 'number' || value <= 0) {
throw new Error(`Values must be numbers greater than 0. Found value ${value} at ${key}`);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q51939
|
isValidNode
|
train
|
function isValidNode(val) {
const cost = Number(val);
if (isNaN(cost) || cost <= 0) {
return false;
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
q51940
|
toDeepMap
|
train
|
function toDeepMap(source) {
const map = new Map();
const keys = Object.keys(source);
keys.forEach((key) => {
const val = source[key];
if (val !== null && typeof val === 'object' && !Array.isArray(val)) {
return map.set(key, toDeepMap(val));
}
if (!isValidNode(val)) {
throw new Error(`Could not add node at key "${key}", make sure it's a valid node`, val);
}
return map.set(key, Number(val));
});
return map;
}
|
javascript
|
{
"resource": ""
}
|
q51941
|
removeDeepFromMap
|
train
|
function removeDeepFromMap(map, key) {
const newMap = new Map();
for (const [aKey, val] of map) {
if (aKey !== key && val instanceof Map) {
newMap.set(aKey, removeDeepFromMap(val, key));
} else if (aKey !== key) {
newMap.set(aKey, val);
}
}
return newMap;
}
|
javascript
|
{
"resource": ""
}
|
q51942
|
createConnect
|
train
|
function createConnect() {
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref$connectHOC = _ref.connectHOC,
connectHOC = _ref$connectHOC === undefined ? __WEBPACK_IMPORTED_MODULE_0__components_connectAdvanced__["a" /* default */] : _ref$connectHOC,
_ref$mapStateToPropsF = _ref.mapStateToPropsFactories,
mapStateToPropsFactories = _ref$mapStateToPropsF === undefined ? __WEBPACK_IMPORTED_MODULE_3__mapStateToProps__["a" /* default */] : _ref$mapStateToPropsF,
_ref$mapDispatchToPro = _ref.mapDispatchToPropsFactories,
mapDispatchToPropsFactories = _ref$mapDispatchToPro === undefined ? __WEBPACK_IMPORTED_MODULE_2__mapDispatchToProps__["a" /* default */] : _ref$mapDispatchToPro,
_ref$mergePropsFactor = _ref.mergePropsFactories,
mergePropsFactories = _ref$mergePropsFactor === undefined ? __WEBPACK_IMPORTED_MODULE_4__mergeProps__["a" /* default */] : _ref$mergePropsFactor,
_ref$selectorFactory = _ref.selectorFactory,
selectorFactory = _ref$selectorFactory === undefined ? __WEBPACK_IMPORTED_MODULE_5__selectorFactory__["a" /* default */] : _ref$selectorFactory;
return function connect(mapStateToProps, mapDispatchToProps, mergeProps) {
var _ref2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
_ref2$pure = _ref2.pure,
pure = _ref2$pure === undefined ? true : _ref2$pure,
_ref2$areStatesEqual = _ref2.areStatesEqual,
areStatesEqual = _ref2$areStatesEqual === undefined ? strictEqual : _ref2$areStatesEqual,
_ref2$areOwnPropsEqua = _ref2.areOwnPropsEqual,
areOwnPropsEqual = _ref2$areOwnPropsEqua === undefined ? __WEBPACK_IMPORTED_MODULE_1__utils_shallowEqual__["a" /* default */] : _ref2$areOwnPropsEqua,
_ref2$areStatePropsEq = _ref2.areStatePropsEqual,
areStatePropsEqual = _ref2$areStatePropsEq === undefined ? __WEBPACK_IMPORTED_MODULE_1__utils_shallowEqual__["a" /* default */] : _ref2$areStatePropsEq,
_ref2$areMergedPropsE = _ref2.areMergedPropsEqual,
areMergedPropsEqual = _ref2$areMergedPropsE === undefined ? __WEBPACK_IMPORTED_MODULE_1__utils_shallowEqual__["a" /* default */] : _ref2$areMergedPropsE,
extraOptions = _objectWithoutProperties(_ref2, ['pure', 'areStatesEqual', 'areOwnPropsEqual', 'areStatePropsEqual', 'areMergedPropsEqual']);
var initMapStateToProps = match(mapStateToProps, mapStateToPropsFactories, 'mapStateToProps');
var initMapDispatchToProps = match(mapDispatchToProps, mapDispatchToPropsFactories, 'mapDispatchToProps');
var initMergeProps = match(mergeProps, mergePropsFactories, 'mergeProps');
return connectHOC(selectorFactory, _extends({
// used in error messages
methodName: 'connect',
// used to compute Connect's displayName from the wrapped component's displayName.
getDisplayName: function getDisplayName(name) {
return 'Connect(' + name + ')';
},
// if mapStateToProps is falsy, the Connect component doesn't subscribe to store state changes
shouldHandleStateChanges: Boolean(mapStateToProps),
// passed through to selectorFactory
initMapStateToProps: initMapStateToProps,
initMapDispatchToProps: initMapDispatchToProps,
initMergeProps: initMergeProps,
pure: pure,
areStatesEqual: areStatesEqual,
areOwnPropsEqual: areOwnPropsEqual,
areStatePropsEqual: areStatePropsEqual,
areMergedPropsEqual: areMergedPropsEqual
}, extraOptions));
};
}
|
javascript
|
{
"resource": ""
}
|
q51943
|
finalPropsSelectorFactory
|
train
|
function finalPropsSelectorFactory(dispatch, _ref2) {
var initMapStateToProps = _ref2.initMapStateToProps,
initMapDispatchToProps = _ref2.initMapDispatchToProps,
initMergeProps = _ref2.initMergeProps,
options = _objectWithoutProperties(_ref2, ['initMapStateToProps', 'initMapDispatchToProps', 'initMergeProps']);
var mapStateToProps = initMapStateToProps(dispatch, options);
var mapDispatchToProps = initMapDispatchToProps(dispatch, options);
var mergeProps = initMergeProps(dispatch, options);
if (true) {
Object(__WEBPACK_IMPORTED_MODULE_0__verifySubselectors__["a" /* default */])(mapStateToProps, mapDispatchToProps, mergeProps, options.displayName);
}
var selectorFactory = options.pure ? pureFinalPropsSelectorFactory : impureFinalPropsSelectorFactory;
return selectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, options);
}
|
javascript
|
{
"resource": ""
}
|
q51944
|
getDependsOnOwnProps
|
train
|
function getDependsOnOwnProps(mapToProps) {
return mapToProps.dependsOnOwnProps !== null && mapToProps.dependsOnOwnProps !== undefined ? Boolean(mapToProps.dependsOnOwnProps) : mapToProps.length !== 1;
}
|
javascript
|
{
"resource": ""
}
|
q51945
|
resolveComponents
|
train
|
function resolveComponents(router) {
const path = getLocation(router.options.base, router.options.mode)
return flatMapComponents(router.match(path), async (Component, _, match, key, index) => {
// If component is not resolved yet, resolve it
if (typeof Component === 'function' && !Component.options) {
Component = await Component()
}
// Sanitize it and save it
const _Component = applySSRData(sanitizeComponent(Component), NUXT.data ? NUXT.data[index] : null)
match.components[key] = _Component
return _Component
})
}
|
javascript
|
{
"resource": ""
}
|
q51946
|
train
|
function(str1, str2, options) {
var useCollator = (options && collator && options.useCollator);
var str1Len = str1.length,
str2Len = str2.length;
// base cases
if (str1Len === 0) return str2Len;
if (str2Len === 0) return str1Len;
// two rows
var curCol, nextCol, i, j, tmp;
// initialise previous row
for (i=0; i<str2Len; ++i) {
prevRow[i] = i;
str2Char[i] = str2.charCodeAt(i);
}
prevRow[str2Len] = str2Len;
var strCmp;
if (useCollator) {
// calculate current row distance from previous row using collator
for (i = 0; i < str1Len; ++i) {
nextCol = i + 1;
for (j = 0; j < str2Len; ++j) {
curCol = nextCol;
// substution
strCmp = 0 === collator.compare(str1.charAt(i), String.fromCharCode(str2Char[j]));
nextCol = prevRow[j] + (strCmp ? 0 : 1);
// insertion
tmp = curCol + 1;
if (nextCol > tmp) {
nextCol = tmp;
}
// deletion
tmp = prevRow[j + 1] + 1;
if (nextCol > tmp) {
nextCol = tmp;
}
// copy current col value into previous (in preparation for next iteration)
prevRow[j] = curCol;
}
// copy last col value into previous (in preparation for next iteration)
prevRow[j] = nextCol;
}
}
else {
// calculate current row distance from previous row without collator
for (i = 0; i < str1Len; ++i) {
nextCol = i + 1;
for (j = 0; j < str2Len; ++j) {
curCol = nextCol;
// substution
strCmp = str1.charCodeAt(i) === str2Char[j];
nextCol = prevRow[j] + (strCmp ? 0 : 1);
// insertion
tmp = curCol + 1;
if (nextCol > tmp) {
nextCol = tmp;
}
// deletion
tmp = prevRow[j + 1] + 1;
if (nextCol > tmp) {
nextCol = tmp;
}
// copy current col value into previous (in preparation for next iteration)
prevRow[j] = curCol;
}
// copy last col value into previous (in preparation for next iteration)
prevRow[j] = nextCol;
}
}
return nextCol;
}
|
javascript
|
{
"resource": ""
}
|
|
q51947
|
formatUrl
|
train
|
function formatUrl (url, query) {
let protocol
let index = url.indexOf('://')
if (index !== -1) {
protocol = url.substring(0, index)
url = url.substring(index + 3)
} else if (url.indexOf('//') === 0) {
url = url.substring(2)
}
let parts = url.split('/')
let result = (protocol ? protocol + '://' : '//') + parts.shift()
let path = parts.filter(Boolean).join('/')
let hash
parts = path.split('#')
if (parts.length === 2) {
path = parts[0]
hash = parts[1]
}
result += path ? '/' + path : ''
if (query && JSON.stringify(query) !== '{}') {
result += (url.split('?').length === 2 ? '&' : '?') + formatQuery(query)
}
result += hash ? '#' + hash : ''
return result
}
|
javascript
|
{
"resource": ""
}
|
q51948
|
formatQuery
|
train
|
function formatQuery (query) {
return Object.keys(query).sort().map(key => {
var val = query[key]
if (val == null) {
return ''
}
if (Array.isArray(val)) {
return val.slice().map(val2 => [key, '=', val2].join('')).join('&')
}
return key + '=' + val
}).filter(Boolean).join('&')
}
|
javascript
|
{
"resource": ""
}
|
q51949
|
cleanup
|
train
|
function cleanup() {
if (url) { URL.revokeObjectURL(url); }
if (ww) { ww.terminate(); }
if (timeout) { clearTimeout(timeout); }
}
|
javascript
|
{
"resource": ""
}
|
q51950
|
append
|
train
|
function append(object, path, value) {
set(object, path, get(object, path, '') + `\r\n${value}`);
}
|
javascript
|
{
"resource": ""
}
|
q51951
|
getType
|
train
|
function getType(node) {
const tagLoaders = {
script: 'javascript',
style: 'text/css'
};
return get(node, 'attrs.type', tagLoaders[node.tag]);
}
|
javascript
|
{
"resource": ""
}
|
q51952
|
serialize
|
train
|
function serialize(obj) {
var params = [],
encodedBrackets = encodeURIComponent('[]');
_.forOwn(obj, function(value, key) {
if (typeof value === 'string' ||
typeof value === 'number' ||
typeof value === 'boolean') {
params.push(key + '=' + encodeURIComponent(value));
} else if (typeof value === 'object' && Array.isArray(value)) {
params.push(value.map(function(param) {
return key + encodedBrackets + '=' + encodeURIComponent(param);
}).join('&'));
}
});
return params.join('&');
}
|
javascript
|
{
"resource": ""
}
|
q51953
|
getInfo
|
train
|
function getInfo(hostingId) {
var requestConfigs = _.assign({}, configs.DEFAULT_REQUEST_CONFIGS, {
url: configs.HOSTING_INFO_URL + '/' + hostingId + '?' + serialize(configs.DEFAULT_REQUEST_PARAMS)
});
return new Promise(function(resolve, reject) {
// Make request to parse hosting info
request(requestConfigs, function(err, res, body) {
if (!err && res.statusCode == 200) {
resolve(JSON.parse(body));
} else if (err) {
reject(err);
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q51954
|
executeEach
|
train
|
function executeEach(arr, fun) {
var i = -1;
while (++i < arr.length) {
if (arr[i]) {
fun(arr[i]);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q51955
|
train
|
function (ns, obj, overwrite) {
var isFunc = typeof obj === 'function';
var parts = ns ? ns.split('.') : [];
var parent = this;
obj = obj || {};
// ignore leading global
if (parts[0] === 'F2') {
parts = parts.slice(1);
}
// create namespaces
for (var i = 0, len = parts.length; i < len; i++) {
if (!parent[parts[i]]) {
parent[parts[i]] = isFunc && i + 1 == len ? obj : {};
}
parent = parent[parts[i]];
}
// copy object into namespace
if (!isFunc) {
for (var prop in obj) {
if (typeof parent[prop] === 'undefined' || overwrite) {
parent[prop] = obj[prop];
}
}
}
return parent;
}
|
javascript
|
{
"resource": ""
}
|
|
q51956
|
train
|
function(testObject) {
var bIsNode = (
typeof Node === 'object' ? testObject instanceof Node :
testObject && typeof testObject === 'object' && typeof testObject.nodeType === 'number' && typeof testObject.nodeName === 'string'
);
var bIsElement = (
typeof HTMLElement === 'object' ? testObject instanceof HTMLElement : //DOM2
testObject && typeof testObject === 'object' && testObject.nodeType === 1 && typeof testObject.nodeName === 'string'
);
return (bIsNode || bIsElement);
}
|
javascript
|
{
"resource": ""
}
|
|
q51957
|
train
|
function(token, eventKey) // additional arguments will likely be passed
{
// will throw an exception and stop execution if the token is invalid
if(token != _f2t)
{
throw ('Token passed is invalid. Only F2 is allowed to call F2.AppHandlers.__trigger().');
}
if(_handlerCollection && _handlerCollection[eventKey])
{
// create a collection of arguments that are safe to pass to the callback.
var passableArgs = [];
// populate that collection with all arguments except token and eventKey
for(var i = 2, j = arguments.length; i < j; i++)
{
passableArgs.push(arguments[i]);
}
if(_handlerCollection[eventKey].length === 0 && _defaultMethods[eventKey])
{
_defaultMethods[eventKey].apply(F2, passableArgs);
return this;
}
else if(_handlerCollection[eventKey].length === 0 && !_handlerCollection[eventKey])
{
return this;
}
// fire all event listeners in the order that they were added.
for(var iCounter = 0, hcl = _handlerCollection[eventKey].length; iCounter < hcl; iCounter++)
{
var handler = _handlerCollection[eventKey][iCounter];
// appRender where root is already defined
if (handler.domNode && arguments[2] && arguments[2].root && arguments[3])
{
var $appRoot = jQuery(arguments[2].root).append(arguments[3]);
jQuery(handler.domNode).append($appRoot);
}
else if (handler.domNode && arguments[2] && !arguments[2].root && arguments[3])
{
// set the root to the actual HTML of the app
arguments[2].root = jQuery(arguments[3]).get(0);
// appends the root to the dom node specified
jQuery(handler.domNode).append(arguments[2].root);
}
else
{
handler.func.apply(F2, passableArgs);
}
}
}
else
{
throw ('Invalid EventKey passed. Check your inputs and try again.');
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q51958
|
train
|
function(appConfig, message, origin) {
var obj, func;
function parseFunction(parent, functionName) {
var path = String(functionName).split('.');
for (var i = 0; i < path.length; i++) {
if (parent[path[i]] === undefined) {
parent = undefined;
break;
}
parent = parent[path[i]];
}
return parent;
}
function parseMessage(regEx, message, instanceId) {
var o = F2.parse(message.replace(regEx, ''));
// if obj.callbacks
// for each callback
// for each params
// if callback matches param
// replace param with _createRpcCallback(app.instanceId, callback)
if (o.params && o.params.length && o.callbacks && o.callbacks.length) {
jQuery.each(o.callbacks, function(i, c) {
jQuery.each(o.params, function(i, p) {
if (c == p) {
o.params[i] = _createRpcCallback(instanceId, c);
}
});
});
}
return o;
}
// handle UI Call
if (_rUiCall.test(message)) {
obj = parseMessage(_rUiCall, message, appConfig.instanceId);
func = parseFunction(appConfig.ui, obj.functionName);
// if we found the function, call it
if (func !== undefined) {
func.apply(appConfig.ui, obj.params);
} else {
F2.log('Unable to locate UI RPC function: ' + obj.functionName);
}
// handle RPC
} else if (_rRpc.test(message)) {
obj = parseMessage(_rRpc, message, appConfig.instanceId);
func = parseFunction(window, obj.functionName);
if (func !== undefined) {
func.apply(func, obj.params);
} else {
F2.log('Unable to locate RPC function: ' + obj.functionName);
}
// handle RPC Callback
} else if (_rRpcCallback.test(message)) {
obj = parseMessage(_rRpcCallback, message, appConfig.instanceId);
if (_callbacks[obj.functionName] !== undefined) {
_callbacks[obj.functionName].apply(_callbacks[obj.functionName], obj.params);
delete _callbacks[obj.functionName];
}
// handle Events
} else if (_rEvents.test(message)) {
obj = parseMessage(_rEvents, message, appConfig.instanceId);
F2.Events._socketEmit.apply(F2.Events, obj);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51959
|
train
|
function(messageType, params) {
// check valid messageType
var message = messageType + F2.stringify(params);
jQuery.each(_apps, function(i, a) {
a.socket.postMessage(message);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q51960
|
train
|
function(instanceId, messageType, functionName, params) {
// loop through params and find functions and convert them to callbacks
var callbacks = [];
jQuery.each(params, function(i, e) {
if (typeof e === 'function') {
var cid = _registerCallback(e);
params[i] = cid;
callbacks.push(cid);
}
});
// check valid messageType
_apps[instanceId].socket.postMessage(
messageType + F2.stringify({
functionName:functionName,
params:params,
callbacks:callbacks
})
);
}
|
javascript
|
{
"resource": ""
}
|
|
q51961
|
train
|
function(instanceId) {
return (
// we have an app
_apps[instanceId] !== undefined &&
// the app is secure
_apps[instanceId].config.isSecure &&
// we can't access the iframe
jQuery(_apps[instanceId].config.root).find('iframe').length === 0
);
}
|
javascript
|
{
"resource": ""
}
|
|
q51962
|
train
|
function(appConfig, appManifest) {
if (!!appConfig && !!appManifest) {
_apps[appConfig.instanceId] = {
config:appConfig,
socket:_createContainerToAppSocket(appConfig, appManifest)
};
} else {
F2.log('Unable to register socket connection. Please check container configuration.');
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51963
|
train
|
function(message, callback) {
if (!F2.isInit()) {
F2.log('F2.init() must be called before F2.UI.Modals.alert()');
return;
}
if (F2.Rpc.isRemote(_appConfig.instanceId)) {
F2.Rpc.call(
_appConfig.instanceId,
F2.Constants.Sockets.UI_RPC,
'Modals.alert',
[].slice.call(arguments)
);
} else {
// display the alert
jQuery(_renderAlert(message))
.on('show.bs.modal', function() {
var modal = this;
jQuery(modal).find('.btn-primary').on('click', function() {
jQuery(modal).modal('hide').remove();
(callback || jQuery.noop)();
});
})
.modal({backdrop:true});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51964
|
train
|
function(message, okCallback, cancelCallback) {
if (!F2.isInit()) {
F2.log('F2.init() must be called before F2.UI.Modals.confirm()');
return;
}
if (F2.Rpc.isRemote(_appConfig.instanceId)) {
F2.Rpc.call(
_appConfig.instanceId,
F2.Constants.Sockets.UI_RPC,
'Modals.confirm',
[].slice.call(arguments)
);
} else {
// display the alert
jQuery(_renderConfirm(message))
.on('show.bs.modal', function() {
var modal = this;
jQuery(modal).find('.btn-ok').on('click', function() {
jQuery(modal).modal('hide').remove();
(okCallback || jQuery.noop)();
});
jQuery(modal).find('.btn-cancel').on('click', function() {
jQuery(modal).modal('hide').remove();
(cancelCallback || jQuery.noop)();
});
})
.modal({backdrop:true});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51965
|
train
|
function(title) {
if (F2.Rpc.isRemote(_appConfig.instanceId)) {
F2.Rpc.call(
_appConfig.instanceId,
F2.Constants.Sockets.UI_RPC,
'setTitle',
[
title
]
);
} else {
jQuery(_appConfig.root).find('.' + F2.Constants.Css.APP_TITLE).text(title);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51966
|
train
|
function(input) {
if (typeof input === 'function') {
this.on('change', input);
} else if (typeof input === 'string') {
if (_appConfig.isSecure && !F2.Rpc.isRemote(_appConfig.instanceId)) {
F2.Rpc.call(
_appConfig.instanceId,
F2.Constants.Sockets.UI_RPC,
'Views.change',
[].slice.call(arguments)
);
} else if (F2.inArray(input, _appConfig.views)) {
jQuery('.' + F2.Constants.Css.APP_VIEW, $root)
.addClass('hide')
.filter('[data-f2-view="' + input + '"]', $root)
.removeClass('hide');
_updateHeight();
_events.emit('change', input);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51967
|
train
|
function(appConfig, html) {
var handler = _config.afterAppRender || function(appConfig, html) {
return jQuery(html).appendTo('body');
};
var appContainer = handler(appConfig, html);
if ( !! _config.afterAppRender && !appContainer) {
F2.log('F2.ContainerConfig.afterAppRender() must return the DOM Element that contains the app');
return;
}
else {
// apply APP class
jQuery(appContainer).addClass(F2.Constants.Css.APP);
return appContainer.get(0);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51968
|
train
|
function(appConfig, html) {
// apply APP_CONTAINER class and AppID
html = _outerHtml(jQuery(html).addClass(F2.Constants.Css.APP_CONTAINER + ' ' + appConfig.appId));
// optionally apply wrapper html
if (_config.appRender) {
html = _config.appRender(appConfig, html);
}
return _outerHtml(html);
}
|
javascript
|
{
"resource": ""
}
|
|
q51969
|
train
|
function(appConfig, scriptInfo) {
var handler = _config.appScriptLoadFailed || jQuery.noop;
return handler(appConfig, scriptInfo);
}
|
javascript
|
{
"resource": ""
}
|
|
q51970
|
train
|
function(appConfig) {
// make a copy of the app config to ensure that the original is not modified
appConfig = jQuery.extend(true, {}, appConfig);
// create the instanceId for the app
appConfig.instanceId = appConfig.instanceId || F2.guid();
// default the views if not provided
appConfig.views = appConfig.views || [];
if (!F2.inArray(F2.Constants.Views.HOME, appConfig.views)) {
appConfig.views.push(F2.Constants.Views.HOME);
}
//pass container-defined locale to each app
if (F2.ContainerConfig.locale){
appConfig.containerLocale = F2.ContainerConfig.locale;
}
return appConfig;
}
|
javascript
|
{
"resource": ""
}
|
|
q51971
|
train
|
function(node) {
var appConfig;
if (node) {
var appId = node.getAttribute('data-f2-appid');
var manifestUrl = node.getAttribute('data-f2-manifesturl');
if (appId && manifestUrl) {
appConfig = {
appId: appId,
enableBatchRequests: node.hasAttribute('data-f2-enablebatchrequests'),
isSecure: node.hasAttribute('data-f2-issecure'),
manifestUrl: manifestUrl,
root: node
};
// See if the user passed in a block of serialized json
var contextJson = node.getAttribute('data-f2-context');
if (contextJson) {
try {
appConfig.context = F2.parse(contextJson);
}
catch (e) {
console.warn('F2: "data-f2-context" of node is not valid JSON', '"' + e + '"');
}
}
}
}
return appConfig;
}
|
javascript
|
{
"resource": ""
}
|
|
q51972
|
train
|
function(node) {
var hasNodes = false;
if (node.hasChildNodes()) {
for (var i = 0, len = node.childNodes.length; i < len; i++) {
if (node.childNodes[i].nodeType === 1) {
hasNodes = true;
break;
}
}
}
return hasNodes;
}
|
javascript
|
{
"resource": ""
}
|
|
q51973
|
train
|
function(containerConfig) {
if (!containerConfig.scriptErrorTimeout) {
containerConfig.scriptErrorTimeout = F2.ContainerConfig.scriptErrorTimeout;
}
if (containerConfig.debugMode !== true) {
containerConfig.debugMode = F2.ContainerConfig.debugMode;
}
if (containerConfig.locale && typeof containerConfig.locale == 'string'){
F2.ContainerConfig.locale = containerConfig.locale;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51974
|
train
|
function(appConfig) {
jQuery(appConfig.root).on('click', '.' + F2.Constants.Css.APP_VIEW_TRIGGER + '[' + F2.Constants.Views.DATA_ATTRIBUTE + ']', function(event) {
event.preventDefault();
var view = jQuery(this).attr(F2.Constants.Views.DATA_ATTRIBUTE).toLowerCase();
// handle the special REMOVE view
if (view == F2.Constants.Views.REMOVE) {
F2.removeApp(appConfig.instanceId);
}
else {
appConfig.ui.Views.change(view);
}
});
}
|
javascript
|
{
"resource": ""
}
|
|
q51975
|
train
|
function() {
var resizeTimeout;
var resizeHandler = function() {
F2.Events.emit(F2.Constants.Events.CONTAINER_WIDTH_CHANGE);
};
jQuery(window).on('resize', function() {
clearTimeout(resizeTimeout);
resizeTimeout = setTimeout(resizeHandler, 100);
});
//listen for container-broadcasted locale changes
F2.Events.on(F2.Constants.Events.CONTAINER_LOCALE_CHANGE,function(data){
if (data.locale && typeof data.locale == 'string'){
F2.ContainerConfig.locale = data.locale;
}
});
}
|
javascript
|
{
"resource": ""
}
|
|
q51976
|
train
|
function(node) {
return (
F2.isNativeDOMNode(node) &&
!_hasNonTextChildNodes(node) &&
!!node.getAttribute('data-f2-appid') &&
!!node.getAttribute('data-f2-manifesturl')
);
}
|
javascript
|
{
"resource": ""
}
|
|
q51977
|
train
|
function(appConfig, appContent) {
// instantiate F2.UI
appConfig.ui = new F2.UI(appConfig);
// instantiate F2.App
if (F2.Apps[appConfig.appId] !== undefined) {
if (typeof F2.Apps[appConfig.appId] === 'function') {
// IE
setTimeout(function() {
_apps[appConfig.instanceId].app = new F2.Apps[appConfig.appId](appConfig, appContent, appConfig.root);
if (_apps[appConfig.instanceId].app['init'] !== undefined) {
_apps[appConfig.instanceId].app.init();
}
}, 0);
}
else {
F2.log('app initialization class is defined but not a function. (' + appConfig.appId + ')');
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51978
|
train
|
function(styles, cb) {
// Reduce the list to styles that haven't been loaded
var existingStyles = _findExistingStyles();
styles = jQuery.grep(styles, function(url) {
return url && jQuery.inArray(url, existingStyles) === -1;
});
// Attempt to use the user provided method
if (_config.loadStyles) {
return _config.loadStyles(styles, cb);
}
// load styles, see #101
var stylesFragment = null,
useCreateStyleSheet = !!document.createStyleSheet;
jQuery.each(styles, function(i, resourceUrl) {
if (useCreateStyleSheet) {
document.createStyleSheet(resourceUrl);
}
else {
stylesFragment = stylesFragment || [];
stylesFragment.push('<link rel="stylesheet" type="text/css" href="' + resourceUrl + '"/>');
}
});
if (stylesFragment) {
jQuery('head').append(stylesFragment.join(''));
}
cb();
}
|
javascript
|
{
"resource": ""
}
|
|
q51979
|
train
|
function(scripts, cb) {
// Reduce the list to scripts that haven't been loaded
var existingScripts = _findExistingScripts();
var loadingScripts = Object.keys(_loadingScripts);
scripts = jQuery.grep(scripts, function(url) {
return url && (jQuery.inArray(url, existingScripts) === -1 || jQuery.inArray(url, loadingScripts) !== -1);
});
// Attempt to use the user provided method
if (_config.loadScripts) {
return _config.loadScripts(scripts, cb);
}
if (!scripts.length) {
return cb();
}
var doc = window.document;
var scriptCount = scripts.length;
var scriptsLoaded = 0;
//http://caniuse.com/#feat=script-async
// var supportsAsync = 'async' in doc.createElement('script') || 'MozAppearance' in doc.documentElement.style || window.opera;
var head = doc && (doc['head'] || doc.getElementsByTagName('head')[0]);
// to keep IE from crying, we need to put scripts before any
// <base> elements, but after any <meta>. this should do it:
var insertBeforeEl = head && head.getElementsByTagName('base')[0] || null;
// Check for IE10+ so that we don't rely on onreadystatechange, readyStates for IE6-9
var readyStates = 'addEventListener' in window ? {} : { 'loaded': true, 'complete': true };
// Log and emit event for the failed (400,500) scripts
var _error = function(e) {
setTimeout(function() {
var evtData = {
src: e.target.src,
appId: appConfigs[0].appId
};
// Send error to console
F2.log('Script defined in \'' + evtData.appId + '\' failed to load \'' + evtData.src + '\'');
// TODO: deprecate, see #222
F2.Events.emit(F2.Constants.Events.RESOURCE_FAILED_TO_LOAD, evtData);
if (!_bUsesAppHandlers) {
_appScriptLoadFailed(appConfigs[0], evtData.src);
}
else {
F2.AppHandlers.__trigger(
_sAppHandlerToken,
F2.Constants.AppHandlers.APP_SCRIPT_LOAD_FAILED,
appConfigs[0],
evtData.src
);
}
}, _config.scriptErrorTimeout); // Defaults to 7000
};
var _checkComplete = function() {
// Are we done loading all scripts for this app?
if (++scriptsLoaded === scriptCount) {
// success
cb();
}
};
var _emptyWaitlist = function(resourceKey, errorEvt) {
var waiting,
waitlist = _loadingScripts[resourceKey];
if (!waitlist) {
return;
}
for (var i=0; i<waitlist.length; i++) {
waiting = waitlist [i];
if (errorEvt) {
waiting.error(errorEvt);
} else {
waiting.success();
}
}
_loadingScripts[resourceKey] = null;
};
// Load scripts and eval inlines once complete
jQuery.each(scripts, function(i, e) {
var script = doc.createElement('script'),
resourceUrl = e,
resourceKey = resourceUrl.toLowerCase();
// this script is actively loading, add this app to the wait list
if (_loadingScripts[resourceKey]) {
_loadingScripts[resourceKey].push({
success: _checkComplete,
error: _error
});
return;
}
// create the waitlist
_loadingScripts[resourceKey] = [];
// If in debugMode, add cache buster to each script URL
if (_config.debugMode) {
resourceUrl += '?cachebuster=' + new Date().getTime();
}
// Scripts are loaded asynchronously and executed in order
// in supported browsers: http://caniuse.com/#feat=script-async
script.async = false;
script.type = 'text/javascript';
script.charset = 'utf-8';
script.onerror = function(e) {
_error(e);
_emptyWaitlist(resourceKey, e);
};
// Use a closure for the load event so that we can dereference the original script
script.onload = script.onreadystatechange = function(e) {
e = e || window.event; // For older IE
// detect when it's done loading
// ev.type == 'load' is for all browsers except IE6-9
// IE6-9 need to use onreadystatechange and look for
// el.readyState in {loaded, complete} (yes, we need both)
if (e.type == 'load' || readyStates[script.readyState]) {
// Done, cleanup
script.onload = script.onreadystatechange = script.onerror = '';
// increment and check if scripts are done
_checkComplete();
// empty wait list
_emptyWaitlist(resourceKey);
// Dereference script
script = null;
}
};
//set the src, start loading
script.src = resourceUrl;
//<head> really is the best
head.insertBefore(script, insertBeforeEl);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q51980
|
train
|
function(apps) {
jQuery.each(apps, function(i, a) {
if (_isPlaceholderElement(appConfigs[i].root)) {
jQuery(appConfigs[i].root)
.addClass(F2.Constants.Css.APP)
.append(jQuery(a.html).addClass(F2.Constants.Css.APP_CONTAINER + ' ' + appConfigs[i].appId));
}
else if (!_bUsesAppHandlers) {
// load html and save the root node
appConfigs[i].root = _afterAppRender(appConfigs[i], _appRender(appConfigs[i], a.html));
}
else {
F2.AppHandlers.__trigger(
_sAppHandlerToken,
F2.Constants.AppHandlers.APP_RENDER,
appConfigs[i], // the app config
_outerHtml(jQuery(a.html).addClass(F2.Constants.Css.APP_CONTAINER + ' ' + appConfigs[i].appId))
);
var appId = appConfigs[i].appId,
root = appConfigs[i].root;
if (!root) {
throw ('Root for ' + appId + ' must be a native DOM element and cannot be null or undefined. Check your AppHandler callbacks to ensure you have set App root to a native DOM element.');
}
if (!elementInDocument(root)) {
throw ('App root for ' + appId + ' was not appended to the DOM. Check your AppHandler callbacks to ensure you have rendered the app root to the DOM.');
}
F2.AppHandlers.__trigger(
_sAppHandlerToken,
F2.Constants.AppHandlers.APP_RENDER_AFTER,
appConfigs[i] // the app config
);
if (!F2.isNativeDOMNode(root)) {
throw ('App root for ' + appId + ' must be a native DOM element. Check your AppHandler callbacks to ensure you have set app root to a native DOM element.');
}
}
// init events
_initAppEvents(appConfigs[i]);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q51981
|
train
|
function(appConfig) {
// check for valid app configurations
if (!appConfig.appId) {
F2.log('"appId" missing from app object');
return false;
}
else if (!appConfig.root && !appConfig.manifestUrl) {
F2.log('"manifestUrl" missing from app object');
return false;
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q51982
|
train
|
function() {
if (_config) {
if (_config.xhr) {
if (!(typeof _config.xhr === 'function' || typeof _config.xhr === 'object')) {
throw ('ContainerConfig.xhr should be a function or an object');
}
if (_config.xhr.dataType && typeof _config.xhr.dataType !== 'function') {
throw ('ContainerConfig.xhr.dataType should be a function');
}
if (_config.xhr.type && typeof _config.xhr.type !== 'function') {
throw ('ContainerConfig.xhr.type should be a function');
}
if (_config.xhr.url && typeof _config.xhr.url !== 'function') {
throw ('ContainerConfig.xhr.url should be a function');
}
}
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q51983
|
train
|
function() {
if (!_isInit()) {
F2.log('F2.init() must be called before F2.getContainerState()');
return;
}
return jQuery.map(_apps, function(app) {
return {
appId: app.config.appId
};
});
}
|
javascript
|
{
"resource": ""
}
|
|
q51984
|
train
|
function(parentNode) {
var elements = [],
appConfigs = [],
add = function(e) {
if (!e) { return; }
elements.push(e);
},
addAll = function(els) {
if (!els) { return; }
for (var i = 0, len = els.length; i < len; i++) {
add(els[i]);
}
};
if (!!parentNode && !F2.isNativeDOMNode(parentNode)) {
throw ('"parentNode" must be null or a DOM node');
}
// if the passed in element has a data-f2-appid attribute add
// it to the list of elements but to not search within that
// element for other placeholders
if (parentNode && parentNode.hasAttribute('data-f2-appid')) {
add(parentNode);
} else {
// find placeholders within the parentNode only if
// querySelectorAll exists
parentNode = parentNode || document;
if (parentNode.querySelectorAll) {
addAll(parentNode.querySelectorAll('[data-f2-appid]'));
}
}
for (var i = 0, len = elements.length; i < len; i++) {
var appConfig = _getAppConfigFromElement(elements[i]);
appConfigs.push(appConfig);
}
if (appConfigs.length) {
F2.registerApps(appConfigs);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51985
|
train
|
function() {
jQuery.each(req.apps, function(idx, item) {
item.name = item.name || item.appId;
F2.log('Removed failed ' + item.name + ' app', item);
F2.AppHandlers.__trigger(
_sAppHandlerToken,
F2.Constants.AppHandlers.APP_MANIFEST_REQUEST_FAIL,
item // the app config
);
F2.removeApp(item.instanceId);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q51986
|
whenReady
|
train
|
function whenReady(fn, scope){
if (domIsReady) {
fn.call(scope);
return;
}
domReadyQueue.push(function(){
fn.call(scope);
});
}
|
javascript
|
{
"resource": ""
}
|
q51987
|
getParentObject
|
train
|
function getParentObject(){
var obj = parent;
if (namespace !== "") {
for (var i = 0, ii = namespace.split("."); i < ii.length; i++) {
obj = obj[ii[i]];
}
}
return obj.easyXDM;
}
|
javascript
|
{
"resource": ""
}
|
q51988
|
noConflict
|
train
|
function noConflict(ns){
window.easyXDM = _easyXDM;
namespace = ns;
if (namespace) {
IFRAME_PREFIX = "easyXDM_" + namespace.replace(".", "_") + "_";
}
return easyXDM;
}
|
javascript
|
{
"resource": ""
}
|
q51989
|
getLocation
|
train
|
function getLocation(url){
var m = url.toLowerCase().match(reURI);
var proto = m[2], domain = m[3], port = m[4] || "";
if ((proto == "http:" && port == ":80") || (proto == "https:" && port == ":443")) {
port = "";
}
return proto + "//" + domain + port;
}
|
javascript
|
{
"resource": ""
}
|
q51990
|
resolveUrl
|
train
|
function resolveUrl(url){
// replace all // except the one in proto with /
url = url.replace(reDoubleSlash, "$1/");
// If the url is a valid url we do nothing
if (!url.match(/^(http||https):\/\//)) {
// If this is a relative path
var path = (url.substring(0, 1) === "/") ? "" : location.pathname;
if (path.substring(path.length - 1) !== "/") {
path = path.substring(0, path.lastIndexOf("/") + 1);
}
url = location.protocol + "//" + location.host + path + url;
}
// reduce all 'xyz/../' to just ''
while (reParent.test(url)) {
url = url.replace(reParent, "");
}
return url;
}
|
javascript
|
{
"resource": ""
}
|
q51991
|
train
|
function(){
var cached = {};
var obj = {
a: [1, 2, 3]
}, json = "{\"a\":[1,2,3]}";
if (typeof JSON != "undefined" && typeof JSON.stringify === "function" && JSON.stringify(obj).replace((/\s/g), "") === json) {
// this is a working JSON instance
return JSON;
}
if (Object.toJSON) {
if (Object.toJSON(obj).replace((/\s/g), "") === json) {
// this is a working stringify method
cached.stringify = Object.toJSON;
}
}
if (typeof String.prototype.evalJSON === "function") {
obj = json.evalJSON();
if (obj.a && obj.a.length === 3 && obj.a[2] === 3) {
// this is a working parse method
cached.parse = function(str){
return str.evalJSON();
};
}
}
if (cached.stringify && cached.parse) {
// Only memoize the result if we have valid instance
getJSON = function(){
return cached;
};
return cached;
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
|
q51992
|
createFrame
|
train
|
function createFrame(config){
if (undef(HAS_NAME_PROPERTY_BUG)) {
testForNamePropertyBug();
}
var frame;
// This is to work around the problems in IE6/7 with setting the name property.
// Internally this is set as 'submitName' instead when using 'iframe.name = ...'
// This is not required by easyXDM itself, but is to facilitate other use cases
if (HAS_NAME_PROPERTY_BUG) {
frame = document.createElement("<iframe name=\"" + config.props.name + "\"/>");
}
else {
frame = document.createElement("IFRAME");
frame.name = config.props.name;
}
frame.id = frame.name = config.props.name;
delete config.props.name;
if (typeof config.container == "string") {
config.container = document.getElementById(config.container);
}
if (!config.container) {
// This needs to be hidden like this, simply setting display:none and the like will cause failures in some browsers.
apply(frame.style, {
position: "absolute",
top: "-2000px",
// Avoid potential horizontal scrollbar
left: "0px"
});
config.container = document.body;
}
// HACK: IE cannot have the src attribute set when the frame is appended
// into the container, so we set it to "javascript:false" as a
// placeholder for now. If we left the src undefined, it would
// instead default to "about:blank", which causes SSL mixed-content
// warnings in IE6 when on an SSL parent page.
var src = config.props.src;
config.props.src = "javascript:false";
// transfer properties to the frame
apply(frame, config.props);
frame.border = frame.frameBorder = 0;
frame.allowTransparency = true;
config.container.appendChild(frame);
if (config.onLoad) {
on(frame, "load", config.onLoad);
}
// set the frame URL to the proper value (we previously set it to
// "javascript:false" to work around the IE issue mentioned above)
if(config.usePost) {
var form = config.container.appendChild(document.createElement('form')), input;
form.target = frame.name;
form.action = src;
form.method = 'POST';
if (typeof(config.usePost) === 'object') {
for (var i in config.usePost) {
if (config.usePost.hasOwnProperty(i)) {
if (HAS_NAME_PROPERTY_BUG) {
input = document.createElement('<input name="' + i + '"/>');
} else {
input = document.createElement("INPUT");
input.name = i;
}
input.value = config.usePost[i];
form.appendChild(input);
}
}
}
form.submit();
form.parentNode.removeChild(form);
} else {
frame.src = src;
}
config.props.src = src;
return frame;
}
|
javascript
|
{
"resource": ""
}
|
q51993
|
removeFromStack
|
train
|
function removeFromStack(element){
element.up.down = element.down;
element.down.up = element.up;
element.up = element.down = null;
}
|
javascript
|
{
"resource": ""
}
|
q51994
|
train
|
function(name, del){
if (!_map.hasOwnProperty(name)) {
return;
}
var fn = _map[name];
if (del) {
delete _map[name];
}
return fn;
}
|
javascript
|
{
"resource": ""
}
|
|
q51995
|
addSwf
|
train
|
function addSwf(domain){
// the differentiating query argument is needed in Flash9 to avoid a caching issue where LocalConnection would throw an error.
var url = config.swf + "?host=" + config.isHost;
var id = "easyXDM_swf_" + Math.floor(Math.random() * 10000);
// prepare the init function that will fire once the swf is ready
easyXDM.Fn.set("flash_loaded" + domain.replace(/[\-.]/g, "_"), function(){
easyXDM.stack.FlashTransport[domain].swf = swf = swfContainer.firstChild;
var queue = easyXDM.stack.FlashTransport[domain].queue;
for (var i = 0; i < queue.length; i++) {
queue[i]();
}
queue.length = 0;
});
if (config.swfContainer) {
swfContainer = (typeof config.swfContainer == "string") ? document.getElementById(config.swfContainer) : config.swfContainer;
}
else {
// create the container that will hold the swf
swfContainer = document.createElement('div');
// http://bugs.adobe.com/jira/browse/FP-4796
// http://tech.groups.yahoo.com/group/flexcoders/message/162365
// https://groups.google.com/forum/#!topic/easyxdm/mJZJhWagoLc
apply(swfContainer.style, HAS_FLASH_THROTTLED_BUG && config.swfNoThrottle ? {
height: "20px",
width: "20px",
position: "fixed",
right: 0,
top: 0
} : {
height: "1px",
width: "1px",
position: "absolute",
overflow: "hidden",
right: 0,
top: 0
});
document.body.appendChild(swfContainer);
}
// create the object/embed
var flashVars = "callback=flash_loaded" + encodeURIComponent(domain.replace(/[\-.]/g, "_"))
+ "&proto=" + global.location.protocol
+ "&domain=" + encodeURIComponent(getDomainName(global.location.href))
+ "&port=" + encodeURIComponent(getPort(global.location.href))
+ "&ns=" + encodeURIComponent(namespace);
swfContainer.innerHTML = "<object height='20' width='20' type='application/x-shockwave-flash' id='" + id + "' data='" + url + "'>" +
"<param name='allowScriptAccess' value='always'></param>" +
"<param name='wmode' value='transparent'>" +
"<param name='movie' value='" +
url +
"'></param>" +
"<param name='flashvars' value='" +
flashVars +
"'></param>" +
"<embed type='application/x-shockwave-flash' FlashVars='" +
flashVars +
"' allowScriptAccess='always' wmode='transparent' src='" +
url +
"' height='1' width='1'></embed>" +
"</object>";
}
|
javascript
|
{
"resource": ""
}
|
q51996
|
_getOrigin
|
train
|
function _getOrigin(event){
if (event.origin) {
// This is the HTML5 property
return getLocation(event.origin);
}
if (event.uri) {
// From earlier implementations
return getLocation(event.uri);
}
if (event.domain) {
// This is the last option and will fail if the
// origin is not using the same schema as we are
return location.protocol + "//" + event.domain;
}
throw "Unable to retrieve the origin of the event";
}
|
javascript
|
{
"resource": ""
}
|
q51997
|
train
|
function(event){
if (event.data == config.channel + "-ready") {
// replace the eventlistener
callerWindow = ("postMessage" in frame.contentWindow) ? frame.contentWindow : frame.contentWindow.document;
un(window, "message", waitForReady);
on(window, "message", _window_onMessage);
setTimeout(function(){
pub.up.callback(true);
}, 0);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51998
|
train
|
function(){
// Remove the handler
var w = callerWindow || this;
un(w, "load", onLoad);
easyXDM.Fn.set(config.channel + "_load", _onLoad);
(function test(){
if (typeof w.contentWindow.sendMessage == "function") {
_onReady();
}
else {
setTimeout(test, 50);
}
}());
}
|
javascript
|
{
"resource": ""
}
|
|
q51999
|
_pollHash
|
train
|
function _pollHash(){
if (!_listenerWindow) {
return;
}
var href = _listenerWindow.location.href, hash = "", indexOf = href.indexOf("#");
if (indexOf != -1) {
hash = href.substring(indexOf);
}
if (hash && hash != _lastMsg) {
_handleHash(hash);
}
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.