_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q51800
|
parseSymbol
|
train
|
function parseSymbol () {
if (tokenType === TOKENTYPE.SYMBOL) {
if (token === 'true') {
getToken();
return true;
}
if (token === 'false') {
getToken();
return false;
}
if (token === 'null') {
getToken();
return null;
}
throw createSyntaxError('Unknown symbol "' + token + '"');
}
return parseEnd();
}
|
javascript
|
{
"resource": ""
}
|
q51801
|
parseCircular
|
train
|
function parseCircular(object) {
// if circular references are disabled, just return the refs object
if (!config().circularRefs) {
return object;
}
let pointerPath = parsePointer(object.$ref);
// validate whether the path corresponds with current stack
for (let i = 0; i < pointerPath.length; i++) {
if (pointerPath[i] !== path[i]) {
throw new Error('Invalid circular reference "' + object.$ref + '"');
}
}
return stack[pointerPath.length];
}
|
javascript
|
{
"resource": ""
}
|
q51802
|
stringifyValue
|
train
|
function stringifyValue(value, replacer, space, indent) {
// boolean, null, number, string, or date
if (typeof value === 'boolean' || value instanceof Boolean ||
value === null ||
typeof value === 'number' || value instanceof Number ||
typeof value === 'string' || value instanceof String ||
value instanceof Date) {
return JSON.stringify(value);
}
// lossless number, the secret ingredient :)
if (value && value.isLosslessNumber) {
return value.value;
}
// array
if (Array.isArray(value)) {
return stringifyArray(value, replacer, space, indent);
}
// object (test lastly!)
if (value && typeof value === 'object') {
return stringifyObject(value, replacer, space, indent);
}
return undefined;
}
|
javascript
|
{
"resource": ""
}
|
q51803
|
stringifyArray
|
train
|
function stringifyArray(array, replacer, space, indent) {
let childIndent = space ? (indent + space) : undefined;
let str = space ? '[\n' : '[';
// check for circular reference
if (isCircular(array)) {
return stringifyCircular(array, replacer, space, indent);
}
// add this array to the stack
const stackIndex = stack.length;
stack[stackIndex] = array;
for (let i = 0; i < array.length; i++) {
let key = i + '';
let item = (typeof replacer === 'function')
? replacer.call(array, key, array[i])
: array[i];
if (space) {
str += childIndent;
}
if (typeof item !== 'undefined' && typeof item !== 'function') {
path[stackIndex] = key;
str += stringifyValue(item, replacer, space, childIndent);
}
else {
str += 'null'
}
if (i < array.length - 1) {
str += space ? ',\n' : ',';
}
}
// remove current entry from the stack
stack.length = stackIndex;
path.length = stackIndex;
str += space ? ('\n' + indent + ']') : ']';
return str;
}
|
javascript
|
{
"resource": ""
}
|
q51804
|
stringifyObject
|
train
|
function stringifyObject(object, replacer, space, indent) {
let childIndent = space ? (indent + space) : undefined;
let first = true;
let str = space ? '{\n' : '{';
if (typeof object.toJSON === 'function') {
return stringify(object.toJSON(), replacer, space);
}
// check for circular reference
if (isCircular(object)) {
return stringifyCircular(object, replacer, space, indent);
}
// add this object to the stack
const stackIndex = stack.length;
stack[stackIndex] = object;
for (let key in object) {
if (object.hasOwnProperty(key)) {
let value = (typeof replacer === 'function')
? replacer.call(object, key, object[key])
: object[key];
if (includeProperty(key, value, replacer)) {
if (first) {
first = false;
}
else {
str += space ? ',\n' : ',';
}
str += space
? (childIndent + '"' + key + '": ')
: ('"' + key + '":');
path[stackIndex] = key;
str += stringifyValue(value, replacer, space, childIndent);
}
}
}
// remove current entry from the stack
stack.length = stackIndex;
path.length = stackIndex;
str += space ? ('\n' + indent + '}') : '}';
return str;
}
|
javascript
|
{
"resource": ""
}
|
q51805
|
stringifyCircular
|
train
|
function stringifyCircular (value, replacer, space, indent) {
if (!config().circularRefs) {
throw new Error('Circular reference at "' + stringifyPointer(path) + '"');
}
let pathIndex = stack.indexOf(value);
let circular = {
$ref: stringifyPointer(path.slice(0, pathIndex))
};
return stringifyObject(circular, replacer, space, indent);
}
|
javascript
|
{
"resource": ""
}
|
q51806
|
includeProperty
|
train
|
function includeProperty (key, value, replacer) {
return typeof value !== 'undefined'
&& typeof value !== 'function'
&& (!Array.isArray(replacer) || contains(replacer, key));
}
|
javascript
|
{
"resource": ""
}
|
q51807
|
reviveValue
|
train
|
function reviveValue (context, key, value, reviver) {
if (Array.isArray(value)) {
return reviver.call(context, key, reviveArray(value, reviver));
}
else if (value && typeof value === 'object' && !value.isLosslessNumber) {
// note the special case for LosslessNumber,
// we don't want to iterate over the internals of a LosslessNumber
return reviver.call(context, key, reviveObject(value, reviver))
}
else {
return reviver.call(context, key, value)
}
}
|
javascript
|
{
"resource": ""
}
|
q51808
|
reviveObject
|
train
|
function reviveObject (object, reviver) {
let revived = {};
for (let key in object) {
if (object.hasOwnProperty(key)) {
revived[key] = reviveValue(object, key, object[key], reviver);
}
}
return revived;
}
|
javascript
|
{
"resource": ""
}
|
q51809
|
reviveArray
|
train
|
function reviveArray (array, reviver) {
let revived = [];
for (let i = 0; i < array.length; i++) {
revived[i] = reviveValue(array, i + '', array[i], reviver);
}
return revived;
}
|
javascript
|
{
"resource": ""
}
|
q51810
|
commentNode
|
train
|
function commentNode(el, vnode) {
const comment = document.createComment(' ')
Object.defineProperty(comment, 'setAttribute', {
value: () => undefined
})
vnode.text = ' '
vnode.elm = comment
vnode.isComment = true
vnode.tag = undefined
vnode.data.directives = undefined
if (vnode.componentInstance) {
vnode.componentInstance.$el = comment
}
if (el.parentNode) {
el.parentNode.replaceChild(comment, el)
}
}
|
javascript
|
{
"resource": ""
}
|
q51811
|
train
|
function(value, currentKeyArray) {
var type = typeof value;
var pushAnElement = function() {
var access = currentKeyArray.reduce(buildColumnName);
if (mongoModelMap[access]) { return; }
mongoModelMap[access] = access;
mongoModel.push({
displayName: access,
access: access,
type: type
});
};
switch (type) {
case "boolean":
case "number":
case "string":
return pushAnElement();
case "object":
if (!value) {
return pushAnElement();
}
switch(value.constructor) {
case Array:
return searchArray(value, currentKeyArray.slice());
case Object:
return searchObject(value, currentKeyArray.slice());
case Date:
type = 'date';
return pushAnElement();
default:
if (value.constructor.name === "ObjectID") {
type = "ObjectID";
return pushAnElement();
} else if (value.constructor.name === "InternalCache") {
// Skip this. Internal mongoose type.
// Isn't part of the document.
return;
} else {
console.log("Unknown Object Type:", value.constructor.name);
}
}
break;
case "symbol":
case "function":
return;
default:
break;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51812
|
toggleFullScreen
|
train
|
function toggleFullScreen(editor) {
// Set fullscreen
var cm = editor.codemirror;
cm.setOption('fullScreen', !cm.getOption('fullScreen'));
// Prevent scrolling on body during fullscreen active
if (cm.getOption('fullScreen')) {
saved_overflow = document.body.style.overflow;
document.body.style.overflow = 'hidden';
} else {
document.body.style.overflow = saved_overflow;
}
// Update toolbar class
var wrap = cm.getWrapperElement();
if (!/fullscreen/.test(wrap.previousSibling.className)) {
wrap.previousSibling.className += ' fullscreen';
} else {
wrap.previousSibling.className = wrap.previousSibling.className.replace(/\s*fullscreen\b/, '');
}
// Update toolbar button
if (editor.toolbarElements.fullscreen) {
var toolbarButton = editor.toolbarElements.fullscreen;
if (!/active/.test(toolbarButton.className)) {
toolbarButton.className += ' active';
} else {
toolbarButton.className = toolbarButton.className.replace(/\s*active\s*/g, '');
}
}
// Hide side by side if needed
var sidebyside = cm.getWrapperElement().nextSibling;
if (/editor-preview-active-side/.test(sidebyside.className))
toggleSideBySide(editor);
}
|
javascript
|
{
"resource": ""
}
|
q51813
|
toggleSideBySide
|
train
|
function toggleSideBySide(editor) {
var cm = editor.codemirror;
var wrapper = cm.getWrapperElement();
var preview = wrapper.nextSibling;
var toolbarButton = editor.toolbarElements['side-by-side'];
var useSideBySideListener = false;
if (/editor-preview-active-side/.test(preview.className)) {
preview.className = preview.className.replace(
/\s*editor-preview-active-side\s*/g, ''
);
toolbarButton.className = toolbarButton.className.replace(/\s*active\s*/g, '');
wrapper.className = wrapper.className.replace(/\s*CodeMirror-sided\s*/g, ' ');
} else {
// When the preview button is clicked for the first time,
// give some time for the transition from editor.css to fire and the view to slide from right to left,
// instead of just appearing.
setTimeout(function () {
if (!cm.getOption('fullScreen'))
toggleFullScreen(editor);
preview.className += ' editor-preview-active-side';
}, 1);
toolbarButton.className += ' active';
wrapper.className += ' CodeMirror-sided';
useSideBySideListener = true;
}
// Hide normal preview if active
var previewNormal = wrapper.lastChild;
if (/editor-preview-active/.test(previewNormal.className)) {
previewNormal.className = previewNormal.className.replace(
/\s*editor-preview-active\s*/g, ''
);
var toolbar = editor.toolbarElements.preview;
var toolbar_div = wrapper.previousSibling;
toolbar.className = toolbar.className.replace(/\s*active\s*/g, '');
toolbar_div.className = toolbar_div.className.replace(/\s*disabled-for-preview*/g, '');
}
var sideBySideRenderingFunction = function () {
preview.innerHTML = editor.options.previewRender(editor.value(), preview);
};
if (!cm.sideBySideRenderingFunction) {
cm.sideBySideRenderingFunction = sideBySideRenderingFunction;
}
if (useSideBySideListener) {
preview.innerHTML = editor.options.previewRender(editor.value(), preview);
cm.on('update', cm.sideBySideRenderingFunction);
} else {
cm.off('update', cm.sideBySideRenderingFunction);
}
// Refresh to fix selection being off (#309)
cm.refresh();
}
|
javascript
|
{
"resource": ""
}
|
q51814
|
addShutdown
|
train
|
function addShutdown(server) {
var connections = {};
var isShuttingDown = false;
var connectionCounter = 0;
function destroy(socket, force) {
if (force || (socket._isIdle && isShuttingDown)) {
socket.destroy();
delete connections[socket._connectionId];
}
};
function onConnection(socket) {
var id = connectionCounter++;
socket._isIdle = true;
socket._connectionId = id;
connections[id] = socket;
socket.on('close', function() {
delete connections[id];
});
};
server.on('request', function(req, res) {
req.socket._isIdle = false;
res.on('finish', function() {
req.socket._isIdle = true;
destroy(req.socket);
});
});
server.on('connection', onConnection);
server.on('secureConnection', onConnection);
function shutdown(force, cb) {
isShuttingDown = true;
server.close(function(err) {
if (cb) {
process.nextTick(function() { cb(err); });
}
});
Object.keys(connections).forEach(function(key) {
destroy(connections[key], force);
});
};
server.shutdown = function(cb) {
shutdown(false, cb);
};
server.forceShutdown = function(cb) {
shutdown(true, cb);
};
return server;
}
|
javascript
|
{
"resource": ""
}
|
q51815
|
join
|
train
|
function join (options) {
if (options.peerId.length !== 12) {
return this.emit('we-ready', new Error('Unvalid peerId length, must be 48 bits, received: ' + options.peerId).toString())
}
if (peerTable[options.peerId]) {
return this.emit('we-ready', new Error('peerId already exists').toString())
}
peerTable[options.peerId] = {
socket: this,
notify: typeof options.notify === 'boolean' && options.notify === true,
fingers: options.fingers || {
'0': {
ideal: idealFinger(new Id(options.peerId), '0').toHex(),
current: undefined
}}
}
log('peer joined: ' + options.peerId)
this.emit('we-ready')
if (Object.keys(peerTable).length === 1) {
return log('This was the first peer join, do nothing')
}
notify()
if (peerTable[options.peerId].fingers['0'].current === undefined) {
if (!peerTable[options.peerId].notify) {
return
}
updateFinger(options.peerId, '0')
}
// notify if to other peers if this new Peer is a best finger for them
function notify () {
const newId = options.peerId
const peerIds = Object.keys(peerTable)
// check for all the peers
// if same id skip
// if notify === false skip
// check the first finger that matches the criteria for ideal or next to ideal
peerIds.forEach((peerId) => {
if (newId === peerId) {
return // skip ourselves
}
if (!peerTable[peerId].notify) {
return // skip if it doesn't want to be notified of available peers
}
// if it had none, notify to get a successor
if (peerTable[peerId].fingers['0'].current === undefined) {
peerTable[peerId].fingers['0'].current = newId
peerTable[peerId].socket.emit('we-update-finger', {
row: '0',
id: newId
})
return
}
const rows = Object.keys(peerTable[peerId].fingers)
// find the first row that could use this finger
rows.some((row) => {
const finger = peerTable[peerId].fingers[row]
const bestCandidate = fingerBestFit(
new Id(peerId),
new Id(finger.ideal),
new Id(finger.current),
new Id(newId))
if (bestCandidate) {
peerTable[peerId].fingers[row].current = newId
peerTable[peerId].socket.emit('we-update-finger', {
row: row,
id: newId
})
return true
}
})
})
}
}
|
javascript
|
{
"resource": ""
}
|
q51816
|
notify
|
train
|
function notify () {
const newId = options.peerId
const peerIds = Object.keys(peerTable)
// check for all the peers
// if same id skip
// if notify === false skip
// check the first finger that matches the criteria for ideal or next to ideal
peerIds.forEach((peerId) => {
if (newId === peerId) {
return // skip ourselves
}
if (!peerTable[peerId].notify) {
return // skip if it doesn't want to be notified of available peers
}
// if it had none, notify to get a successor
if (peerTable[peerId].fingers['0'].current === undefined) {
peerTable[peerId].fingers['0'].current = newId
peerTable[peerId].socket.emit('we-update-finger', {
row: '0',
id: newId
})
return
}
const rows = Object.keys(peerTable[peerId].fingers)
// find the first row that could use this finger
rows.some((row) => {
const finger = peerTable[peerId].fingers[row]
const bestCandidate = fingerBestFit(
new Id(peerId),
new Id(finger.ideal),
new Id(finger.current),
new Id(newId))
if (bestCandidate) {
peerTable[peerId].fingers[row].current = newId
peerTable[peerId].socket.emit('we-update-finger', {
row: row,
id: newId
})
return true
}
})
})
}
|
javascript
|
{
"resource": ""
}
|
q51817
|
updateFinger
|
train
|
function updateFinger (peerId, row) {
var availablePeers = Object.keys(peerTable)
availablePeers.splice(availablePeers.indexOf(peerId), 1)
// if row hasn't been checked before
if (!peerTable[peerId].fingers[row]) {
peerTable[peerId].fingers[row] = {
ideal: idealFinger(new Id(peerId), row).toHex(),
current: undefined
}
}
var best = availablePeers.shift()
availablePeers.forEach((otherId) => {
const isFBT = fingerBestFit(
new Id(peerId),
new Id(peerTable[peerId].fingers[row].ideal),
new Id(best),
new Id(otherId))
if (isFBT) {
best = otherId
}
})
if (best === peerTable[peerId].fingers[row].current) {
return // nevermind then
}
peerTable[peerId].fingers[row].current = best
peerTable[peerId].socket.emit('we-update-finger', {
row: row,
id: best
})
}
|
javascript
|
{
"resource": ""
}
|
q51818
|
forward
|
train
|
function forward (offer) {
if (offer.answer) {
peerTable[offer.srcId].socket
.emit('we-handshake', offer)
return
}
peerTable[offer.dstId].socket
.emit('we-handshake', offer)
}
|
javascript
|
{
"resource": ""
}
|
q51819
|
connect
|
train
|
function connect (url, callback) {
io = SocketIO.connect(url)
io.on('connect', callback)
}
|
javascript
|
{
"resource": ""
}
|
q51820
|
join
|
train
|
function join (callback) {
log('connected to sig-server')
io.emit('ss-join', {
peerId: config.peerId.toHex(),
notify: true
})
io.on('we-update-finger', fingerTable.updateFinger(io))
io.on('we-handshake', channel.accept(io))
io.once('we-ready', callback)
}
|
javascript
|
{
"resource": ""
}
|
q51821
|
closest
|
train
|
function closest(el, fn) {
return el && (fn(el) ? el : closest(el.parentNode, fn));
}
|
javascript
|
{
"resource": ""
}
|
q51822
|
main
|
train
|
function main(contents, options) {
if (options === void 0) { options = { tagNames: [] }; }
var sourceFile = ts.createSourceFile("file.ts", contents, ts.ScriptTarget.ES2015,
/*setParentNodes */ false, ts.ScriptKind.TSX);
var dm = findMethodCallsWithName(sourceFile, "defineMessages", extractMessagesForDefineMessages);
// TODO formatMessage might not be the initializer for a VarDecl
// eg console.log(formatMessage(...))
var fm = findMethodCallsWithName(sourceFile, "formatMessage", extractMessagesForFormatMessage);
var results = [];
var tagNames = ["FormattedMessage"].concat(options.tagNames);
tagNames.forEach(function (tagName) {
var elements = findJsxOpeningLikeElementsWithName(sourceFile, tagName);
// convert JsxOpeningLikeElements to Message maps
var jsxMessages = getElementsMessages(elements);
results.push.apply(results, jsxMessages);
});
return results.concat(dm).concat(fm);
}
|
javascript
|
{
"resource": ""
}
|
q51823
|
getElementsMessages
|
train
|
function getElementsMessages(elements) {
return elements
.map(function (element) {
var msg = {};
if (element.attributes) {
element.attributes.properties.forEach(function (attr) {
if (!ts.isJsxAttribute(attr) || !attr.initializer) {
// Either JsxSpreadAttribute, or JsxAttribute without initializer.
return;
}
var key = attr.name.text;
var init = attr.initializer;
var text;
if (ts.isStringLiteral(init)) {
text = init.text;
}
else if (ts.isJsxExpression(init)) {
if (init.expression &&
(ts.isStringLiteral(init.expression) ||
ts.isNoSubstitutionTemplateLiteral(init.expression))) {
text = init.expression.text;
}
else {
// Either the JsxExpression has no expression (?)
// or a non-StringLiteral expression.
return;
}
}
else {
// Should be a StringLiteral or JsxExpression, but it's not!
return;
}
copyIfMessageKey(msg, key, text);
});
}
return isValidMessage(msg) ? msg : null;
})
.filter(notNull);
}
|
javascript
|
{
"resource": ""
}
|
q51824
|
getRelatedModelFields
|
train
|
function getRelatedModelFields(User) {
const fields = {};
_.forEach(User.relations, (relation) => {
const model = relation.modelTo;
fields[_.lowerFirst(relation.name)] = {
args: Object.assign({
where: {
type: getType('JSON')
},
order: {
type: getType('JSON')
},
}, connectionArgs),
type: getConnection(model.modelName),
resolve: (obj, args, context) => {
if (!context.req.accessToken) return null;
return findUserFromAccessToken(context.req.accessToken, User)
.then(user => connectionFromPromisedArray(findAllRelated(User, user, relation.name, args, context), args, model));
}
};
});
return fields;
}
|
javascript
|
{
"resource": ""
}
|
q51825
|
findUserFromAccessToken
|
train
|
function findUserFromAccessToken(accessToken, UserModel) {
if (!accessToken) return null;
return UserModel.findById(accessToken.userId).then((user) => {
if (!user) return Promise.reject('No user with this access token was found.');
return Promise.resolve(user);
});
}
|
javascript
|
{
"resource": ""
}
|
q51826
|
getMeField
|
train
|
function getMeField(User) {
return {
me: {
type: getType(User.modelName),
resolve: (obj, args, { app, req }) => {
if (!req.accessToken) return null;
return findUserFromAccessToken(req.accessToken, User);
}
}
};
}
|
javascript
|
{
"resource": ""
}
|
q51827
|
checkAccess
|
train
|
function checkAccess({ accessToken, id, model, method, options, ctx }) {
return new Promise((resolve, reject) => {
// ignore checking if does not enable auth
if (model.app.isAuthEnabled) {
if (!model.app.models.ACL) {
console.log('ACL has not been setup, skipping access check.')
resolve(true);
} else {
model.checkAccess(accessToken, id, method, ctx,
((err, allowed) => {
if (err)
reject(err);
else if (allowed)
resolve(allowed);
else
reject(`ACCESS_DENIED`);
}));
}
} else {
resolve(true);
}
})
}
|
javascript
|
{
"resource": ""
}
|
q51828
|
isRemoteMethodAllowed
|
train
|
function isRemoteMethodAllowed(method, allowedVerbs) {
let httpArray = method.http;
if (!_.isArray(method.http)) {
httpArray = [method.http];
}
const results = httpArray.map((item) => {
const verb = item.verb;
if (allowedVerbs && !_.includes(allowedVerbs, verb)) {
return false;
}
return true;
});
const result = _.includes(results, true);
return result;
}
|
javascript
|
{
"resource": ""
}
|
q51829
|
getRemoteMethodInput
|
train
|
function getRemoteMethodInput(method, isConnection = false) {
const acceptingParams = {};
method.accepts.forEach((param) => {
let paramType = '';
if (typeof param.type === 'object') {
paramType = 'JSON';
} else if (!SCALARS[param.type.toLowerCase()]) {
paramType = `${param.type}Input`;
} else {
paramType = _.upperFirst(param.type);
}
if (param.arg) {
acceptingParams[param.arg] = {
type: getType(exchangeTypes[paramType] || paramType)
};
}
});
return (isConnection) ? Object.assign({}, acceptingParams, connectionArgs) : acceptingParams;
}
|
javascript
|
{
"resource": ""
}
|
q51830
|
getRemoteMethodOutput
|
train
|
function getRemoteMethodOutput(method) {
let returnType = 'JSON';
let list = false;
if (method.returns && method.returns[0]) {
if (!SCALARS[method.returns[0].type] && typeof method.returns[0].type !== 'object') {
returnType = `${method.returns[0].type}`;
} else {
returnType = `${method.returns[0].type}`;
if (_.isArray(method.returns[0].type) && _.isString(method.returns[0].type[0])) {
returnType = method.returns[0].type[0];
list = true;
} else if (typeof method.returns[0].type === 'object') {
returnType = 'JSON';
}
}
}
let type = exchangeTypes[returnType] || returnType;
type = (list) ? getConnection(type) : getType(type);
type = type || getType('JSON');
return {
type,
list
};
}
|
javascript
|
{
"resource": ""
}
|
q51831
|
mapRelation
|
train
|
function mapRelation(rel, modelName, relName) {
let acceptingParams = Object.assign({}, {
filter: {
generated: false,
type: 'JSON'
}
}, connectionArgs);
types[modelName].meta.fields[relName] = {
generated: true,
meta: {
relation: true,
connection: true,
relationType: rel.type,
isMany: isManyRelation(rel.type),
embed: rel.embed,
type: rel.modelTo.modelName,
args: acceptingParams,
},
resolve: (obj, args, context, info) => {
const ctxOptions = { accessToken: context.req.accessToken }
const modelId = args && args.id;
const method = rel.modelTo.sharedClass.findMethodByName('find');
// TODO: ...
return new Promise((resolve, reject) => { resolve(true) }).then(() => {
let params = {};
_.forEach(acceptingParams, (param, name) => {
if (typeof args[name] !== 'undefined' && Object.keys(args[name]).length > 0) {
_.merge(params, _.cloneDeep(args[name]));
}
});
if (isManyRelation(rel.type) === true) {
return connectionFromPromisedArray(findRelatedMany(rel, obj, params, context), args, rel.modelTo);
} else {
return findRelatedOne(rel, obj, params, context);
}
// let wrap = promisify(model[method.name](...params, ctxOptions));
// if (typeObj.list) {
// return connectionFromPromisedArray(wrap, args, model);
// } else {
// return wrap;
// }
}).catch((err) => {
throw err;
});
}
};
}
|
javascript
|
{
"resource": ""
}
|
q51832
|
mapType
|
train
|
function mapType(model) {
types[model.modelName] = {
generated: false,
name: model.modelName,
meta: {
category: 'TYPE',
fields: {}
}
};
_.forEach(model.definition.properties, (property, key) => {
mapProperty(model, property, model.modelName, key);
});
_.forEach(sharedRelations(model), (rel) => {
mapRelation(rel, model.modelName, rel.name);
});
}
|
javascript
|
{
"resource": ""
}
|
q51833
|
mapInputType
|
train
|
function mapInputType(model) {
const modelName = `${model.modelName}Input`;
types[modelName] = {
generated: false,
name: modelName,
meta: {
category: 'TYPE',
input: true,
fields: {}
}
};
_.forEach(model.definition.properties, (property, key) => {
mapProperty(model, property, modelName, key, true);
});
}
|
javascript
|
{
"resource": ""
}
|
q51834
|
generateTypeDefs
|
train
|
function generateTypeDefs(models) {
types = Object.assign({}, types, getCustomTypeDefs());
_.forEach(models, (model) => {
mapType(model);
mapInputType(model);
});
return types;
}
|
javascript
|
{
"resource": ""
}
|
q51835
|
generateType
|
train
|
function generateType(name, def) {
// const def = _.find(getTypeDefs(), (o, n) => n === name);
if (!name || !def) {
return null;
}
// If def doesnt have {generated: false} prop, then it is
// already a type. Hence return it as is.
if (def.generated !== false) {
return def;
}
def = _.clone(def);
processIdField(name, def);
if (def.meta.category === 'TYPE') {
def.fields = () => generateTypeFields(def);
if (def.meta.input === true) {
return new GraphQLInputObjectType(def);
}
return new GraphQLObjectType(def);
} else if (def.category === 'ENUM') {
const values = {};
_.forEach(def.values, (val) => { values[val] = { value: val }; });
def.values = values;
return new GraphQLEnumType(def);
}
}
|
javascript
|
{
"resource": ""
}
|
q51836
|
take
|
train
|
function take (delimeter) {
var start, last, res;
last = this.last;
start = this.ptr;
while (true) {
if (this.ptr > last) {
// good part
res = this.buf.slice(start, this.ptr);
return res;
}
if (this.buf[this.ptr].search(delimeter) === 0) {
// good part
res = this.buf.slice(start, this.ptr);
this.ptr++;
return res;
}
this.ptr++;
}
}
|
javascript
|
{
"resource": ""
}
|
q51837
|
train
|
function () {
var s = document.createElement('span')
/*
* We need this css as in some weird browser this
* span elements shows up for a microSec which creates a
* bad user experience
*/
s.style.position = 'absolute'
s.style.left = '-9999px'
s.style.fontSize = testSize
// css font reset to reset external styles
s.style.fontStyle = 'normal'
s.style.fontWeight = 'normal'
s.style.letterSpacing = 'normal'
s.style.lineBreak = 'auto'
s.style.lineHeight = 'normal'
s.style.textTransform = 'none'
s.style.textAlign = 'left'
s.style.textDecoration = 'none'
s.style.textShadow = 'none'
s.style.whiteSpace = 'normal'
s.style.wordBreak = 'normal'
s.style.wordSpacing = 'normal'
s.innerHTML = testString
return s
}
|
javascript
|
{
"resource": ""
}
|
|
q51838
|
train
|
function (fontToDetect, baseFont) {
var s = createSpan()
s.style.fontFamily = "'" + fontToDetect + "'," + baseFont
return s
}
|
javascript
|
{
"resource": ""
}
|
|
q51839
|
train
|
function () {
var spans = []
for (var index = 0, length = baseFonts.length; index < length; index++) {
var s = createSpan()
s.style.fontFamily = baseFonts[index]
baseFontsDiv.appendChild(s)
spans.push(s)
}
return spans
}
|
javascript
|
{
"resource": ""
}
|
|
q51840
|
train
|
function () {
var spans = {}
for (var i = 0, l = fontList.length; i < l; i++) {
var fontSpans = []
for (var j = 0, numDefaultFonts = baseFonts.length; j < numDefaultFonts; j++) {
var s = createSpanWithFonts(fontList[i], baseFonts[j])
fontsDiv.appendChild(s)
fontSpans.push(s)
}
spans[fontList[i]] = fontSpans // Stores {fontName : [spans for that font]}
}
return spans
}
|
javascript
|
{
"resource": ""
}
|
|
q51841
|
train
|
function (fontSpans) {
var detected = false
for (var i = 0; i < baseFonts.length; i++) {
detected = (fontSpans[i].offsetWidth !== defaultWidth[baseFonts[i]] || fontSpans[i].offsetHeight !== defaultHeight[baseFonts[i]])
if (detected) {
return detected
}
}
return detected
}
|
javascript
|
{
"resource": ""
}
|
|
q51842
|
train
|
function(data) {
// use the supplied constructor
// This allows a user to pass in instance: function Audience() {}
// and have the Audience() function return an instance of Audience
var instance = new InstanceConstructor();
var instanceData = _.extend(
{},
_.cloneDeep(config.fields || {}),
_.cloneDeep(data || {})
);
// populate the instanceor
_.extend(instance, instanceData);
return instance;
}
|
javascript
|
{
"resource": ""
}
|
|
q51843
|
train
|
function(instance) {
var loadData = function(data) {
return _.extend(instance, data);
};
if (instance.id) {
// do PUT save
return api
.one(config.entity, instance.id)
.put(instance)
.then(loadData, console.error);
} else {
// no id is set, do a POST
var endpoint = api;
if (config.parent) {
endpoint.one(config.parent.entity, instance[config.parent.key]);
}
endpoint.all(config.entity);
return endpoint
.post(instance)
.then(loadData, console.error);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51844
|
train
|
function(entityId) {
return api
.one(config.entity, entityId)
.get()
.then(this.create, console.error);
}
|
javascript
|
{
"resource": ""
}
|
|
q51845
|
train
|
function(filters) {
filters = _.clone(filters || {});
var endpoint = api;
if (config.parent && !filters[config.parent.key]) {
throw new Error("fetchAll: must supply the parent.key as a filter to fetch all entities");
}
if (config.parent) {
endpoint.one(config.parent.entity, filters[config.parent.key]);
// since the filtering is happening in the endpoint url we dont need filters
delete filters[config.parent.key];
}
return endpoint
.all(config.entity)
.filter(filters)
.get()
.then(function(results) {
return results.map(this.create);
// }.bind(this), console.error);
}.bind(this), function(err) {console.log(err); throw new Error(err);});
}
|
javascript
|
{
"resource": ""
}
|
|
q51846
|
train
|
function(instance) {
if (!instance.id) {
throw new Error("delete(): `id` must be defined");
}
return api
.one(config.entity, instance.id)
.delete();
}
|
javascript
|
{
"resource": ""
}
|
|
q51847
|
recursiveStyle
|
train
|
function recursiveStyle(data, styleName) {
var style;
if (!styleName) {
styleName = 'style';
style = data;
} else {
style = data[styleName];
}
//Instead of defining one style for the layer, we've been given a style function
//to apply to each feature.
if (styleName === 'style' && data instanceof Function) {
return data;
}
if (!(style instanceof Object)) {
return style;
}
var styleObject;
if (Object.prototype.toString.call(style) === '[object Object]') {
styleObject = {};
var styleConstructor = styleMap[styleName];
if (styleConstructor && style instanceof styleConstructor) {
return style;
}
Object.getOwnPropertyNames(style).forEach(function(val, idx, array) {
//Consider the case
//image: {
// circle: {
// fill: {
// color: 'red'
// }
// }
//
//An ol.style.Circle is an instance of ol.style.Image, so we do not want to construct
//an Image and then construct a Circle. We assume that if we have an instanceof
//relationship, that the JSON parent has exactly one child.
//We check to see if an inheritance relationship exists.
//If it does, then for the parent we create an instance of the child.
var valConstructor = styleMap[val];
if (styleConstructor && valConstructor &&
valConstructor.prototype instanceof styleMap[styleName]) {
console.assert(array.length === 1, 'Extra parameters for ' + styleName);
styleObject = recursiveStyle(style, val);
return optionalFactory(styleObject, valConstructor);
} else {
styleObject[val] = recursiveStyle(style, val);
// if the value is 'text' and it contains a String, then it should be interpreted
// as such, 'cause the text style might effectively contain a text to display
if (val !== 'text' && typeof styleObject[val] !== 'string') {
styleObject[val] = optionalFactory(styleObject[val], styleMap[val]);
}
}
});
} else {
styleObject = style;
}
return optionalFactory(styleObject, styleMap[styleName]);
}
|
javascript
|
{
"resource": ""
}
|
q51848
|
train
|
function(seed) {
if (!values.isNumber(seed)) {
throw errors.typeErrorFunction('Math.seed', 'number', seed);
}
_random = seedrandom(seed);
return null;
}
|
javascript
|
{
"resource": ""
}
|
|
q51849
|
optimize
|
train
|
function optimize(graph, Juttle) {
var reads = _.where(graph.get_roots(), {type: 'ReadProc'});
_.each(reads, function(node) {optimize_read(node, graph, Juttle);});
}
|
javascript
|
{
"resource": ""
}
|
q51850
|
addVisitFunction
|
train
|
function addVisitFunction(type) {
ASTVisitor.prototype['visit' + type] = function(node) {
var self = this;
var extraArgs = Array.prototype.slice.call(arguments, 1);
if (DEBUG) {
checkNode(node);
}
NODE_CHILDREN[type].forEach(function(property) {
var value = node[property];
if (_.isArray(value)) {
value.forEach(function(item) {
if (item !== null) {
self.visit.apply(self, [item].concat(extraArgs));
}
});
} else if (value !== null && value !== undefined) {
self.visit.apply(self, [value].concat(extraArgs));
}
});
};
}
|
javascript
|
{
"resource": ""
}
|
q51851
|
implicit_views
|
train
|
function implicit_views(g, options) {
var default_view = options.default_view || 'table';
var leaves = g.get_leaves();
var table;
_.each(leaves, function(node) {
if (!is_sink(node)) {
table = g.add_node('View', default_view);
g.add_edge(node, table);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q51852
|
locate
|
train
|
function locate(fn, location) {
try {
return fn();
} catch (e) {
if (e instanceof JuttleError && !e.info.location) {
e.info.location = location;
}
throw e;
}
}
|
javascript
|
{
"resource": ""
}
|
q51853
|
train
|
function(value) {
switch (typeof value) {
case 'boolean':
return 'Boolean';
case 'number':
return 'Number';
case 'string':
return 'String';
case 'object':
if (value === null) {
return 'Null';
} else {
switch (Object.prototype.toString.call(value)) {
case '[object RegExp]':
return 'RegExp';
case '[object Array]':
return 'Array';
case '[object Object]':
switch (value.constructor) {
case JuttleMoment:
if (value.moment) {
return 'Date';
}
if (value.duration) {
return 'Duration';
}
break; // silence ESLint
case Filter:
return 'Filter';
case Object:
return 'Object';
}
}
}
}
throw new Error('Invalid Juttle value: ' + value + '.');
}
|
javascript
|
{
"resource": ""
}
|
|
q51854
|
train
|
function(a, b) {
var self = this;
function equalArrays(a, b) {
if (a.length !== b.length) {
return false;
}
var length = a.length;
var i;
for (i = 0; i < length; i++) {
if (!self.equal(a[i], b[i])) {
return false;
}
}
return true;
}
function equalObjects(a, b) {
var keysA = Object.keys(a);
var keysB = Object.keys(b);
keysA.sort();
keysB.sort();
if (keysA.length !== keysB.length) {
return false;
}
var length = keysA.length;
var i;
var key;
for (i = 0; i < length; i++) {
if (keysA[i] !== keysB[i]) {
return false;
}
key = keysA[i];
if (!self.equal(a[key], b[key])) {
return false;
}
}
return true;
}
var typeA = this.typeOf(a);
var typeB = this.typeOf(b);
if (typeA !== typeB) {
return false;
}
switch (typeA) {
case 'Null':
case 'Boolean':
case 'Number':
case 'String':
case 'Filter':
return a === b;
case 'RegExp':
return a.source === b.source
&& a.global === b.global
&& a.multiline === b.multiline
&& a.ignoreCase === b.ignoreCase;
case 'Date':
case 'Duration':
return JuttleMoment.eq(a, b);
case 'Array':
return equalArrays(a, b);
case 'Object':
return equalObjects(a, b);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51855
|
train
|
function(value) {
switch (values.typeOf(value)) {
case 'Null':
case 'Boolean':
case 'String':
case 'Number':
return value;
case 'RegExp':
return String(value);
case 'Date':
case 'Duration':
return value.valueOf();
case 'Filter':
return value.source;
case 'Array':
return _.map(value, this.toJSONCompatible, this);
case 'Object':
return _.mapObject(value, this.toJSONCompatible, this);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51856
|
train
|
function(value) {
switch (values.typeOf(value)) {
case 'Null':
return { type: 'NullLiteral' };
case 'Boolean':
return { type: 'BooleanLiteral', value: value };
case 'Number':
if (value !== value) {
return { type: 'NaNLiteral' };
} else if (value === Infinity) {
return { type: 'InfinityLiteral', negative: false };
} else if (value === -Infinity) {
return { type: 'InfinityLiteral', negative: true };
} else {
return { type: 'NumberLiteral', value: value };
}
break; // silence ESLint
case 'String':
return { type: 'StringLiteral', value: value };
case 'RegExp':
return {
type: 'RegExpLiteral',
pattern: value.source,
flags: value.toString().match(/\/(\w*)$/)[1]
};
case 'Date':
return { type: 'MomentLiteral', value: value.valueOf() };
case 'Duration':
return { type: 'DurationLiteral', value: value.valueOf() };
case 'Filter':
return { type: 'FilterLiteral', ast: value.ast, source: value.source };
case 'Array':
return { type: 'ArrayLiteral', elements: _.map(value, values.toAST) };
case 'Object':
return {
type: 'ObjectLiteral',
properties: _.map(value, function(value, key) {
return {
type: 'ObjectProperty',
key: values.toAST(key),
value: values.toAST(value)
};
})
};
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51857
|
extract_program_stats
|
train
|
function extract_program_stats(prog) {
var stats = {};
var sources_array = source_stats(prog);
stats.inputs = input_stats(prog);
stats.input_total = count_procs(stats.inputs);
stats.sources = sources_array;
stats.source_total = sources_array.length;
stats.reducers = reducer_stats(prog);
stats.reducer_total = count_procs(stats.reducers);
stats.functions = function_stats(prog);
stats.procs = proc_stats(prog);
stats.proc_total = count_procs(stats.procs);
stats.views = view_stats(prog);
stats.view_total = count_procs(stats.views);
stats.subs = sub_stats(prog);
stats.imports = import_stats(prog);
return stats;
}
|
javascript
|
{
"resource": ""
}
|
q51858
|
loadAdapter
|
train
|
function loadAdapter(type, location) {
var options = adapterConfig[type];
try {
var modulePath = adapterModulePath(type, options);
global.JuttleAdapterAPI = JuttleAdapterAPI;
var start = new Date();
if (!options.builtin) {
checkCompatible(type, modulePath, location);
}
var init = require(modulePath);
var loaded = new Date();
var adapter = init(options);
global.JuttleAdapterAPI = undefined;
if (adapter.name !== type) {
throw new Error('adapter name ', adapter.name, ' != type ', type);
}
var initialized = new Date();
logger.debug(adapter.name, 'adapter loaded in', (loaded - start), 'ms,',
'initialized in', (initialized - loaded), 'ms');
register(adapter.name, adapter);
return adapter;
} catch (err) {
logger.error('error loading adapter ' + type + ': ' + err.message);
throw err;
}
}
|
javascript
|
{
"resource": ""
}
|
q51859
|
checkCompatible
|
train
|
function checkCompatible(type, modulePath, location) {
var adapterPackage = require(path.join(modulePath, 'package.json'));
var adapterJuttleVersion = adapterPackage.juttleAdapterAPI;
if (!adapterJuttleVersion) {
throw errors.compileError('INCOMPATIBLE-ADAPTER', {
type,
adapterJuttleVersion: '(unknown)',
apiVersion: JuttleAdapterAPI.version,
location
});
}
if (!semver.satisfies(JuttleAdapterAPI.version, adapterJuttleVersion)) {
throw errors.compileError('INCOMPATIBLE-ADAPTER', {
type,
adapterJuttleVersion,
apiVersion: JuttleAdapterAPI.version,
location
});
}
}
|
javascript
|
{
"resource": ""
}
|
q51860
|
configure
|
train
|
function configure(config) {
config = config || {};
logger.debug('configuring adapters', _.keys(config).join(','));
_.extend(adapterConfig, _.clone(config));
logger.debug('configuring builtin adapters');
_.each(BUILTIN_ADAPTERS, function(adapter) {
adapterConfig[adapter] = {
path: path.resolve(__dirname, '../adapters/' + adapter),
builtin: true
};
});
}
|
javascript
|
{
"resource": ""
}
|
q51861
|
list
|
train
|
function list() {
var adapters = [];
_.each(adapterConfig, function(config, adapter) {
var modulePath = adapterModulePath(adapter, config);
var version, installPath, moduleName;
var isBuiltin = BUILTIN_ADAPTERS.indexOf(adapter) !== -1;
var loaded = true;
if (isBuiltin) {
version = juttleVersion;
installPath = Module._resolveFilename(modulePath, module);
moduleName = '(builtin)';
} else {
try {
var packagePath = path.join(modulePath, 'package');
var pkg = require(packagePath);
installPath = path.dirname(Module._resolveFilename(packagePath, module));
version = pkg.version || '(unknown)';
moduleName = pkg.name;
} catch (err) {
installPath = '(unable to load adapter)';
version = '(unknown)';
moduleName = '(unknown)';
loaded = false;
}
}
adapters.push({adapter: adapter, builtin: isBuiltin, module: moduleName, version: version, path: installPath, loaded: loaded});
});
return adapters;
}
|
javascript
|
{
"resource": ""
}
|
q51862
|
bound
|
train
|
function bound(val, min, max) {
// trim the value to be within min..max (if min..max are specified)
val = (min !== undefined)? Math.max(val, min) : val;
val = (max !== undefined)? Math.min(val, max) : val;
return val ;
}
|
javascript
|
{
"resource": ""
}
|
q51863
|
reduce
|
train
|
function reduce(options, params, location, program) {
return options.every? new reduce_every(options, params, location, program) : new reduce_batch(options, params, location, program);
}
|
javascript
|
{
"resource": ""
}
|
q51864
|
train
|
function(e) {
L.EditToolbar.Edit.prototype._enableLayerEdit.call(this, e);
var layer = e.layer || e.target || e;
if (!layer.snapediting) {
if (layer.hasOwnProperty('_mRadius')) {
if (layer.editing) {
layer.editing._markerGroup.clearLayers();
delete layer.editing;
}
layer.editing = layer.snapediting = new L.Handler.CircleSnap(layer._map, layer, this.snapOptions);
}
else if (layer.getLatLng) {
layer.snapediting = new L.Handler.MarkerSnap(layer._map, layer, this.snapOptions);
}
else {
if (layer.editing) {
if (layer.editing.hasOwnProperty('_shape')) {
layer.editing._markerGroup.clearLayers();
if (layer.editing._shape instanceof L.Rectangle) {
delete layer.editing;
layer.editing = layer.snapediting = new L.Handler.RectangleSnap(layer._map, layer, this.snapOptions);
}
else if (layer.editing._shape instanceof L.FeatureGroup) {
delete layer.editing;
layer.editing = layer.snapediting = new L.Handler.FeatureGroupSnap(layer._map, layer, this.snapOptions);
}
else {
delete layer.editing;
layer.editing = layer.snapediting = new L.Handler.CircleSnap(layer._map, layer, this.snapOptions);
}
}
else {
layer.editing._markerGroup.clearLayers();
layer.editing._verticesHandlers[0]._markerGroup.clearLayers();
delete layer.editing;
layer.editing = layer.snapediting = new L.Handler.PolylineSnap(layer._map, layer, this.snapOptions);
}
}
else {
layer.editing = layer.snapediting = new L.Handler.PolylineSnap(layer._map, layer, this.snapOptions);
}
}
for (var i = 0, n = this._guideLayers.length; i < n; i++) {
layer.snapediting.addGuideLayer(this._guideLayers[i]);
}
}
layer.snapediting.enable();
}
|
javascript
|
{
"resource": ""
}
|
|
q51865
|
nextFrame
|
train
|
function nextFrame() {
if (currentVideo.paused || currentVideo.ended) {
return;
}
context.drawImage(currentVideo, 0, 0);
requestAnimationFrame(nextFrame);
}
|
javascript
|
{
"resource": ""
}
|
q51866
|
getMore
|
train
|
function getMore() {
var ajax = new XMLHttpRequest();
ajax.addEventListener('load', function () {
var originals =
this.responseText
.split(/\r?\n/)
.filter(RegExp.prototype.test.bind(/\.ts$/))
.map(resolveURL.bind(null, manifest));
originals = originals.slice(originals.lastIndexOf(lastOriginal) + 1);
lastOriginal = originals[originals.length - 1];
worker.postMessage(originals.map(function (url, index) {
return {url: url, index: sentVideos + index};
}));
sentVideos += originals.length;
console.log('asked for ' + originals.length + ' more videos');
});
ajax.open('GET', manifest, true);
ajax.send();
}
|
javascript
|
{
"resource": ""
}
|
q51867
|
train
|
function() {
var i, j, col1, col2;
var from = this.originalTable.startIndex;
var to = this.originalTable.endIndex;
/* Find children thead and tbody.
* Only to process the immediate tr-children. Bugfix for inner tables
*/
var thtb = this.originalTable.el.children();
if (this.options.excludeFooter) {
thtb = thtb.not('tfoot');
}
if (from < to) {
for (i = from; i < to; i++) {
col1 = thtb.find('> tr > td:nth-child(' + i + ')')
.add(thtb.find('> tr > th:nth-child(' + i + ')'));
col2 = thtb.find('> tr > td:nth-child(' + (i + 1) + ')')
.add(thtb.find('> tr > th:nth-child(' + (i + 1) + ')'));
for (j = 0; j < col1.length; j++) {
swapNodes(col1[j], col2[j]);
}
}
} else {
for (i = from; i > to; i--) {
col1 = thtb.find('> tr > td:nth-child(' + i + ')')
.add(thtb.find('> tr > th:nth-child(' + i + ')'));
col2 = thtb.find('> tr > td:nth-child(' + (i - 1) + ')')
.add(thtb.find('> tr > th:nth-child(' + (i - 1) + ')'));
for (j = 0; j < col1.length; j++) {
swapNodes(col1[j], col2[j]);
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51868
|
getTokensLength
|
train
|
function getTokensLength(tokens) {
if (typeof tokens === 'string') {
return tokens.length;
}
return tokens.reduce((acc, token) => {
return acc + (token.length ? token.length : 0);
}, 0);
}
|
javascript
|
{
"resource": ""
}
|
q51869
|
getHeaderContent
|
train
|
function getHeaderContent(tokens, type, markup) {
if (tokens[1].children.length === 0) {
tokens[1].children.push(getEmptyText());
} else if (tokens[1].children[0].type !== 'text') {
tokens[1].children.unshift(getEmptyText());
}
const content = changeText(tokens[1].children, markup);
return {
type,
content,
length: getTokensLength(content)
};
}
|
javascript
|
{
"resource": ""
}
|
q51870
|
getBlockContent
|
train
|
function getBlockContent(tokens, type, markup, start = false) {
const content = {
type,
content: processBlockTokens(tokens.slice(1, -1)), // eslint-disable-line
markup
};
if (start) {
content.start = start;
}
return content;
}
|
javascript
|
{
"resource": ""
}
|
q51871
|
getUrlToken
|
train
|
function getUrlToken({ tokens, intEmphasis, num }) {
const urlContent = `(${getAttr(tokens[num].attrs, 'href')})`;
const urlLength = urlContent.length;
const punctuation1 = {
type: "punctuation",
content: "[",
length: 1
};
const punctuation2 = {
type: "punctuation",
content: "]",
length: 1
};
const urlContentObj = {
type: "punctuation",
content: urlContent,
length: urlLength
};
const content = Array.isArray(intEmphasis) ?
[punctuation1, ...intEmphasis, punctuation2, urlContentObj] :
[punctuation1, intEmphasis, punctuation2, urlContentObj];
return {
type: "url",
content,
length: Array.isArray(intEmphasis) ? getTokensLength(content) : 1 + intEmphasis.length + 1 + urlLength
};
}
|
javascript
|
{
"resource": ""
}
|
q51872
|
getEmphasisToken
|
train
|
function getEmphasisToken({ tokens, intEmphasis, currTag, num }) {
const rawContent = joinArrString(_.flattenDeep([
tokens[num].markup,
intEmphasis,
tokens[num].markup
]));
const contentLength = getTokensLength(rawContent);
return {
type: getEmphasisType(currTag),
content: rawContent,
length: contentLength
};
}
|
javascript
|
{
"resource": ""
}
|
q51873
|
parseEmphasis
|
train
|
function parseEmphasis(tokens) {
const newTokens = [];
let i = 0;
while (i < tokens.length) {
if (typeof tokens[i] === 'string') {
if (tokens[i] !== '') {
newTokens.push(tokens[i]);
}
i++;
} else {
const currTag = tokens[i].type;
if (INLINE_OPEN.indexOf(currTag) !== -1) {
const closeTag = getCloseTag(currTag);
const closePos = getClosePos(tokens, i, closeTag, tokens[i].markup);
if (closePos !== -1) {
let intEmphasis = getOneEmphasis(tokens, i, closePos);
if (Array.isArray(intEmphasis) && intEmphasis.length === 0) {
intEmphasis = '';
}
if (currTag === 'link_open') {
newTokens.push(getUrlToken({ tokens, intEmphasis, num: i }));
} else {
newTokens.push(getEmphasisToken({ tokens, intEmphasis, currTag, num: i }));
}
i = closePos + 1;
continue;
}
}
newTokens.push(tokens[i]);
i++;
}
}
return newTokens;
}
|
javascript
|
{
"resource": ""
}
|
q51874
|
hasMarkOnChar
|
train
|
function hasMarkOnChar(character, mark) {
const arrChars = character.marks.toJS();
const marksSize = arrChars.length;
for (let i = 0; i < marksSize; i++) {
if (arrChars[i].type === mark) {
return true;
}
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q51875
|
hasEmphasis
|
train
|
function hasEmphasis(mark, state) {
const { startKey, endKey, startOffset, endOffset, texts } = state;
if (startKey === endKey) {
const focusText = texts.get(0).text;
const textLength = focusText.length;
if (texts.get(0).charsData) {
const characters = texts.get(0).charsData.characters;
// not selection
if (startOffset === endOffset) {
// string's edge
if (startOffset === 0 || startOffset === textLength) {
return false;
} else {
const prevChar = characters.get(startOffset - 1);
const currChar = characters.get(startOffset);
const hasPrevMark = hasMarkOnChar(prevChar, mark);
const hasCurrMark = hasMarkOnChar(currChar, mark);
// between character's marks
if (hasPrevMark && hasCurrMark) {
return true;
// between pairs of markers
} else if ((mark === 'bold' || mark === 'strikethrough') &&
startOffset > 1 && startOffset < textLength - 1) {
const leftPart = focusText.substr(startOffset - 2, 2);
const rightPart = focusText.substr(startOffset, 2);
if (leftPart === rightPart &&
(mark === 'bold' && (leftPart === '**' || leftPart === '__') ||
mark === 'strikethrough' && leftPart === '~~')) {
return true;
}
// between italic markers and not bold's edge
} else if (mark === 'italic' && prevChar.text === currChar.text &&
(currChar.text === '_' || currChar.text === '*') && !hasPrevMark && !hasCurrMark &&
(!(hasMarkOnChar(prevChar, 'bold') && hasMarkOnChar(currChar, 'bold')) &&
(startOffset === 1 || startOffset === focusText.length - 1 ||
!hasMarkOnChar(characters.get(startOffset - 2), 'bold') &&
!hasMarkOnChar(characters.get(startOffset + 1), 'bold')))) {
return true;
}
}
// selection
} else {
for (let i = startOffset; i < endOffset; i++) {
if (!hasMarkOnChar(characters.get(i), mark)) {
return false;
}
}
return true;
}
}
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q51876
|
unionEmphasis
|
train
|
function unionEmphasis({ change, focusKey, characters, accent, text, startOffset, endOffset, markerLength }) {
const leftEmphEdge = getLeftEmphEdge(accent, characters, startOffset);
const rightEmphEdge = getRightEmphEdge(accent, characters, endOffset - 1, text.length);
const leftMarker = text.substr(leftEmphEdge, markerLength);
let rightMarkerPos = rightEmphEdge - markerLength;
const rightMarker = text.substr(rightMarkerPos, markerLength);
const delCount = delInternalMarkers({
change,
focusKey,
characters,
accent,
startPos: leftEmphEdge + markerLength,
endPos: rightEmphEdge - markerLength
});
rightMarkerPos -= delCount * markerLength - 1;
if (leftMarker !== rightMarker) {
change.removeTextByKey(focusKey, rightMarkerPos, markerLength).
insertTextByKey(focusKey, rightMarkerPos, leftMarker);
}
return change;
}
|
javascript
|
{
"resource": ""
}
|
q51877
|
wrapEmphasis
|
train
|
function wrapEmphasis(accent, state) {
const marker = EMPHASIS[accent];
const markerLength = marker.length;
const { startOffset, endOffset, focusText, texts } = state;
const { text } = focusText;
const focusKey = focusText.key;
let change = state.change();
// #1 no selection
if (startOffset === endOffset) {
change.insertText(`${marker}${marker}`).
move(-markerLength);
// selection (this edge is selection edge)
} else {
const characters = texts.get(0).charsData.characters;
const delMarkers = delInternalMarkersBind({ change, focusKey, characters, accent });
const {
hasLeftOnEmphasis
} = getLeftSelectionEdgeData({ accent, characters, startOffset });
const {
hasRightOnEmphasis
} = getRightSelectionEdgeData({ accent, characters, endOffset, text });
if (hasLeftOnEmphasis) {
if (hasRightOnEmphasis) {
// #2 both edges on emphasis, delete all internal markers
change = unionEmphasis({
change, focusKey, characters, text, accent, startOffset, endOffset, markerLength
});
} else {
// #3 left edge on emphasis, right edge beyond markers
const leftEmphEdge = getLeftEmphEdge(accent, characters, startOffset);
const leftMarker = text.substr(leftEmphEdge, markerLength);
delMarkers({ startPos: leftEmphEdge, endPos: endOffset - 1 });
change.insertTextByKey(focusKey, endOffset - 1, leftMarker);
}
} else {
if (hasRightOnEmphasis) {
// #4 left edge beyond markers, right edge on emphasis
const rightEmphEdge = getRightEmphEdge(accent, characters, endOffset - 1, text.length);
const rightMarker = text.substr(rightEmphEdge - markerLength + 1, markerLength);
delMarkers({ startPos: startOffset, endPos: rightEmphEdge });
change.insertTextByKey(focusKey, startOffset, rightMarker);
} else {
// #5 both edges beyond markers
// delete all internal markers, wrap selection in markers
delMarkers({ startPos: startOffset, endPos: endOffset });
change.wrapText(marker, marker).focus();
}
}
}
change.focus();
return change.state;
}
|
javascript
|
{
"resource": ""
}
|
q51878
|
hasBlock
|
train
|
function hasBlock(regExp, state) {
const { focusText } = state;
const focusedText = focusText.text;
return regExp.test(focusedText);
}
|
javascript
|
{
"resource": ""
}
|
q51879
|
train
|
function(accent, state) {
let text = accent === 'ul' ? '* ' : '1. ';
if (hasMultiLineSelection(state)) {
const {
anchorKey,
anchorOffset,
focusKey,
focusOffset,
isBackward
} = state.selection;
const keys = [];
let firstBefore, firstAfter, lastBefore, lastAfter;
for (let i = 0; i < state.texts.size; i++) {
keys.push(state.texts.get(i).key);
}
const lineText = state.texts.get(0).text;
let pref, itemNum, div;
if (accent === 'ul') {
const ulMarker = getUlMarker(lineText);
if (ulMarker) {
text = ulMarker;
} else {
text = '* ';
}
} else {
({ pref, itemNum, div } = getOlNum(lineText));
}
let change = state.change();
const keysLength = keys.length;
const lastNum = keysLength - 1;
for (let i = 0; i < keysLength; i++) {
moveSelectionToLine(change, keys[i]); // eslint-disable-line no-use-before-define
if (i === 0) {
firstBefore = getTextLength(change);
} else if (i === lastNum) {
lastBefore = getTextLength(change);
}
if (i === 0 && !hasBlock(MATCH_SINGLE_RULE[accent], change.state) || i > 0) {
text = accent === 'ul' ? text : `${pref}${itemNum}${div} `;
change = wrapBlockForChange(MATCH_RULES[accent], text, change);// eslint-disable-line
if (i === 0) {
firstAfter = getTextLength(change);
} else if (i === lastNum) {
lastAfter = getTextLength(change);
}
itemNum++;
continue;
}
if (i === 0) {
firstAfter = firstBefore;
} else if (i === lastNum) {
lastAfter = lastBefore;
}
itemNum++;
}
change.select({
anchorKey,
anchorOffset: anchorOffset - firstBefore + firstAfter,
focusKey,
focusOffset: focusOffset - lastBefore + lastAfter,
isFocused: true,
isBackward
});
return change.state;
} else {
return wrapBlock(MATCH_RULES[accent], text, state);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51880
|
train
|
function(accent, state) {
if (hasMultiLineSelection(state)) {
const {
anchorKey,
anchorOffset,
focusKey,
focusOffset,
isBackward
} = state.selection;
const keys = [];
let firstBefore, firstAfter, lastBefore, lastAfter;
for (let i = 0; i < state.texts.size; i++) {
keys.push(state.texts.get(i).key);
}
let change = state.change();
const keysLength = keys.length;
const lastNum = keysLength - 1;
for (let i = 0; i < keysLength; i++) {
moveSelectionToLine(change, keys[i]);
if (i === 0) {
firstBefore = getTextLength(change);
} else if (i === lastNum) {
lastBefore = getTextLength(change);
}
change = unwrapListCallbacksForChange[accent](change);
if (i === 0) {
firstAfter = getTextLength(change);
} else if (i === lastNum) {
lastAfter = getTextLength(change);
}
}
const newAnchorOffset = anchorOffset - (isBackward ? lastBefore - lastAfter : firstBefore - firstAfter);
const newFocusOffset = focusOffset - (isBackward ? firstBefore - firstAfter : lastBefore - lastAfter);
change.select({
anchorKey,
anchorOffset: newAnchorOffset < 0 ? 0 : newAnchorOffset,
focusKey,
focusOffset: newFocusOffset < 0 ? 0 : newFocusOffset,
isFocused: true,
isBackward
});
return change.state;
} else {
return unwrapListCallbacks[accent](state);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51881
|
Client
|
train
|
function Client(client) {
if (this instanceof Client === false) {
return new Client(client);
}
if (!client) {
throw new Error('Must configure an S3 client before attempting to create an S3 upload stream.');
}
this.cachedClient = client;
}
|
javascript
|
{
"resource": ""
}
|
q51882
|
train
|
function (next) {
// If this is the first part, and we're just starting,
// but we have a multipartUploadID, then we're beginning
// a resume and can fire the 'ready' event externally.
if (multipartUploadID && !started)
ws.emit('ready', multipartUploadID);
started = true;
if (pendingParts < concurrentPartThreshold) {
// Has the MPU been created yet?
if (multipartUploadID)
upload(); // Upload the part immediately.
else {
e.once('ready', upload); // Wait until multipart upload is initialized.
createMultipartUpload();
}
}
else {
// Block uploading (and receiving of more data) until we upload
// some of the pending parts
e.once('part', upload);
}
function upload() {
// Pause/resume check #2 out of 2:
// Block queued up parts until resumption.
if (paused)
e.once('resume', uploadNow);
else
uploadNow();
function uploadNow() {
pendingParts++;
flushPart(function (partDetails) {
--pendingParts;
e.emit('part'); // Internal event
ws.emit('part', partDetails); // External event
// if we're paused and this was the last outstanding part,
// we can notify the caller that we're really paused now.
if (paused && pendingParts === 0)
notifyPaused();
});
next();
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51883
|
train
|
function () {
// Combine the buffers we've received and reset the list of buffers.
var combinedBuffer = Buffer.concat(receivedBuffers, receivedBuffersLength);
receivedBuffers.length = 0; // Trick to reset the array while keeping the original reference
receivedBuffersLength = 0;
if (combinedBuffer.length > partSizeThreshold) {
// The combined buffer is too big, so slice off the end and put it back in the array.
var remainder = new Buffer(combinedBuffer.length - partSizeThreshold);
combinedBuffer.copy(remainder, 0, partSizeThreshold);
receivedBuffers.push(remainder);
receivedBuffersLength = remainder.length;
// Return the perfectly sized part.
var uploadBuffer = new Buffer(partSizeThreshold);
combinedBuffer.copy(uploadBuffer, 0, 0, partSizeThreshold);
return uploadBuffer;
}
else {
// It just happened to be perfectly sized, so return it.
return combinedBuffer;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51884
|
train
|
function (callback) {
var partBuffer = preparePartBuffer();
var localPartNumber = partNumber;
partNumber++;
receivedSize += partBuffer.length;
cachedClient.uploadPart(
{
Body: partBuffer,
Bucket: destinationDetails.Bucket,
Key: destinationDetails.Key,
UploadId: multipartUploadID,
PartNumber: localPartNumber
},
function (err, result) {
if (err)
abortUpload('Failed to upload a part to S3: ' + JSON.stringify(err));
else {
uploadedSize += partBuffer.length;
partIds[localPartNumber - 1] = {
ETag: result.ETag,
PartNumber: localPartNumber
};
callback({
ETag: result.ETag,
PartNumber: localPartNumber,
receivedSize: receivedSize,
uploadedSize: uploadedSize
});
}
}
);
}
|
javascript
|
{
"resource": ""
}
|
|
q51885
|
train
|
function () {
// There is a possibility that the incoming stream was empty, therefore the MPU never started
// and cannot be finalized.
if (multipartUploadID) {
cachedClient.completeMultipartUpload(
{
Bucket: destinationDetails.Bucket,
Key: destinationDetails.Key,
UploadId: multipartUploadID,
MultipartUpload: {
Parts: partIds
}
},
function (err, result) {
if (err)
abortUpload('Failed to complete the multipart upload on S3: ' + JSON.stringify(err));
else {
// Emit both events for backwards compatibility, and to follow the spec.
ws.emit('uploaded', result);
ws.emit('finish', result);
started = false;
}
}
);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q51886
|
train
|
function (rootError) {
cachedClient.abortMultipartUpload(
{
Bucket: destinationDetails.Bucket,
Key: destinationDetails.Key,
UploadId: multipartUploadID
},
function (abortError) {
if (abortError)
ws.emit('error', rootError + '\n Additionally failed to abort the multipart upload on S3: ' + abortError);
else
ws.emit('error', rootError);
}
);
}
|
javascript
|
{
"resource": ""
}
|
|
q51887
|
_reevaluateInputs
|
train
|
function _reevaluateInputs() {
var inputElements = element.find('input');
$angular.forEach(inputElements, function forEach(inputElement, index) {
inputElement = $angular.element(inputElement);
inputElement.val('');
inputElement.val(scope._model[index]);
});
}
|
javascript
|
{
"resource": ""
}
|
q51888
|
_sel
|
train
|
function _sel(selector)
{
var f, out = [];
if (typeof selector == "string")
{
while (selector != "")
{
f = selector.match(re_selector_fragment);
if (f[0] == "") return null;
out.push({ rel: f[1], tag: f[2], uTag: (f[2] || "").toUpperCase(), id: f[3], classes: (f[4]) ? f[4].split(".") : _undefined });
selector = selector.substring(f[0].length);
}
}
return out;
}
|
javascript
|
{
"resource": ""
}
|
q51889
|
_isDescendant
|
train
|
function _isDescendant(elm, ancestor)
{
while ((elm = elm.parentNode) && elm != ancestor) { }
return elm !== null;
}
|
javascript
|
{
"resource": ""
}
|
q51890
|
drawText
|
train
|
function drawText(text, dx, dy, ctx) {
var dx0 = dx;
for (var i = 0; i < text.length; i++) {
var n = text.charCodeAt(i);
var sx = (n&63)*8;
var sy = (n>>6)*10 + 56;
var width = _fontwidths[n];
ctx.drawImage(fontimg, sx, sy, width, 10, dx, dy, width, 10);
dx += width + 1;
}
return dx - dx0;
}
|
javascript
|
{
"resource": ""
}
|
q51891
|
MixSilenceIntoBuf
|
train
|
function MixSilenceIntoBuf(ch, start, end, dataL, dataR) {
var s = ch.filterstate[1];
if (isNaN(s)) {
console.log("NaN filterstate?", ch.filterstate, ch.filter);
return;
}
for (var i = start; i < end; i++) {
if (Math.abs(s) < 1.526e-5) { // == 1/65536.0
s = 0;
break;
}
dataL[i] += s * ch.vL;
dataR[i] += s * ch.vR;
s *= popfilter_alpha;
}
ch.filterstate[1] = s;
ch.filterstate[2] = s;
if (isNaN(s)) {
console.log("NaN filterstate after adding silence?", ch.filterstate, ch.filter, i);
return;
}
return 0;
}
|
javascript
|
{
"resource": ""
}
|
q51892
|
transformSelector
|
train
|
function transformSelector(selector, customSelectors) {
const transpiledSelectors = [];
for (const index in selector.nodes) {
const { value, nodes } = selector.nodes[index];
if (value in customSelectors) {
for (const replacementSelector of customSelectors[value].nodes) {
const selectorClone = selector.clone();
selectorClone.nodes.splice(index, 1, ...replacementSelector.clone().nodes.map(node => {
// use spacing from the current usage
node.spaces = { ...selector.nodes[index].spaces };
return node;
}));
const retranspiledSelectors = transformSelector(selectorClone, customSelectors);
adjustNodesBySelectorEnds(selectorClone.nodes, Number(index));
if (retranspiledSelectors.length) {
transpiledSelectors.push(...retranspiledSelectors);
} else {
transpiledSelectors.push(selectorClone);
}
}
return transpiledSelectors;
} else if (nodes && nodes.length) {
transformSelectorList(selector.nodes[index], customSelectors);
}
}
return transpiledSelectors;
}
|
javascript
|
{
"resource": ""
}
|
q51893
|
callService
|
train
|
function callService(service, emitter, channel, callback) {
var argsValue = Array.prototype.slice.call(Array.prototype.slice.call(arguments)[4]);
var callerFunc = arguments.callee.caller;
var eventName = service.name || service._name;
var callerArgNames = _retrieveArgumentNames(callerFunc);
var props = {};
for(var i = 0; i < callerArgNames.length - 1; i++) {
props[callerArgNames[i]] = argsValue[i];
}
if (callback) {
emitter.once(eventName, callback);
}
if (emitter.isReady(true)) {
try {
service({
props: props,
channel: channel,
callback: createEventEmitterCallback(eventName, emitter)
});
} catch (err) {
emitter.emit('error', err);
}
}
return new Promise(function (fulfill, reject) {
emitter.once('error', reject);
emitter.once(eventName, function (result) {
emitter.removeListener('error', reject);
if (typeof result !== 'boolean' && result.instanceOf('mtproto.type.Rpc_error')) {
reject(new Error(result.error_message));
} else {
fulfill(result);
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q51894
|
createEventEmitterCallback
|
train
|
function createEventEmitterCallback(event, emitter) {
return function (ex) {
if (ex) {
emitter.emit('error', ex);
} else {
var args = Array.prototype.slice.call(arguments);
args[0] = event;
emitter.emit.apply(emitter, args);
if (event == 'end') {
emitter.removeAllListeners();
}
}
};
}
|
javascript
|
{
"resource": ""
}
|
q51895
|
startRepl
|
train
|
function startRepl() {
var repl = require('repl');
var gcliEval = function(command, scope, file, callback) {
// Why does node wrap the command in '(...)\n'?
command = command.replace(/^\((.*)\n\)$/, function(all, part) {
return part;
});
if (command.length !== 0) {
requisition.updateExec(command)
.then(logResults)
.then(function() { callback(); })
.catch(function(ex) { util.errorHandler(ex); callback(); });
}
};
console.log('This is also a limited GCLI REPL. ' +
'Type \'help\' for a list of commands, CTRL+C 3 times to exit:');
repl.start(': ', process, gcliEval, false, true);
}
|
javascript
|
{
"resource": ""
}
|
q51896
|
train
|
function(input, source) {
var output = input.toString();
if (source.path.match(/\.js$/)) {
output = output.replace(/(["'](do not )?use strict[\"\'];)/,
'define(function(require, exports, module) {\n\n$1');
output += '\n\n});\n';
}
return output;
}
|
javascript
|
{
"resource": ""
}
|
|
q51897
|
train
|
function(context, typed, options) {
var matches = options.matches == null ? undefined : options.matches.source;
var connector = context.system.connectors.get();
return GcliFront.create(connector).then(function(front) {
return front.parseFile(typed, options.filetype,
options.existing, matches).then(function(reply) {
reply.status = Status.fromString(reply.status);
if (reply.predictions != null) {
reply.predictor = function() {
return Promise.resolve(reply.predictions);
};
}
front.connection.disconnect().catch(util.errorHandler);
return reply;
});
});
}
|
javascript
|
{
"resource": ""
}
|
|
q51898
|
train
|
function(element, clear) {
// Strict check on the off-chance that we later think of other options
// and want to replace 'clear' with an 'options' parameter, but want to
// support backwards compat.
if (clear === true) {
util.clearElement(element);
}
element.appendChild(this.toDom(element.ownerDocument));
}
|
javascript
|
{
"resource": ""
}
|
|
q51899
|
train
|
function(document) {
if (options.css) {
util.importCss(options.css, document, options.cssId);
}
var child = host.toDom(document, options.html);
domtemplate.template(child, options.data || {}, options.options || {});
return child;
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.