Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
if (loaderErr) { return deferred.reject(loaderErr); }
if (!this._schemaRegistry.isRegistered(ref)) { this.register(schema, ref); }
deferred.resolve(schema);
};
// now request the missing refs that have not been requested yet
for (var index = 0, len = missing.length; index !== len; ++index) {
var ref = missing[index];
var deferred = when.defer();
this._refsRequested[SchemaRegistry._normalizeId(ref)] = deferred.promise;
this.loader(ref, onLoaded.bind(this, ref, deferred));
}
// wait for all of them
var self = this;
keys.all(this._refsRequested).then(
function() {
// all promises fulfilled
if (missing.length) {
// We loaded some schemas. We need to recurse to load
// additional schemas that were referenced by the schemas we
// just loaded.
self._loadMissingRefs(depth - 1, callback);
} else {
// We didn’t load any more schemas ourselves; we were just
// waiting for any loader promises to be fulfilled.
callback();
}
},
callback // one or more promises rejected
);
}
// Here, we check to see if the user has provided a single-view template,
// and if so, add its path to spike's ignores. This is because templates
// render separately with special variables through this plugin and
// shouldn't be processed as normal views by spike.
const tpl = this.opts[k].template
if (tpl && Object.keys(tpl).length) {
spikeOpts.ignore.push(path.join(compiler.options.context, tpl.path))
}
}
// Here's where the magic happens. First we use the when/keys utility to go
// through our "tasks" object and resolve all the promises. More info here:
// https://github.com/cujojs/when/blob/master/docs/api.md#whenkeys-all
keys.all(tasks)
// Then we go through each of they keys again, applying the user-provided
// transform function to each one, if it exists.
.then((tasks) => keys.map(tasks, transformData.bind(this)))
// After this, we add the fully resolved and transformed data to the
// addDataTo object, so it can be made available in views.
.tap(mergeIntoLocals.bind(this))
// Then we save the locals on a class property for templates to use. We will
// need this in a later webpack hook when we're writing templates.
.then((locals) => { this._locals = locals })
// And finally, tell webpack we're done with our business here
.done(() => { done() }, done)
}
return nodeFn.call(fs.readdir, dir).then(function (contents) {
contents.sort().forEach(function(fn) {
var stats = fs.lstatSync(dir+"/"+fn);
if (stats.isDirectory()) {
dirCount += 1;
dirs[fn] = listFiles(dir+"/"+fn)
} else {
files.push(fn.split(".")[0]);
}
})
var result = {};
if (dirCount > 0) { result.d = keys.all(dirs); }
if (files.length > 0) { result.f = when.resolve(files); }
return keys.all(result);
})
}
return nodeFn.call(fs.readdir, dir).then(function (contents) {
contents.sort().forEach(function(fn) {
var stats = fs.lstatSync(dir+"/"+fn);
if (stats.isDirectory()) {
dirCount += 1;
dirs[fn] = listFiles(dir+"/"+fn)
} else {
files.push(fn.split(".")[0]);
}
})
var result = {};
if (dirCount > 0) { result.d = keys.all(dirs); }
if (files.length > 0) { result.f = when.resolve(files); }
return keys.all(result);
})
}
export default (_token, routerState, _context) => {
token = _token;
context = _context || {};
return all(routerState.routes.filter((route) => {
return route.handler.load;
}).reduce(function fillPromises(promises, route) {
context.displayName = route.handler.displayName;
context.token = token;
promises[route.handler.displayName] = route.handler.load(context);
return handleChildren(promises, route.handler.children);
}, {}));
};
var fetchAllData = (routes, params) => {
var promises = routes
.filter(route => route.handler.fetchData)
.reduce((promises, route) => {
promises[route.name] = route.handler.fetchData(params);
return promises;
}, {});
return ResolveAllPromises(promises);
};
var fetchData = module.exports = (token, routerState) => {
var { params, query } = routerState;
return all(routerState.routes.filter((route) => {
return route.handler.fetchData;
}).reduce((promises, route) => {
promises[route.name] = route.handler.fetchData(token, params, query);
return promises;
}, {}));
};
return when.all(transition.routes.map((route) => {
if (route.RouteHandler.fetchData) {
return keys.all(route.RouteHandler.fetchData(transition.params, transition))
}
}))
})
var datas = when.all(transition.nextRoutes.map(function (route) {
if (route.RouteHandler.fetchData) {
return keys.all(route.RouteHandler.fetchData(transition.params, transition));
}
}));
return datas;
export default (state) => {
return all(state.routes.filter((route) => {
return route.handler.fetchData;
}).reduce((promises, route) => {
promises[route.name] = route.handler.fetchData(state);
return promises;
}, {}));
};