_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q3700
|
toggleColor
|
train
|
async function toggleColor(store) {
await store.update(state => {
if (state.color === "blue") {
state.color = "green"
} else {
state.color = "blue"
}
})
}
|
javascript
|
{
"resource": ""
}
|
q3701
|
ErrorMessage
|
train
|
function ErrorMessage({ state, error, clearError }) {
return (
<>
<h1 style={{ color: "red" }}>{error.message}</h1>
<button onClick={() => clearError()}>Try Again</button>
<pre>{JSON.stringify(state, null, 2)}</pre>
</>
)
}
|
javascript
|
{
"resource": ""
}
|
q3702
|
CurrentQuote
|
train
|
function CurrentQuote() {
const [quoteId] = useStore("quoteId")
const [quoteLength] = useStore("quoteLengths", quoteId)
return (
<>
<p>The following quote is {quoteLength} characters long:</p>
<QuoteView quoteId={quoteId} />
</>
)
}
|
javascript
|
{
"resource": ""
}
|
q3703
|
fileToObject
|
train
|
function fileToObject(file) {
return {
lastModified: file.lastModified,
lastModifiedDate: file.lastModifiedDate,
name: file.filename || file.name,
size: file.size,
type: file.type,
uid: file.uid,
response: file.response,
error: file.error,
percent: 0,
originFileObj: file
};
}
|
javascript
|
{
"resource": ""
}
|
q3704
|
train
|
function(route) {
// Save the previous route value
this._previousRoute = this._currentRoute;
// Fetch Resources
document.body.classList.add("loading");
return this._fetchResource(route, this.config.container).then(function(res){
document.body.classList.remove('loading');
return res;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q3705
|
train
|
function(fragment, options={}) {
// Default trigger to true unless otherwise specified
(options.trigger === undefined) && (options.trigger = true);
// Stringify any data passed in the options hash
var query = options.data ? (~fragment.indexOf('?') ? '&' : '?') + $.url.query.stringify(options.data) : '';
// Un-Mark any `active` links in the page container
var $container = $(this.config.containers).unMarkLinks();
// Navigate to the specified path. Return value is the value from the router
// callback specified on the component
var resp = Backbone.history.navigate(fragment + query, options);
// Always return a promise. If the response of `Backbone.histroy.navigate`
// was a promise, wait for it to resolve before resolving. Once resolved,
// mark relevent links on the page as `active`.
return new Promise(function(resolve, reject) {
if(resp && resp.constructor === Promise) resp.then(resolve, resolve);
resolve(resp);
}).then(function(resp){
$container.markLinks();
return resp;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q3706
|
train
|
function(route, name, callback) {
if (_.isFunction(name)) {
callback = name;
name = '';
}
if (!_.isRegExp(route)){
route = this._routeToRegExp(route);
}
if (!callback){ callback = this[name]; }
Backbone.history.route(route, (fragment) => {
// If this route was defined as a regular expression, we don't capture
// query params. Only parse the actual path.
fragment = fragment.split('?')[0];
// Extract the arguments we care about from the fragment
var args = this._extractParameters(route, fragment);
// Get the query params string
var search = (Backbone.history.getSearch() || '').slice(1);
// If this route was created from a string (not a regexp), remove the auto-captured
// search params.
if(route._isString){ args.pop(); }
// If the route is not user prodided, if the history object has search params
// then our args have the params as its last agrument as of Backbone 1.2.0
// If the route is a user provided regex, add in parsed search params from
// the history object before passing to the callback.
args.push((search) ? $.url.query.parse(search) : {});
var resp = this.execute(callback, args, name);
if ( resp !== false) {
this.trigger.apply(this, ['route:' + name].concat(args));
this.trigger('route', name, args);
Backbone.history.trigger('route', this, name, args);
}
return resp;
});
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q3707
|
train
|
function(options={}, callback=function(){}) {
// Let all of our components always have referance to our router
Component.prototype.router = this;
// Save our config referance
this.config = options;
this.config.handlers = [];
this.config.containers = [];
// Normalize our url configs
this.config.root = normalizeUrl(this.config.root);
this.config.assetRoot = this.config.assetRoot ? normalizeUrl(this.config.assetRoot) : this.config.root;
this.config.jsPath = normalizeUrl(this.config.assetRoot, this.config.jsPath);
this.config.cssPath = normalizeUrl(this.config.assetRoot, this.config.cssPath);
// Get a unique instance id for this router
this.uid = $.uniqueId('router');
// Allow user to override error route
this.config.errorRoute && (ERROR_ROUTE_NAME = this.config.errorRoute);
// Convert our routeMappings to regexps and push to our handlers
_.each(this.config.routeMapping, function(value, route){
var regex = this._routeToRegExp(route);
this.config.handlers.unshift({ route: route, regex: regex, app: value });
}, this);
// Use the user provided container, or default to the closest `<main>` tag
this.config.container = $((this.config.container || 'main'))[0];
this.config.containers.push(this.config.container);
SERVICES.page = new ServiceLoader('page');
// Install our global components
_.each(this.config.services, function(selector, route){
var container = $(selector)[0] || document.createElement('span');
this.config.containers.push(container);
SERVICES[route] = new ServiceLoader(route);
this._fetchResource(route, container).catch(function(){});
}, this);
// Watch click events on links in all out containers
this._watchLinks(this.config.containers);
// Start the history and call the provided callback
Backbone.history.start({
pushState: (this.config.pushState === undefined) ? true : this.config.pushState,
root: (this.config.root || '')
}).then(callback);
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q3708
|
train
|
function(container){
// Navigate to route for any link with a relative href
$(container).on('click', 'a', (e) => {
var path = e.target.getAttribute('href');
// If the path is a remote URL, allow the browser to navigate normally.
// Otherwise, prevent default so we can handle the route event.
if(IS_REMOTE_URL.test(path) || path === '#'){ return void 0; }
e.preventDefault();
// If this is not our current route, navigate to the new route
if(path !== '/'+Backbone.history.fragment){
this.navigate(path, {trigger: true});
}
});
}
|
javascript
|
{
"resource": ""
}
|
|
q3709
|
train
|
function(){
var routes = this.current ? (this.current.data.routes || {}) : {};
routes[this._previousRoute] = '';
// Unset Previous Application's Routes. For each route in the page app, remove
// the handler from our route object and delete our referance to the route's callback
_.each(routes, (value, key) => {
var regExp = this._routeToRegExp(key).toString();
Backbone.history.handlers = _.filter(Backbone.history.handlers, function(obj){
return obj.route.toString() !== regExp;
});
});
if(!this.current){ return void 0; }
var oldPageName = this.current.__pageId;
// Un-hook Event Bindings, Delete Objects
this.current.data.deinitialize();
// Now we no longer have a page installed.
this.current = undefined;
// Disable old css if it exists
setTimeout(() => {
if(this.status === ERROR){ return void 0; }
document.getElementById(oldPageName + '-css').setAttribute('disabled', true);
}, 500);
}
|
javascript
|
{
"resource": ""
}
|
|
q3710
|
train
|
function(PageApp, appName, container) {
var oldPageName, pageInstance, routes = [];
var isService = (container !== this.config.container);
var name = (isService) ? appName : 'page';
// If no container exists, throw an error
if(!container) throw 'No container found on the page! Please specify a container that exists in your Rebound config.';
// Add page level loading class
container.classList.remove('error', 'loading');
// Uninstall any old resource we have loaded
if(!isService && this.current){ this._uninstallResource(); }
// Load New PageApp, give it it's name so we know what css to remove when it deinitializes
pageInstance = ComponentFactory(PageApp).el;
if(SERVICES[name].isLazyComponent){ SERVICES[name].hydrate(pageInstance.data); }
else{ SERVICES[name] = pageInstance.data; }
pageInstance.__pageId = this.uid + '-' + appName;
// Add to our page
$(container).empty();
container.appendChild(pageInstance);
// Make sure we're back at the top of the page
document.body.scrollTop = 0;
// Add a default route handler for the route that got us here so if the component
// does not define a route that handles it, we don't get a redirect loop
if(!isService){ this.route(this._currentRoute, 'default', function(){ return void 0; }); }
// Augment ApplicationRouter with new routes from PageApp added in reverse order to preserve order higherarchy
_.each(pageInstance.data.routes, (value, key) => {
// Add the new callback referance on to our router and add the route handler
this.route(key, value, function () { return pageInstance.data[value].apply(pageInstance.data, arguments); });
});
// If this is the main page component, set it as current
if(!isService){ this.current = pageInstance; }
// Always return a promise
return new Promise(function(resolve, reject){
// Re-trigger route so the newly added route may execute if there's a route match.
// If no routes are matched, app will hit wildCard route which will then trigger 404
if(!isService){
let res = Backbone.history.loadUrl(Backbone.history.fragment);
if(res && typeof res.then === 'function') return res.then(resolve);
return resolve(res);
}
// Return our newly installed app
return resolve(pageInstance);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q3711
|
train
|
function(route, container) {
var appName, routeName,
isService = (container !== this.config.container),
isError = (route === ERROR_ROUTE_NAME);
// Normalize Route
route || (route = '');
// Get the app name from this route
appName = routeName = (route.split('/')[0] || 'index');
// If this isn't the error route, Find Any Custom Route Mappings
if(!isService && !isError){
this._currentRoute = route.split('/')[0];
_.any(this.config.handlers, (handler) => {
if (handler.regex.test(route)){
appName = handler.app;
this._currentRoute = handler.route;
return true;
}
});
}
// Wrap these async resource fetches in a promise and return it.
// This promise resolves when both css and js resources are loaded
// It rejects if either of the css or js resources fails to load.
return new Promise((resolve, reject) => {
var throwError = (err) => {
// If we are already in an error state, this means we were unable to load
// a custom error page. Uninstall anything we have and insert our default 404 page.
if(this.status === ERROR){
if(isService) return resolve(err);
this._uninstallResource();
container.innerHTML = DEFAULT_404_PAGE;
return resolve(err);
}
// Set our status to error and attempt to load a custom error page.
console.error('Could not ' + ((isService) ? 'load the ' + appName + ' service:' : 'find the ' + (appName || 'index') + ' app.'), 'at', ('/' + route));
this.status = ERROR;
this._currentRoute = route;
resolve(this._fetchResource(ERROR_ROUTE_NAME, container));
};
// If the values we got from installing our resources are unexpected, 404
// Otherwise, set status, activate the css, and install the page component
var install = (response) => {
var cssElement = response[0], jsElement = response[1];
if(!(cssElement instanceof Element) || !(jsElement instanceof Element) ) return throwError();
(!isService && !isError) && (this.status = SUCCESS);
cssElement && cssElement.removeAttribute('disabled');
this._installResource(jsElement.getAttribute('data-name'), appName, container).then(resolve, resolve);
};
// If loading a page, set status to loading
(!isService && !isError) && (this.status = LOADING);
// If Page Is Already Loaded Then The Route Does Not Exist. 404 and Exit.
if (this.current && this.current.__pageId === (this.uid + '-' + appName)){ return throwError(); }
// Fetch our css and js in paralell, install or throw when both complete
Promise.all([this._fetchCSS(routeName, appName), this._fetchJavascript(routeName, appName)])
.then(install, throwError);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q3712
|
clone
|
train
|
function clone(object) {
// check if the object is an object and isn't empty
if (is(object) && !empty(object)) {
// create a new object for the result
const result = {};
// for each key in the specified object add it
// to the new result with the value from the
// original object
Object.keys(object).forEach((key) => {
result[key] = object[key];
});
// return the result object
return result;
}
// if the object isn't an object or is empty return
// an empty object this will keep the return immutable
return {};
}
|
javascript
|
{
"resource": ""
}
|
q3713
|
endListener
|
train
|
function endListener(state) {
// Note: If incremental is conclusive for 'end' event, this will be called
// with isDone === true, since removeListener doesn't affect listeners for
// an event which is already in-progress.
if (state.ended || isDone) {
return;
}
state.ended = true;
ended += 1;
debug(`${streamName(this)} has ended.`);
if (options.incremental) {
if (doCompare(options.incremental, CompareType.incremental)) {
return;
}
}
if (ended === 2) {
const postEndCompare = function() {
doCompare(options.compare, CompareType.last);
};
if (options.delay) {
debug(`All streams have ended. Delaying for ${options.delay
}ms before final compare.`);
postEndTimeout = setTimeout(postEndCompare, options.delay);
} else {
// Let pending I/O and callbacks complete to catch some errant events
debug('All streams have ended. Delaying before final compare.');
postEndImmediate = setImmediate(postEndCompare);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q3714
|
addData
|
train
|
function addData(data) {
if (options.objectMode) {
if (!this.data) {
this.data = [data];
} else {
this.data.push(data);
}
this.totalDataLen += 1;
} else if (typeof data !== 'string' && !(data instanceof Buffer)) {
throw new TypeError(`expected string or Buffer, got ${
Object.prototype.toString.call(data)}. Need objectMode?`);
} else if (this.data === null || this.data === undefined) {
this.data = data;
this.totalDataLen += data.length;
} else if (typeof this.data === 'string' && typeof data === 'string') {
// perf: Avoid unnecessary string concatenation
if (this.data.length === 0) {
this.data = data;
} else if (data.length > 0) {
this.data += data;
}
this.totalDataLen += data.length;
} else if (this.data instanceof Buffer && data instanceof Buffer) {
// perf: Avoid unnecessary Buffer concatenation
if (this.data.length === 0) {
this.data = data;
} else if (data.length > 0) {
// FIXME: Potential performance issue if data or this.data are large.
// Should append to a Buffer we control and store a slice in .data
this.data = Buffer.concat(
[this.data, data],
this.data.length + data.length
);
}
this.totalDataLen += data.length;
} else {
throw new TypeError(`read returned ${
Object.prototype.toString.call(data)}, previously ${
Object.prototype.toString.call(this.data)
}. Need objectMode?`);
}
}
|
javascript
|
{
"resource": ""
}
|
q3715
|
handleData
|
train
|
function handleData(state, data) {
debug('Read data from ', streamName(this));
try {
addData.call(state, data);
} catch (err) {
debug(`Error adding data from ${streamName(this)}`, err);
reject(err);
done();
return;
}
if (options.incremental) {
doCompare(options.incremental, CompareType.incremental);
}
}
|
javascript
|
{
"resource": ""
}
|
q3716
|
readNext
|
train
|
function readNext() {
let stream, state;
while (!isDone) {
if (!state1.ended
&& (state2.ended || state1.totalDataLen <= state2.totalDataLen)) {
stream = stream1;
state = state1;
} else if (!state2.ended) {
stream = stream2;
state = state2;
} else {
debug('All streams have ended. No further reads.');
return;
}
const data = stream.read();
if (data === null) {
debug(`Waiting for ${streamName(stream)} to be readable...`);
stream.once('readable', readNext);
return;
}
handleData.call(stream, state, data);
}
}
|
javascript
|
{
"resource": ""
}
|
q3717
|
train
|
function(operation, parameters) {
var req;
req = getXmlReqHeader.call(this);
req.push('<Operation><Name>', operation, '</Name>', '<Params>');
if (parameters) {
// don't send raw '&', but don't change '&', '<', etc.
req.push(
parameters.replace(/&/g, "&")
.replace(/&(amp|lt|gt|quot);/g, "&$1;")
);
}
req.push('</Params></Operation></PVRequest>');
return req.join('');
}
|
javascript
|
{
"resource": ""
}
|
|
q3718
|
evenly
|
train
|
function evenly(iterables) {
const iterators = iterables.map(iterable => createIterator(iterable, { strict: false }));
const empties = new Set();
const count = iterators.length;
let index = -1;
/**
* Returns next iterator.
*
* Returns the first iterator after the last one.
*
* @returns {Iterator}
*/
function step() {
// Back to the first iterator.
if (index === count - 1) {
index = -1;
}
// Go to the next iterator.
index++;
// Ignore empty iterators.
while(empties.has(index)) {
if (index === count - 1) {
index = -1;
}
index++;
}
return iterators[index];
}
/**
* Returns next value.
*
* @returns {{done: boolean, value: *}}
*/
function next() {
// Exit if all iterators are traversed.
if (empties.size === count) {
return done;
}
// Go to the next iterator.
const iter = step();
const res = iter.next();
// Mark iterator as empty and go to the next.
if (res.done) {
empties.add(index);
return next();
}
return res;
}
return { next, [Symbol.iterator]() { return this; } };
}
|
javascript
|
{
"resource": ""
}
|
q3719
|
step
|
train
|
function step() {
// Back to the first iterator.
if (index === count - 1) {
index = -1;
}
// Go to the next iterator.
index++;
// Ignore empty iterators.
while(empties.has(index)) {
if (index === count - 1) {
index = -1;
}
index++;
}
return iterators[index];
}
|
javascript
|
{
"resource": ""
}
|
q3720
|
next
|
train
|
function next() {
// Exit if all iterators are traversed.
if (empties.size === count) {
return done;
}
// Go to the next iterator.
const iter = step();
const res = iter.next();
// Mark iterator as empty and go to the next.
if (res.done) {
empties.add(index);
return next();
}
return res;
}
|
javascript
|
{
"resource": ""
}
|
q3721
|
series
|
train
|
function series(iterables) {
if (iterables.length === 0) {
return createIterator();
}
let iter = createIterator(iterables.shift(), { strict: false });
return {
[Symbol.iterator]() { return this; },
next() {
let next = iter.next();
// If iterator is ended go to the next.
// If next iterator is empty (is ended) go to the next,
// until you get not empty iterator, or all iterators are ended.
while (next.done) {
// If iterators are ended, then exit.
if (iterables.length === 0) {
return done;
}
iter = createIterator(iterables.shift(), { strict: false });
next = iter.next();
}
return next;
}
};
}
|
javascript
|
{
"resource": ""
}
|
q3722
|
transformMessageToRequestMessage
|
train
|
function transformMessageToRequestMessage(message) {
const newMessage = {
info: message.info,
hops: message.hops
};
let payload;
if (message.payload === 'string') {
payload = message.payload;
} else if (message.payload instanceof stream.Stream) {
payload = message.payload;
} else {
// expect that it is JSON
payload = JSON.stringify(message.payload);
}
// make the message a form
const formData = new FormData();
if (message.info) {
formData.append('info', JSON.stringify(message.info));
}
if (message.hops) {
formData.append('hops', JSON.stringify(message.hops));
}
if (payload) {
formData.append('payload', payload);
}
newMessage.payload = formData;
return newMessage;
}
|
javascript
|
{
"resource": ""
}
|
q3723
|
unpackToMessage
|
train
|
function unpackToMessage(request, forwardFunction) {
const busboy = new Busboy({
headers: request.headers
});
return new Promise((resolve, reject) => {
// the message which will be forwarded
const newMessage = {};
let resultPromise;
busboy.on('file', function(fieldname, file, filename, encoding, mimetype) {
if (fieldname === 'payload') {
// This is a stream payload
newMessage.payload = file;
if (forwardFunction) {
resolve(forwardFunction(newMessage));
} else {
resolve(newMessage);
}
}
});
busboy.on('field', function(
fieldname,
val,
fieldnameTruncated,
valTruncated
) {
if (
fieldname === 'info' ||
fieldname === 'hops' ||
fieldname === 'payload'
) {
newMessage[fieldname] = JSON.parse(val);
}
});
request.pipe(busboy);
});
}
|
javascript
|
{
"resource": ""
}
|
q3724
|
train
|
function(arr){
var i, len = arr.length;
this.added || (this.added = {});
arr.forEach((item) => {
if(this.added[item.cid]){ return; }
this.added[item.cid] = 1;
if(item.isLazyValue){ item.makeDirty(); }
this.push(item);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q3725
|
onReset
|
train
|
function onReset(data, options){
trigger.call(this, 'reset', data, data.isModel ? data.changedAttributes() : { '@each': data }, options);
}
|
javascript
|
{
"resource": ""
}
|
q3726
|
train
|
function(attributes, options={}){
var self = this;
if(attributes === null || attributes === undefined){ attributes = {}; }
attributes.isModel && (attributes = attributes.attributes);
this.helpers = {};
this.defaults = this.defaults || {};
this.setParent( options.parent || this );
this.setRoot( options.root || this );
this.__path = options.path || this.__path;
// Convert getters and setters to computed properties
$.extractComputedProps(attributes);
Backbone.Model.call( this, attributes, options );
}
|
javascript
|
{
"resource": ""
}
|
|
q3727
|
train
|
function(attr, options) {
options = options ? _.clone(options) : {};
var val = this.get(attr);
if(!_.isBoolean(val)) console.error('Tried to toggle non-boolean value ' + attr +'!', this);
return this.set(attr, !val, options);
}
|
javascript
|
{
"resource": ""
}
|
|
q3728
|
train
|
function(obj, options){
var changed = {}, key, value;
options || (options = {});
options.reset = true;
obj = (obj && obj.isModel && obj.attributes) || obj || {};
options.previousAttributes = _.clone(this.attributes);
// Any unset previously existing values will be set back to default
_.each(this.defaults, function(val, key){
if(!obj.hasOwnProperty(key)){ obj[key] = val; }
}, this);
// Iterate over the Model's attributes:
// - If the property is the `idAttribute`, skip.
// - If the properties are already the same, skip
// - If the property is currently undefined and being changed, assign
// - If the property is a `Model`, `Collection`, or `ComputedProperty`, reset it.
// - If the passed object has the property, set it to the new value.
// - If the Model has a default value for this property, set it back to default.
// - Otherwise, unset the attribute.
for(key in this.attributes){
value = this.attributes[key];
if(value === obj[key]){ continue; }
else if(_.isUndefined(value) && !_.isUndefined(obj[key])){ changed[key] = obj[key]; }
else if (value.isComponent){ continue; }
else if (value.isCollection || value.isModel || value.isComputedProperty){
value.reset((obj[key] || []), {silent: true});
if(value.isCollection) changed[key] = value.previousModels;
else if(value.isModel && value.isComputedProperty) changed[key] = value.cache.model.changedAttributes();
else if(value.isModel) changed[key] = value.changedAttributes();
}
else if (obj.hasOwnProperty(key)){ changed[key] = obj[key]; }
else{
changed[key] = undefined;
this.unset(key, {silent: true});
}
}
// Any new values will be set to on the model
_.each(obj, function(val, key){
if(_.isUndefined(changed[key])){ changed[key] = val; }
});
// Reset our model
obj = this.set(obj, _.extend({}, options, {silent: true, reset: false}));
// Trigger custom reset event
this.changed = changed;
if (!options.silent){ this.trigger('reset', this, options); }
// Return new values
return obj;
}
|
javascript
|
{
"resource": ""
}
|
|
q3729
|
train
|
function() {
if (this._isSerializing){ return this.id || this.cid; }
this._isSerializing = true;
var json = _.clone(this.attributes);
_.each(json, function(value, name) {
if( _.isNull(value) || _.isUndefined(value) ){ return void 0; }
_.isFunction(value.toJSON) && (json[name] = value.toJSON());
});
this._isSerializing = false;
return json;
}
|
javascript
|
{
"resource": ""
}
|
|
q3730
|
getCoverageReport
|
train
|
function getCoverageReport (folder) {
var reports = grunt.file.expand(folder + '*/index.html');
if (reports && reports.length > 0) {
return reports[0];
}
return '';
}
|
javascript
|
{
"resource": ""
}
|
q3731
|
getAuthConfigs
|
train
|
function getAuthConfigs(modelName) {
return _.filter(internals.authConfig, function hasSameModelName(c) {
return c.defaults.modelName === modelName;
});
}
|
javascript
|
{
"resource": ""
}
|
q3732
|
setModel
|
train
|
function setModel(Model, modelName) {
let authConfigs;
if (!internals.acl) {
throw new Error('Attempt to shield model before setting acl');
}
if (!internals.authConfig.length) {
throw new Error('Attempt to shield model before seting configs');
}
// raise shield around Model
new Shield(Model, internals.acl);
authConfigs = getAuthConfigs(modelName);
_.each(authConfigs, _.bind(Model.shield.addRules, Model.shield));
internals.models[modelName] = Model;
}
|
javascript
|
{
"resource": ""
}
|
q3733
|
validate
|
train
|
function validate(options) {
const schema = joi.object().keys({
config: joi.array().min(_.keys(options.models).length).required(),
acl: joi.object().required(),
models: joi.object().required()
});
joi.assert(options, schema, 'Invalid Shield Options:');
return true;
}
|
javascript
|
{
"resource": ""
}
|
q3734
|
init
|
train
|
function init(options) {
validate(options);
setAuthConfig(options.config);
setAcl(options.acl);
setModels(options.models);
}
|
javascript
|
{
"resource": ""
}
|
q3735
|
Radio
|
train
|
function Radio (url) {
var self = this;
Block.apply(self, arguments);
self.audio = document.createElement('audio');
self.audio.autoplay = true;
self.audio.src = self.url;
self.node = self.app.context.createMediaElementSource(self.audio);
self.audio.play();
//show code in textarea
self.input = q('input', self.content);
self.input.value = self.url;
//update url
on(self.input, 'change', function () {
self.audio.src = self.input.value;
});
//go ready state
self.state = 'ready';
}
|
javascript
|
{
"resource": ""
}
|
q3736
|
keys
|
train
|
function keys(object, follow = false) {
// check if the object is an object and it's not empty
if (is(object) && !empty(object)) {
// create an empty array for the result
let result = [];
// if follow is enabled
if (follow) {
// create a new function which gets the keys and
// adds them with dot notation to the results array
const followKeys = (obj, currentPath) => {
// get all the keys for the inner object
Object.keys(obj).forEach((key) => {
// parse the dot notation path
const followPath = `${currentPath}.${key}`;
// if the result is an object run the function again
// for that object
if (is(obj[key]) && !empty(obj[key])) {
// the value is an object so run the function again
// for that object but with the new path
followKeys(obj[key], followPath);
}
// add the new parsed path to the result object
result.push(followPath);
});
};
// for each key in the specified object
Object.keys(object).forEach((key) => {
// add the key to the results array
result.push(key);
// if the value of the key is an object add all them keys
// to the results array
if (is(object[key]) && !empty(object[key])) {
// the value is an object so add all them keys also
// to the results array
followKeys(object[key], key);
}
});
} else {
// if follow isn't enabled just add all the base object keys
// to the results array
result = Object.keys(object);
}
// return the results array
return result;
}
// if the object isn't an object or its empty return an empty array
return [];
}
|
javascript
|
{
"resource": ""
}
|
q3737
|
hierarchy
|
train
|
function hierarchy (config) {
const templates = _.mapValues(config.templates, augmentSingleFile)
const partials = _.mapValues(config.partials, augmentSingleFile)
return {
children: Object.keys(templates).map((name) => {
let template = templates[name]
return {
name: name,
type: 'template',
path: template.path,
comments: template.comments,
children: template.callsPartial
.map((callee) => callee.name)
// Remove redundant names (only take the first one)
.filter((name, index, array) => array.indexOf(name) === index)
.map((name) => partialForCallTree(name, partials, {}))
}
})
}
}
|
javascript
|
{
"resource": ""
}
|
q3738
|
partialForCallTree
|
train
|
function partialForCallTree (name, partials, visitedNodes) {
const cycleFound = visitedNodes[name]
try {
visitedNodes[name] = true
const partial = partials[name]
if (!partial) {
throw new Error(`Missing partial "${name}"`)
}
let children
if (!cycleFound) {
children = partial.callsPartial
.map((callee) => callee.name)
// Remove redundant names (only take the first one)
.filter((name, index, array) => array.indexOf(name) === index)
.map((name) => partialForCallTree(name, partials, visitedNodes))
}
return {
name,
type: 'partial',
comments: partial.comments,
path: partial.path,
children,
cycleFound
}
} finally {
if (!cycleFound) {
delete visitedNodes[name]
}
}
}
|
javascript
|
{
"resource": ""
}
|
q3739
|
keyOf
|
train
|
function keyOf(object, value, follow = false) {
// if the object is an object and is not empty
if (is(object) && !empty(object)) {
// create a found boolean so we can skip
// over keys once we have found the correct
// key
let found = false;
// create an result variable as false
let result = '';
// for each key/value in the object
// follow is passed into each therefore the
// each function works out whether to follow
// the objects
each(object, (key, objValue) => {
// if the result isn't already found
if (!found) {
// check if the object value is equal to
// the specified value
if (objValue === value) {
// set found to true since the key was found
found = true;
// if the values are the same set the result
// to the key
result = key;
}
}
}, follow);
// return the result if it was found else return
// undefined
return found
? result
: undefined;
}
// if the object isn't an object or is empty return
// false because the object can't be checked
return undefined;
}
|
javascript
|
{
"resource": ""
}
|
q3740
|
every
|
train
|
function every(object, iterator, follow = false) {
// if the object is an object and is not empty
if (is(object) && !empty(object) && typeof iterator === 'function') {
// set the result to true so we can change it
// to false if the iterator fails
let result = true;
// for each over the object keys and values
// follow is passed into each therefore the
// each function works out whether to follow
// the objects
each(object, (key, value) => {
// run the iterator function on the key and
// value and if it evaluates to false set
// the result to false
if (iterator(key, value) === false) {
// set the result to false
result = false;
}
}, follow);
// return the result
return result;
}
// if the object isn't an object or is empty return false
// because the iterator can't be ran to make a check
return false;
}
|
javascript
|
{
"resource": ""
}
|
q3741
|
parseStaticRoutes
|
train
|
function parseStaticRoutes(config) {
Object.keys(config).map((key) => {
StaticRoutes.push({
method: 'get',
route: key,
controller: config[key].target,
action: '*',
options: config[key].options,
generated: true,
debug: {
controller: config[key].target,
action: '*'
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q3742
|
extractErrorHandler
|
train
|
function extractErrorHandler(target, name) {
if(name.indexOf('#') !== -1) {
const [controller, action] = name.split('#');
ErrorsHandler.push({
target: target,
controller,
action,
});
} else {
ErrorsHandler.push({
target: target,
controller: name,
});
}
}
|
javascript
|
{
"resource": ""
}
|
q3743
|
generate
|
train
|
function generate() {
for(const i in Routes) {
if(!Routes[i].generated) {
Routes[i] = generateController(path.controllers, Routes[i]);
}
}
for(const i in MiddleWares) {
MiddleWares[i] = generateController(path.middlewares, MiddleWares[i]);
}
for(const i in GlobalMiddleWares) {
GlobalMiddleWares[i] = generateController(path.middlewares, GlobalMiddleWares[i]);
}
for(const i in ErrorsHandler) {
ErrorsHandler[i] = generateController(path.errorHandler, ErrorsHandler[i]);
}
for(const i in Services) {
Services[i] = generateService(path.services, Services[i]);
}
}
|
javascript
|
{
"resource": ""
}
|
q3744
|
train
|
function(prop){
var props = {},
len, i = 0, item;
prop = Array.from(prop);
len = prop.length;
while(len--){
props[prop[i++]] = void 0;
}
// void 0 is used because 'undefined' is a var that can be changed in some browsers
this.set(props);
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q3745
|
loadBinary
|
train
|
function loadBinary (file, callback) {
if (isPlask) {
loadBinaryPlask(file, callback)
} else {
loadBinaryBrowser(file, callback)
}
}
|
javascript
|
{
"resource": ""
}
|
q3746
|
map
|
train
|
function map(object, iterator, follow = false) {
// if the object is an object and is not empty
if (is(object) && !empty(object) && typeof iterator === 'function') {
// create an empty object for the result
let result = {};
// for each key/value in the object
// follow is passed into each therefore the
// each function works out whether to follow
// the objects
each(object, (key, value) => {
// set the result to the object with the key/value computed
// from the specified iterator
result = set(result, key, iterator(key, value));
}, follow);
// return the result
return result;
}
// if the object isn't an object or is empty return an
// empty object because the iterator can't be ran to
// compute the values
return {};
}
|
javascript
|
{
"resource": ""
}
|
q3747
|
trending
|
train
|
function trending () {
var language;
var timespan;
var callback;
if (arguments.length === 3) {
language = arguments[0];
timespan = arguments[1];
callback = arguments[2];
}
else if (arguments.length === 2) {
language = arguments[0];
callback = arguments[1];
}
else {
callback = arguments[0];
}
language = (language || 'all').toLowerCase();
timespan = timespan || 'daily';
function onResponse (err, html) {
var repositories;
if (err) {
return callback(new VError(err, 'failed to fetch trending repositories (language: %s).', language));
}
repositories = scraper.repositories(html);
callback(null, repositories);
}
mandatory(callback)
.is('function', 'Please define a proper callback function.');
request(endpoint, { l: language, since: timespan }, onResponse);
}
|
javascript
|
{
"resource": ""
}
|
q3748
|
find
|
train
|
function find(object, iterator, follow) {
// if the object is an object and is not empty
if (is(object) && !empty(object) && typeof iterator === 'function') {
// create an result variable as undefined
let found = false;
let result = '';
// for each key/value in the object
// follow is passed into each therefore the
// each function works out whether to follow
// the objects
each(object, (key, value) => {
// if the value hasn't already been found
if (!found) {
// check if the iterator is false if it
// is false then delete that key from the object
if (iterator(key, value) === true) {
found = true;
result = key;
}
}
}, follow);
// return the result unless the value wasn't found
// then return undefined
return found
? result
: undefined;
}
// if the object isn't an object or is empty return
// undefined because the iterator can't be ran to
// make a check
return undefined;
}
|
javascript
|
{
"resource": ""
}
|
q3749
|
loadImage
|
train
|
function loadImage (file, callback, crossOrigin) {
if (isPlask) {
loadImagePlask(file, callback)
} else {
loadImageBrowser(file, callback, crossOrigin)
}
}
|
javascript
|
{
"resource": ""
}
|
q3750
|
slice
|
train
|
function slice(object, start, end = Object.keys(object).length) {
// if the object is an object and is not empty
if (is(object) && !empty(object)) {
// get the keys from the object
const objKeys = keys(object);
// create an empty object for the result
const result = {};
// slice the object keys to the specified start and end
// and for each key returned
objKeys.slice(start, end).forEach((key) => {
// set the result object key to the value
result[key] = object[key];
});
// return the result
return result;
}
// if the object isn't an object or is empty return an
// empty object because slicing won't return anything anyway
return {};
}
|
javascript
|
{
"resource": ""
}
|
q3751
|
get
|
train
|
function get(object, path, defaultValue = undefined) {
// check if the object is an object and is not empty
// and it has the path specified
if (is(object) && !empty(object) && has(object, path)) {
// set the currentValue to the object so its easier to
// iterate over the objects
let currentValue = object;
// for each path parts from the parsed path
getPathParts(path).forEach((key) => {
currentValue = currentValue[key];
});
// if it isn't undefined return the value
return currentValue;
}
// if the object isn't an object or it is empty or
// it doesn't have the specified path return the
// default value
return defaultValue;
}
|
javascript
|
{
"resource": ""
}
|
q3752
|
has
|
train
|
function has(object, ...paths) {
// check if object is an object
if (is(object) && !empty(object)) {
// set the result to true by default
let hasPaths = true;
// for each path specified
paths.forEach((path) => {
// get the parsed path parts
const parts = getPathParts(path);
// set the current value so its easier to iterate over
let currentValue = object;
// for each part in the path
parts.forEach((key) => {
if (is(currentValue) && !empty(currentValue)) {
currentValue = currentValue[key];
} else {
currentValue = undefined;
}
});
// check if the currentValue is undefined meaning that the path
// doesn't exist
if (currentValue === undefined) {
// if the currentValue is undefined set hasPaths to false
// this will lead to the function returning false because
// the object specified doesn't have all the paths specified
hasPaths = false;
}
});
// return whether or not all the paths exist in the specified object
return hasPaths;
}
// return false because the object specified isn't an object
return false;
}
|
javascript
|
{
"resource": ""
}
|
q3753
|
train
|
function(stat)
{
if(stat)
{
if(stat.isDirectory)
{
return stat.isDirectory()
}
if(stat.type)
{
if(stat.type=="dir")
{
return true
}
}
}
return false
}
|
javascript
|
{
"resource": ""
}
|
|
q3754
|
train
|
function() {
this.jsonInit({
"message0": Blockly.Msg.LOOKS_CHANGESIZEBY,
"args0": [
{
"type": "field_dropdown",
"name": "TYPE",
"options": [
[Blockly.Msg.LOOKS_SETSIZETO_SIZE, 'size'],
[Blockly.Msg.LOOKS_SETSIZETO_STRETCH_X, 'stretch x'],
[Blockly.Msg.LOOKS_SETSIZETO_STRETCH_Y, 'stretch y']
]
},
{
"type": "input_value",
"name": "CHANGE"
}
],
"category": Blockly.Categories.looks,
"extensions": ["colours_looks", "shape_statement"]
});
}
|
javascript
|
{
"resource": ""
}
|
|
q3755
|
startsWith
|
train
|
function startsWith(str, test){
if(str === test){ return true; }
return str.substring(0, test.length+1) === test+'.';
}
|
javascript
|
{
"resource": ""
}
|
q3756
|
push
|
train
|
function push(arr){
var i, len = arr.length;
this.added || (this.added = {});
for(i=0;i<len;i++){
arr[i].markDirty();
if(this.added[arr[i].cid]) continue;
this.added[arr[i].cid] = 1;
this.push(arr[i]);
}
}
|
javascript
|
{
"resource": ""
}
|
q3757
|
recomputeCallback
|
train
|
function recomputeCallback(){
var len = TO_CALL.length;
CALL_TIMEOUT = null;
while(len--){
(TO_CALL.shift() || NOOP).call();
}
TO_CALL.added = {};
}
|
javascript
|
{
"resource": ""
}
|
q3758
|
train
|
function(){
var root = this.__root__;
var context = this.__parent__;
root.__computedDeps || (root.__computedDeps = {});
_.each(this.deps, function(path){
// For each dependancy, mark ourselves as dirty if they become dirty
var dep = root.get(path, {raw: true, isPath: true});
if(dep && dep.isComputedProperty){ dep.on('dirty', this.markDirty); }
// Find actual context and path from relative paths
var split = $.splitPath(path);
while(split[0] === '@parent'){
context = context.__parent__;
split.shift();
}
path = context.__path().replace(/\.?\[.*\]/ig, '.@each');
path = path + (path && '.') + split.join('.');
// Add ourselves as dependants
root.__computedDeps[path] || (root.__computedDeps[path] = []);
root.__computedDeps[path].push(this);
}, this);
// Ensure we only have one listener per Model at a time.
context.off('all', this.onRecompute).on('all', this.onRecompute);
}
|
javascript
|
{
"resource": ""
}
|
|
q3759
|
train
|
function(object){
var target = this.value();
if(!object || !target || !target.isData || !object.isData){ return void 0; }
target._cid || (target._cid = target.cid);
object._cid || (object._cid = object.cid);
target.cid = object.cid;
this.tracking = object;
}
|
javascript
|
{
"resource": ""
}
|
|
q3760
|
train
|
function(key, options={}){
if(this.returnType === 'value'){ return console.error('Called get on the `'+ this.name +'` computed property which returns a primitive value.'); }
return this.value().get(key, options);
}
|
javascript
|
{
"resource": ""
}
|
|
q3761
|
train
|
function(key, val, options={}){
if(this.returnType === null){ return void 0; }
var attrs = key;
var value = this.value();
// Noralize the data passed in
if(this.returnType === 'model'){
if (typeof key === 'object') {
attrs = (key.isModel) ? key.attributes : key;
options = val || {};
} else {
(attrs = {})[key] = val;
}
}
if(this.returnType !== 'model'){ options = val || {}; }
attrs = (attrs && attrs.isComputedProperty) ? attrs.value() : attrs;
// If a new value, set it and trigger events
this.setter && this.setter.call(this.__root__, attrs);
if(this.returnType === 'value' && this.cache.value !== attrs) {
this.cache.value = attrs;
if(!options.quiet){
// If set was called not through computedProperty.call(), this is a fresh new event burst.
if(!this.isDirty && !this.isChanging) this.__parent__.changed = {};
this.__parent__.changed[this.name] = attrs;
this.trigger('change', this.__parent__);
this.trigger('change:'+this.name, this.__parent__, attrs);
delete this.__parent__.changed[this.name];
}
}
else if(this.returnType !== 'value' && options.reset){ key = value.reset(attrs, options); }
else if(this.returnType !== 'value'){ key = value.set(attrs, options); }
this.isDirty = this.isChanging = false;
// Call all reamining computed properties waiting for this value to resolve.
_.each(this.waiting, function(prop){ prop && prop.call(); });
return key;
}
|
javascript
|
{
"resource": ""
}
|
|
q3762
|
train
|
function(obj, options={}){
if(_.isNull(this.returnType)){ return void 0; }
options.reset = true;
return this.set(obj, options);
}
|
javascript
|
{
"resource": ""
}
|
|
q3763
|
train
|
function() {
if (this._isSerializing){ return this.cid; }
var val = this.value();
this._isSerializing = true;
var json = (val && _.isFunction(val.toJSON)) ? val.toJSON() : val;
this._isSerializing = false;
return json;
}
|
javascript
|
{
"resource": ""
}
|
|
q3764
|
fromEventCapture
|
train
|
function fromEventCapture(element, name) {
return Observable.create((subj) => {
const handler = function (...args) {
if (args.length > 1) {
subj.next(args);
} else {
subj.next(args[0] || true);
}
};
element.addEventListener(name, handler, true);
return new Subscription(() => element.removeEventListener(name, handler, true));
});
}
|
javascript
|
{
"resource": ""
}
|
q3765
|
train
|
function(obj){
var validators = Object.clone(this._validators),
// Store the global validator
global = validators[asterisk], keys;
// If global validator exists, test the object against it
if (global) {
// remove '*' validator from validators obj otherwise comparing keys will not pass
delete validators[asterisk];
// retrieve keys of obj for comparison;
keys = Object.keys(obj);
// return global(obj) && Object.every(validators, function(val, prop){ return prop in obj;});
return global(obj) && Object.keys(validators).every( keys.contains.bind(keys) );
} else {
// result and Snitch.proof must return true in order to pass proofing
return Snitch.proof(obj, validators);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3766
|
respond
|
train
|
function respond(ctx) {
// allow bypassing koa
if (false === ctx.respond) return;
const res = ctx.res;
if (!ctx.writable) return;
let body = ctx.body;
const code = ctx.status;
// ignore body
if (statuses.empty[code]) {
// strip headers
ctx.body = null;
return res.end();
}
if ("HEAD" == ctx.method) {
if (!res.headersSent && isJSON(body)) {
ctx.length = Buffer.byteLength(JSON.stringify(body));
}
return res.end();
}
// status body
if (null == body) {
body = ctx.message || String(code);
if (!res.headersSent) {
ctx.type = "text";
ctx.length = Buffer.byteLength(body);
}
return res.end(body);
}
// responses
if (Buffer.isBuffer(body)) return res.end(body);
if ("string" == typeof body) return res.end(body);
if (body instanceof Stream) return body.pipe(res);
// body: json
body = JSON.stringify(body);
if (!res.headersSent) {
ctx.length = Buffer.byteLength(body);
}
res.end(body);
}
|
javascript
|
{
"resource": ""
}
|
q3767
|
getHexValue
|
train
|
function getHexValue(rune) {
if ("0" <= rune && rune <= "9") {
return rune.charCodeAt(0) - 48;
}
if ("a" <= rune && rune <= "f") {
return rune.charCodeAt(0) - 87;
}
if ("A" <= rune && rune <= "F") {
return rune.charCodeAt(0) - 55;
}
return -1;
}
|
javascript
|
{
"resource": ""
}
|
q3768
|
flip
|
train
|
function flip(object, follow = false, useToString = false) {
// if the object is an object and is not empty
if (is(object) && !empty(object)) {
// create an empty object for the result
const result = {};
// for each key/value in the object
each(object, (key, value) => {
// if the value is a string it can be used as
// the new key
if (typeof value === 'string') {
// set the new key/value to the result
result[value] = key;
} else if (typeof value !== 'string' && useToString) {
// if the value isn't a string but useToString is true
// toString the value
result[String(value).toString()] = key;
}
}, follow);
// return the result object
return result;
}
// if the object isn't an object or is empty return
// an empty object
return {};
}
|
javascript
|
{
"resource": ""
}
|
q3769
|
traverse
|
train
|
function traverse(segments, tree, trail, iteration) {
if (iteration === undefined) {
iteration = 0;
}
iteration += 1;
var last = segments.pop();
if (last) {
if (tree[last] !== undefined) {
trail.unshift(last);
return traverse(segments, tree[last], trail);
}
if (tree["*"] !== undefined) {
if (tree["!" + last] !== undefined) {
return last;
}
trail.unshift(last);
return traverse(segments, tree["*"], trail);
}
if (tree[true]) {
return last;
}
if (iteration === 1) {
// In first iteration everything is allowed (eg. foo.bar.example)
trail.unshift(last);
last = segments.pop();
if (last) {
return last;
}
}
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
q3770
|
reverse
|
train
|
function reverse(iterable) {
assert(
arguments.length < 2,
'The `resolve()` method not support more than one argument. Use `series() or `evenly()` to combine iterators.'
);
if (arguments.length === 0) {
return createIterator();
}
const iter = createIterator(iterable);
const arr = Array.from(iter);
let index = arr.length - 1;
return {
[Symbol.iterator]() { return this; },
next() {
if (index === -1) {
return done;
}
return {
value: arr[index--],
done: false
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
q3771
|
forEachValue
|
train
|
function forEachValue (obj, iteratee) {
Object.keys(obj).forEach((key) => iteratee(obj[key], key, obj))
}
|
javascript
|
{
"resource": ""
}
|
q3772
|
train
|
function(){
if(this.cache === NIL){ return void 0; }
this.cache = NIL;
for (var i = 0, l = this.subscribers.length; i < l; i++) {
this.subscribers[i].isLazyValue && this.subscribers[i].makeDirty();
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3773
|
train
|
function() {
this.makeDirty();
for (var i = 0, l = this.subscribers.length; i < l; i++) {
if(!this.subscribers[i]){ continue; }
else if(this.subscribers[i].isLazyValue){
this.subscribers[i].destroyed ? (this.subscribers[i] = void 0) : this.subscribers[i].notify();
}
else{
this.subscribers[i](this);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q3774
|
set
|
train
|
function set(object, path, value) {
// check if the object is an object
if (is(object)) {
// clone the object
let cloned = clone(object);
// set a new value for the cloned object so we
// can manipulate it
const result = cloned;
// get the path parts
const pathParts = getPathParts(path);
// loop over all the path parts
for (let index = 0; index < pathParts.length; index += 1) {
// get the current key
const key = pathParts[index];
// check if the value is an object
if (!is(cloned[key])) {
// if it isn't an object set it to an empty object
cloned[key] = {};
}
// check if the current path is the last key
if (index === pathParts.length - 1) {
// if it is the last key set it as the value
cloned[key] = value;
}
// set the modified values to the object
cloned = cloned[key];
}
// returned the result
return result;
}
// if the object isn't an object return an empty
// object this will keep the return immutable
return {};
}
|
javascript
|
{
"resource": ""
}
|
q3775
|
Microphone
|
train
|
function Microphone (options) {
var self = this;
Block.apply(self, arguments);
//get access to the microphone
getUserMedia({video: false, audio: true}, function (err, stream) {
if (err) {
console.log('failed to get microphone');
self.state = 'error';
} else {
self.node = self.app.context.createMediaStreamSource(stream);
self.restart();
self.state = 'ready';
}
});
return self;
}
|
javascript
|
{
"resource": ""
}
|
q3776
|
moduleIfString
|
train
|
function moduleIfString (pathOrObject, type) {
// If this is a string, treat if as module to be required
try {
if (_.isString(pathOrObject)) {
// Attempt to find module without resolving the contents
// If there is an error, the module does not exist (which
// is ignored at the moment)
// If there is no error, the module should be loaded and error while loading
// the module should be reported
require.resolve(path.resolve(pathOrObject))
}
} catch (e) {
debug('Ignoring missing ' + type + ' module: ' + pathOrObject)
pathOrObject = undefined
}
// Require module if needed
if (_.isString(pathOrObject)) {
var absPath = path.resolve(pathOrObject)
delete require.cache[absPath]
pathOrObject = require(absPath)
}
return pathOrObject
}
|
javascript
|
{
"resource": ""
}
|
q3777
|
train
|
function(fm, extraObj) {
// `init` event callback function
fm.bind('init', function() {
// Optional for Japanese decoder "encoding-japanese"
if (fm.lang === 'ja') {
require(
[ 'encoding-japanese' ],
function(Encoding) {
if (Encoding && Encoding.convert) {
fm.registRawStringDecoder(function(s) {
return Encoding.convert(s, {to:'UNICODE',type:'string'});
});
}
}
);
}
});
}
|
javascript
|
{
"resource": ""
}
|
|
q3778
|
createCmdButton
|
train
|
function createCmdButton(cmd, label, forceCheckbox, className) {
var button;
button = document.createElement('button');
button.className = className || 'btn';
button.innerHTML = label;
button.onclick = function() {
var cl;
var clients, doLogic;
cl = node.game.clientList;
// Get selected clients.
clients = cl.getSelectedClients();
if (!clients || clients.length === 0) return;
// If the room's logic client is selected, handle it specially.
if (node.game.roomLogicId) {
doLogic = J.removeElement(cl.roomLogicId, clients);
}
node.socket.send(node.msg.create({
target: 'SERVERCOMMAND',
text: 'ROOMCOMMAND',
data: {
type: cmd,
roomId: cl.roomId,
doLogic: !!doLogic,
clients: clients,
force: forceCheckbox.checked
}
}));
};
return button;
}
|
javascript
|
{
"resource": ""
}
|
q3779
|
train
|
function() {
var e = this.originalEvent;
this.defaultPrevented = true;
this.isDefaultPrevented = returnTrue;
if ( e && e.preventDefault ){ e.preventDefault(); }
}
|
javascript
|
{
"resource": ""
}
|
|
q3780
|
getCallbacks
|
train
|
function getCallbacks(target, delegate, eventType){
var callbacks = [];
if(target.delegateGroup && EVENT_CACHE[target.delegateGroup][eventType]){
_.each(EVENT_CACHE[target.delegateGroup][eventType], function(callbacksList, delegateId){
if(_.isArray(callbacksList) && (delegateId === delegate.delegateId || ( delegate.matchesSelector && delegate.matchesSelector(delegateId) )) ){
callbacks = callbacks.concat(callbacksList);
}
});
}
return callbacks;
}
|
javascript
|
{
"resource": ""
}
|
q3781
|
enumerateFunctions
|
train
|
function enumerateFunctions(relations) {
const blacklist = [
'use',
'tearDown',
'define'
];
return _.reduce(relations, function(functions, prop, key) {
if (blacklist.indexOf(key) === -1 && _.isFunction(prop)) {
functions.push(key);
}
return functions;
}, []);
}
|
javascript
|
{
"resource": ""
}
|
q3782
|
each
|
train
|
function each(object, iterator, follow = false) {
// check if the object is an object and isn't empty
// if it is it would be pointless running the forEach
if (is(object) && !empty(object) && typeof iterator === 'function') {
// if follow is true flatten the object keys so
// its easy to get the path and values if follow
// is false it will just be the base object
// therefore it will only use the base keys
const flattenedObject = follow
? deflate(object)
: object;
// loop over the keys of the object
Object.keys(flattenedObject).forEach((key) => {
// get the value of the current key
const value = flattenedObject[key];
// run the iterator with the key and value
iterator(key, value);
});
// return true because the iterator was ran
return true;
}
// return false because the iterator couldn't of been ran
return false;
}
|
javascript
|
{
"resource": ""
}
|
q3783
|
includes
|
train
|
function includes(object, value, follow = false) {
// if the object is an object and is not empty
if (is(object) && !empty(object)) {
// create an result variable as false
let result = false;
// for each key/value in the object
// follow is passed into each therefore the
// each function works out whether to follow
// the objects
each(object, (key, objValue) => {
// if the result isn't already true
if (!result) {
// check if the object value is equal to
// the specified value
if (objValue === value) {
// if they are the same set the result
// to true
result = true;
}
}
}, follow);
// return the result
return result;
}
// if the object isn't an object or is empty return
// false because the object can't be checked
return false;
}
|
javascript
|
{
"resource": ""
}
|
q3784
|
_publish
|
train
|
function _publish(obj, callback) {
// Write the object to the separate file.
var shortname = prop + '.json';
var data = JSON.stringify(obj);
var hash = _checkNewHash(shortname, data);
if (!hash) {
// No need to publish if the data is the same.
return callback();
}
published[shortname] = true;
// Update new object and call notifications.
_updateObject(shortname, obj, hash);
var fullname = path.join(folder, shortname);
fs.writeFile(fullname, data, function (err) {
if (err) {
console.error('Failed to write file %s err:', fullname, err);
}
return callback(err);
});
}
|
javascript
|
{
"resource": ""
}
|
q3785
|
close
|
train
|
function close() {
if (watcher && !closed) {
if (options.persistent) {
// Close handle only if watcher was created persistent.
watcher.close();
}
else {
// Stop handling change events.
watcher.removeAllListeners();
// Leave watcher on error events that may come from unclosed handle.
watcher.on('error', function (err) { });
}
closed = true;
}
}
|
javascript
|
{
"resource": ""
}
|
q3786
|
_updateSingleton
|
train
|
function _updateSingleton() {
if (!options.singletons) {
return;
}
if (process.rebusinstances[folder]) {
// Somebody added instance already.
return;
}
// Save this instance to return the same for the same folder.
process.rebusinstances[folder] = instance;
}
|
javascript
|
{
"resource": ""
}
|
q3787
|
_startWatchdog
|
train
|
function _startWatchdog() {
if (!watcher) {
var watcherOptions = { persistent: !!options.persistent };
watcher = fs.watch(folder, watcherOptions, function (event, filename) {
if (event === 'change' && filename.charAt(0) != '.') {
// On every change load the changed file. This will trigger notifications for interested
// subscribers.
_loadFile(filename);
}
});
}
}
|
javascript
|
{
"resource": ""
}
|
q3788
|
_loadFile
|
train
|
function _loadFile(filename, callback) {
callback = callback || function () { };
if (filename.charAt(0) == '.') {
callback();
return;
}
var filepath = path.join(folder, filename);
fs.readFile(filepath, function (err, data) {
if (err) {
console.error('Failed to read file ' + filepath + ' err:', err);
callback(err);
return;
}
try {
_loadData(filename, data.toString());
}
catch (e) {
console.info('Object ' + filename + ' was not yet fully written, exception:', e);
// There will be another notification of change when the last write to file is completed.
// Meanwhile leave the previous value.
if (loader) {
// Store this error to wait until file will be successfully loaded for the 1st time.
loader.errors[filename] = e;
}
// Don't return error to continue asynchronous loading of other files. Errors are assembled on loader.
callback();
return;
}
console.log('Loaded ' + filename);
if (loader) {
if (loader.errors[filename]) {
// File that previously failed to load, now is loaded.
delete loader.errors[filename];
var countErrors = Object.keys(loader.errors).length;
if (countErrors === 0) {
// All errors are fixed. This is the time to complete loading.
var initcb = loader.callback;
loader = null;
_updateSingleton();
initcb();
}
}
}
callback();
});
}
|
javascript
|
{
"resource": ""
}
|
q3789
|
_traverse
|
train
|
function _traverse(props, obj, notification) {
var length = props.length;
var refobj = shared;
var refmeta = meta;
var handler = {};
var fns = [];
for (var i = 0; i < length; i++) {
var prop = props[i];
if (!refmeta[prop]) {
refmeta[prop] = {};
refmeta[prop][nfs] = {};
}
var currentmeta = refmeta[prop];
if (!refobj[prop]) {
refobj[prop] = {};
}
var currentobj = refobj[prop];
if (i === (length - 1)) {
// The end of the path.
if (obj) {
// Pin the object here.
refobj[prop] = obj;
// Since object changed, append all notifications in the subtree.
_traverseSubtree(currentmeta, obj, fns);
}
if (notification) {
// Pin notification at the end of the path.
var id = freeId++;
currentmeta[nfs][id] = notification;
// Return value indicates where the notification was pinned.
handler = { id: id, close: closeNotification };
handler[nfs] = currentmeta[nfs];
// Call the notification with initial value of the object.
// Call notification in the next tick, so that return value from subsribtion
// will be available.
process.nextTick(function () {
notification(currentobj);
});
}
}
else if (obj) {
// If change occured, call all notifications along the path.
_pushNotifications(currentmeta, currentobj, fns);
}
// Go deep into the tree.
refobj = currentobj;
refmeta = currentmeta;
}
if (obj) {
// Call all notifications.
async.parallel(fns);
}
return handler;
}
|
javascript
|
{
"resource": ""
}
|
q3790
|
_traverseSubtree
|
train
|
function _traverseSubtree(meta, obj, fns) {
_pushNotifications(meta, obj, fns);
for (var key in meta) {
if (key === nfs) {
continue;
}
var subobj;
if (obj) {
subobj = obj[key];
}
_traverseSubtree(meta[key], subobj, fns);
}
}
|
javascript
|
{
"resource": ""
}
|
q3791
|
_pushNotifications
|
train
|
function _pushNotifications(meta, obj, fns) {
for (var id in meta[nfs]) {
fns.push(function (i) {
return function () {
meta[nfs][i](obj);
}
} (id));
}
}
|
javascript
|
{
"resource": ""
}
|
q3792
|
children
|
train
|
function children(tree, query, options) {
var compiledQuery = query ? _.matches(query) : null;
var settings = _.defaults(options, {
childNode: ['children']
});
settings.childNode = _.castArray(settings.childNode);
var rootNode = query ? treeTools.find(tree, query) : tree;
var seekStack = [];
var seekDown = function seekDown(branch, level) {
if (level > 0) seekStack.push(branch);
settings.childNode.some(function (key) {
if (branch[key] && _.isArray(branch[key])) {
branch[key].forEach(function (branchChild) {
seekDown(branchChild, level + 1);
});
return true;
}
});
};
seekDown(rootNode, 0);
return seekStack;
}
|
javascript
|
{
"resource": ""
}
|
q3793
|
getPackageInfoFrom
|
train
|
function getPackageInfoFrom(string) {
if (string[0] === '@') {
const [scope, rawName] = string.split('/');
const { name, version } = getVersionFromString(rawName);
return {
name: `${scope}/${name}`,
version,
};
}
return getVersionFromString(string);
}
|
javascript
|
{
"resource": ""
}
|
q3794
|
visProps
|
train
|
function visProps(props) {
const {
data,
height,
width,
} = props;
const padding = {
top: 20,
right: 20,
bottom: 40,
left: 50,
};
const plotAreaWidth = width - padding.left - padding.right;
const plotAreaHeight = height - padding.top - padding.bottom;
const xDomain = d3.extent(data, d => d.x);
const yDomain = d3.extent(data, d => d.y);
const xDomainPadding = 0.05 * xDomain[1];
const yDomainPadding = 0.02 * yDomain[1];
const xScale = d3.scaleLinear()
.domain([xDomain[0] - xDomainPadding, xDomain[1] + xDomainPadding])
.range([0, plotAreaWidth]);
const yScale = d3.scaleLinear()
.domain([yDomain[0] - yDomainPadding, yDomain[1] + yDomainPadding])
.range([plotAreaHeight, 0]);
const color = ({ y }) => `rgb(150, 200, ${Math.floor(255 * (yScale(y) / plotAreaHeight))})`;
const voronoiDiagram = d3.voronoi()
.x(d => xScale(d.x))
.y(d => yScale(d.y))
.size([plotAreaWidth, plotAreaHeight])(data);
return {
color,
padding,
plotAreaWidth,
plotAreaHeight,
xScale,
yScale,
voronoiDiagram,
};
}
|
javascript
|
{
"resource": ""
}
|
q3795
|
excludeIncludeKeys
|
train
|
function excludeIncludeKeys(objA, objB, excludeKeys, includeKeys) {
let keysA = Object.keys(objA);
let keysB = Object.keys(objB);
if (excludeKeys) {
keysA = keysA.filter(key => excludeKeys.indexOf(key) === -1);
keysB = keysB.filter(key => excludeKeys.indexOf(key) === -1);
} else if (includeKeys) {
keysA = keysA.filter(key => includeKeys.indexOf(key) !== -1);
keysB = keysB.filter(key => includeKeys.indexOf(key) !== -1);
}
return [keysA, keysB];
}
|
javascript
|
{
"resource": ""
}
|
q3796
|
loadPlugin
|
train
|
function loadPlugin(descriptor, loader) {
const config = Array.isArray(descriptor) ? descriptor : [descriptor];
const [name, options = {}] = config;
const { error, module: plugin } = loader(name);
if (error) {
return {
error,
name,
};
}
if (typeof plugin !== 'function') {
return {
error: new Error(
`Expected the plugin \`${name}\` to export a function, instead ` +
`recieved: ${typeof plugin}`
),
name,
};
}
return {
name,
options,
plugin,
};
}
|
javascript
|
{
"resource": ""
}
|
q3797
|
loadPreset
|
train
|
function loadPreset(descriptor, loader) {
const config = Array.isArray(descriptor) ? descriptor : [descriptor];
const [name, options = {}] = config;
const { error: loaderError, module: getPreset } = loader(name);
if (loaderError) {
return {
error: loaderError,
name,
};
}
if (typeof getPreset !== 'function') {
return {
error: new Error(
`Expected the preset \`${name}\` to export a function, instead ` +
`recieved: ${typeof getPreset}`
),
name,
};
}
let preset;
try {
preset = getPreset(options);
} catch (error) {
return {
error,
name,
options,
};
}
const { presets = [], plugins = [] } = preset;
return {
name,
options,
presets: presets.map(descriptor => loadPreset(descriptor, loader)),
plugins: plugins.map(descriptor => loadPlugin(descriptor, loader)),
};
}
|
javascript
|
{
"resource": ""
}
|
q3798
|
create
|
train
|
async function create(name, options, api, env) {
// Grab the cwd and npmClient off of the environment. We can use these to
// create the folder for the project and for determining what client to use
// for npm-related commands
const { CLI_ENV, cwd, npmClient } = env;
// We support a couple of options for our `create` command, some only exist
// during development (like link and linkCli).
const { link, linkCli, plugins = [], presets = [], skip } = options;
const root = path.join(cwd, name);
logger.trace('Creating project:', name, 'at:', root);
if (await fs.exists(root)) {
throw new Error(`A folder already exists at \`${root}\``);
}
// Create the root directory for the new project
await fs.ensureDir(root);
const {
writePackageJson,
installDependencies,
linkDependencies,
} = await createClient(npmClient, root);
const packageJson = {
name,
private: true,
license: 'MIT',
scripts: {},
dependencies: {},
devDependencies: {},
toolkit: {},
};
// Write the packageJson to the newly created `root` folder
await writePackageJson(packageJson);
const installer = linkCli ? linkDependencies : installDependencies;
await installer(['@carbon/toolkit']);
if (CLI_ENV === 'production') {
clearConsole();
}
if (skip) {
displaySuccess(root, name, npmClient);
return;
}
const toolkit = await which('toolkit', { cwd: root });
if (presets.length > 0) {
const args = ['add', ...presets, link && '--link'].filter(Boolean);
await spawn(toolkit, args, {
cwd: root,
stdio: 'inherit',
});
}
if (plugins.length > 0) {
const args = ['add', ...plugins, link && '--link'].filter(Boolean);
await spawn(toolkit, args, {
cwd: root,
stdio: 'inherit',
});
}
displaySuccess(root, name, npmClient);
}
|
javascript
|
{
"resource": ""
}
|
q3799
|
collect
|
train
|
function collect(str, type) {
if (!type) {
if (otherRE.test(str)) {
// base type, null|undefined etc.
type = 'base';
} else if (objectRE.test(str)) {
// simple property
type = 'prop';
}
}
fragments.push(last = lastEl = {
expr: str,
type,
});
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.