_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q44200
|
train
|
function (p, dist, bearing) {
var a = bearing * Math.PI / 180;
return this.offset(p,
Math.sin(a) * dist,
Math.cos(a) * dist);
}
|
javascript
|
{
"resource": ""
}
|
|
q44201
|
train
|
function (line, dist) {
var sum = 0;
if (dist <= 0) return line[0];
for (var i = 0; i < line.length - 1; i++) {
var p0 = line[i];
var p1 = line[i + 1];
var d = this.distance(p0, p1);
sum += d;
if (sum > dist) return interpolate(p0, p1, (dist - (sum - d)) / d);
}
return line[line.length - 1];
}
|
javascript
|
{
"resource": ""
}
|
|
q44202
|
train
|
function (start, stop, line) {
var sum = 0;
var slice = [];
for (var i = 0; i < line.length - 1; i++) {
var p0 = line[i];
var p1 = line[i + 1];
var d = this.distance(p0, p1);
sum += d;
if (sum > start && slice.length === 0) {
slice.push(interpolate(p0, p1, (start - (sum - d)) / d));
}
if (sum >= stop) {
slice.push(interpolate(p0, p1, (stop - (sum - d)) / d));
return slice;
}
if (sum > start) slice.push(p1);
}
return slice;
}
|
javascript
|
{
"resource": ""
}
|
|
q44203
|
train
|
function (bbox, buffer) {
var v = buffer / this.ky;
var h = buffer / this.kx;
return [
bbox[0] - h,
bbox[1] - v,
bbox[2] + h,
bbox[3] + v
];
}
|
javascript
|
{
"resource": ""
}
|
|
q44204
|
train
|
function (p, bbox) {
return p[0] >= bbox[0] &&
p[0] <= bbox[2] &&
p[1] >= bbox[1] &&
p[1] <= bbox[3];
}
|
javascript
|
{
"resource": ""
}
|
|
q44205
|
train
|
function (aggregate) {
if (!aggregate || !(aggregate instanceof Aggregate)) {
throw new Error('Passed object should be an Aggregate');
}
aggregate.defineContext(this);
if (this.aggregates.indexOf(aggregate) < 0) {
this.aggregates.push(aggregate);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44206
|
train
|
function (name) {
if (!name || !_.isString(name)) {
throw new Error('Please pass in an aggregate name!');
}
return _.find(this.aggregates, function (agg) {
return agg.name === name;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44207
|
train
|
function (name, version) {
if (!name || !_.isString(name)) {
throw new Error('Please pass in a command name!');
}
for (var a in this.aggregates) {
var aggr = this.aggregates[a];
var cmd = aggr.getCommand(name, version);
if (cmd) {
return aggr;
}
}
for (var a in this.aggregates) {
var aggr = this.aggregates[a];
var cmdHndl = aggr.getCommandHandler(name, version);
if (cmdHndl && cmdHndl !== aggr.defaultCommandHandler) {
return aggr;
}
}
debug('no matching aggregate found for command ' + name);
return null;
}
|
javascript
|
{
"resource": ""
}
|
|
q44208
|
train
|
function (streamInfo, rev) {
this.set('_revision', rev);
streamInfo.context = streamInfo.context || '_general';
this.get('_revisions')[streamInfo.context + '_' + streamInfo.aggregate + '_' + streamInfo.aggregateId] = rev;
}
|
javascript
|
{
"resource": ""
}
|
|
q44209
|
train
|
function (streamInfo) {
if (!streamInfo) {
return this.get('_revision');
}
streamInfo.context = streamInfo.context || '_general';
return this.get('_revisions')[streamInfo.context + '_' + streamInfo.aggregate + '_' + streamInfo.aggregateId] || 0;
}
|
javascript
|
{
"resource": ""
}
|
|
q44210
|
train
|
function (data) {
if (arguments.length === 2) {
dotty.put(this.attributes, arguments[0], arguments[1]);
} else if (_.isObject(data)) {
for (var m in data) {
dotty.put(this.attributes, m, data[m]);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44211
|
train
|
function (data) {
if (data instanceof AggregateModel) {
this.attributes = data.toJSON();
} else {
this.attributes = _.cloneDeep(data || {});
}
this.attributes.id = this.id;
this.attributes._destroyed = this.attributes._destroyed || false;
this.attributes._revision = this.attributes._revision || 0;
}
|
javascript
|
{
"resource": ""
}
|
|
q44212
|
construct
|
train
|
function construct(klass, args) {
function T() {
klass.apply(this, arguments[0]);
}
T.prototype = klass.prototype;
return new T(args);
}
|
javascript
|
{
"resource": ""
}
|
q44213
|
randomBetween
|
train
|
function randomBetween(min, max) {
return Math.round(min + Math.random() * (max - min));
}
|
javascript
|
{
"resource": ""
}
|
q44214
|
train
|
function (aggregate) {
if (!aggregate || !_.isObject(aggregate)) {
var err = new Error('Please pass a valid aggregate!');
debug(err);
throw err;
}
this.aggregate = aggregate;
}
|
javascript
|
{
"resource": ""
}
|
|
q44215
|
train
|
function (eventStore) {
if (!eventStore || !_.isObject(eventStore)) {
var err = new Error('Please pass a valid eventStore!');
debug(err);
throw err;
}
this.eventStore = eventStore;
}
|
javascript
|
{
"resource": ""
}
|
|
q44216
|
train
|
function (aggregateLock) {
if (!aggregateLock || !_.isObject(aggregateLock)) {
var err = new Error('Please pass a valid aggregateLock!');
debug(err);
throw err;
}
this.aggregateLock = aggregateLock;
}
|
javascript
|
{
"resource": ""
}
|
|
q44217
|
train
|
function (aggId, cmd, clb) {
if (!aggId || !_.isString(aggId)) {
var err = new Error('Please pass a valid aggregate id!');
debug(err);
throw err;
}
if (!cmd || !_.isObject(cmd)) {
var err = new Error('Please pass a valid command!');
debug(err);
throw err;
}
if (!clb || !_.isFunction(clb)) {
var err = new Error('Please pass a valid callback!');
debug(err);
throw err;
}
this.queue[aggId] = this.queue[aggId] || [];
this.queue[aggId].push({ command: cmd, callback: clb })
}
|
javascript
|
{
"resource": ""
}
|
|
q44218
|
train
|
function (aggId) {
if (!aggId || !_.isString(aggId)) {
var err = new Error('Please pass a valid aggregate id!');
debug(err);
throw err;
}
if (this.queue[aggId] && this.queue[aggId].length > 0) {
var nextCmd = this.queue[aggId][0];
return nextCmd;
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
|
q44219
|
train
|
function (aggId, cmd) {
if (!aggId || !_.isString(aggId)) {
var err = new Error('Please pass a valid aggregate id!');
debug(err);
throw err;
}
_.remove(this.queue[aggId], function (c) {
return c.command === cmd;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44220
|
train
|
function (aggregateId, callback) {
if (!aggregateId || !_.isString(aggregateId)) {
var err = new Error('Please pass a valid aggregateId!');
debug(err);
throw err;
}
if (!callback || !_.isFunction(callback)) {
var err = new Error('Please pass a valid callback!');
debug(err);
throw err;
}
this.aggregateLock.reserve(this.id, aggregateId, callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q44221
|
train
|
function (aggregate, stream, callback) {
if (!aggregate || !_.isObject(aggregate)) {
var err = new Error('Please pass a valid aggregate!');
debug(err);
throw err;
}
if (!stream || !_.isObject(stream)) {
var err = new Error('Please pass a valid aggregate!');
debug(err);
throw err;
}
var hasAggregateName = !!this.definitions.command.aggregate;
var hasContextName = !!this.definitions.command.context;
var query = {
aggregateId: aggregate.id
};
if (hasAggregateName) {
query.aggregate = this.aggregate.name;
}
if (hasContextName) {
query.context = this.aggregate.context.name;
}
query.data = aggregate.toJSON();
query.revision = stream.lastRevision;
query.version = this.aggregate.version;
var self = this;
process.nextTick(function() {
var transformer = self.aggregate.committingSnapshotTransformers[self.aggregate.context.name + '.' + self.aggregate.name + '.' + self.aggregate.version] || function (sn, cb) { cb(null, sn); };
transformer(query.data, function (err, snapData) {
if (err) {
debug(err);
if (callback) callback(err);
return;
}
query.data = snapData;
debug('cerate new snapshot');
self.eventStore.createSnapshot(query, function (err) {
if (err) {
debug(err);
if (callback) callback(err);
return;
}
debug('snapshot created');
if (callback) callback(null);
});
});
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44222
|
train
|
function (aggregate, cmd) {
if (!aggregate || !_.isObject(aggregate)) {
var err = new Error('Please pass a valid aggregate!');
debug(err);
throw err;
}
if (!cmd || !_.isObject(cmd)) {
var err = new Error('Please pass a valid command!');
debug(err);
throw err;
}
var contextName, aggregateName, aggregateId;
if (!!this.definitions.command.context) {
contextName = dotty.get(cmd, this.definitions.command.context);
}
if (!!this.definitions.command.aggregate) {
aggregateName = dotty.get(cmd, this.definitions.command.aggregate);
}
if (!!this.definitions.command.aggregateId) {
aggregateId = dotty.get(cmd, this.definitions.command.aggregateId);
}
var streamInfo = {
context: contextName,
aggregate: aggregateName,
aggregateId: aggregateId
};
if (aggregate.isDestroyed()) {
return new AggregateDestroyedError('Aggregate has already been destroyed!', {
aggregateId: aggregate.id,
aggregateRevision: aggregate.getRevision(streamInfo)
});
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
|
q44223
|
train
|
function (aggregate, cmd) {
if (!aggregate || !_.isObject(aggregate)) {
var err = new Error('Please pass a valid aggregate!');
debug(err);
throw err;
}
if (!cmd || !_.isObject(cmd)) {
var err = new Error('Please pass a valid command!');
debug(err);
throw err;
}
var hasRevision = !!this.definitions.command.revision;
if (!hasRevision) {
return null;
}
var revisionInCommand = dotty.get(cmd, this.definitions.command.revision);
if (revisionInCommand === null || revisionInCommand === undefined) {
return null;
}
var contextName, aggregateName, aggregateId;
if (!!this.definitions.command.context) {
contextName = dotty.get(cmd, this.definitions.command.context);
}
if (!!this.definitions.command.aggregate) {
aggregateName = dotty.get(cmd, this.definitions.command.aggregate);
}
if (!!this.definitions.command.aggregateId) {
aggregateId = dotty.get(cmd, this.definitions.command.aggregateId);
}
var streamInfo = {
context: contextName,
aggregate: aggregateName,
aggregateId: aggregateId
};
if (revisionInCommand === aggregate.getRevision(streamInfo)) {
return null;
}
return new AggregateConcurrencyError('Actual revision in command is "' + revisionInCommand + '", but expected is "' + aggregate.getRevision(streamInfo) + '"!', {
aggregateId: aggregate.id,
aggregateRevision: aggregate.getRevision(streamInfo),
commandRevision: revisionInCommand
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44224
|
train
|
function (cmd, callback) {
if (!cmd || !_.isObject(cmd)) {
debug(err);
return callback(new Error('Please pass a valid command!'), null);
}
return this.aggregate.validateCommand(cmd, callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q44225
|
train
|
function (aggregate, cmd) {
if (!aggregate || !_.isObject(aggregate)) {
var err = new Error('Please pass a valid aggregate!');
debug(err);
throw err;
}
if (!cmd || !_.isObject(cmd)) {
var err = new Error('Please pass a valid command!');
debug(err);
throw err;
}
var reason = this.isAggregateDestroyed(aggregate, cmd);
if (reason) {
return reason;
}
if (this.aggregate.disablePersistence) return;
reason = this.isRevisionWrong(aggregate, cmd);
if (reason) {
return reason;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44226
|
train
|
function (aggregate, cmd, callback) {
if (!aggregate || !_.isObject(aggregate)) {
var err = new Error('Please pass a valid aggregate!');
debug(err);
throw err;
}
if (!cmd || !_.isObject(cmd)) {
var err = new Error('Please pass a valid command!');
debug(err);
throw err;
}
if (!callback || !_.isFunction(callback)) {
var err = new Error('Please pass a valid function!');
debug(err);
throw err;
}
this.aggregate.handle(aggregate, cmd, callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q44227
|
train
|
function (aggregateId, callback) {
if (!aggregateId || !_.isString(aggregateId)) {
var err = new Error('Please pass a valid aggregateId!');
debug(err);
throw err;
}
if (!callback || !_.isFunction(callback)) {
var err = new Error('Please pass a valid callback!');
debug(err);
throw err;
}
var self = this;
this.aggregateLock.getAll(aggregateId, function (err, workerIds) {
if (err) {
return callback(err);
}
if (workerIds.length === 1 && workerIds[0] === self.id) {
return callback(null);
}
var err = new ConcurrencyError('Aggregate is locked by an other command handler!');
debug(err);
callback(err);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44228
|
train
|
function (aggregateId, callback) {
if (!aggregateId || !_.isString(aggregateId)) {
var err = new Error('Please pass a valid aggregateId!');
debug(err);
throw err;
}
if (!callback || !_.isFunction(callback)) {
var err = new Error('Please pass a valid callback!');
debug(err);
throw err;
}
this.aggregateLock.resolve(aggregateId, callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q44229
|
train
|
function (aggregate, streams, clb) {
debug('handle command');
self.letHandleCommandByAggregate(aggregate, cmd, function (err) { // err is a business rule error
if (err) {
return clb(err);
}
clb(null, aggregate, streams);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44230
|
train
|
function (aggregate, streams, clb) {
if (hadNoAggregateId) return clb(null, aggregate, streams);
debug('check aggregate lock');
self.checkAggregateLock(concatenatedId, function (err) {
clb(err, aggregate, streams);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44231
|
train
|
function (cmd, callback) {
var getNewIdFn = this.eventStore.getNewId.bind(this.eventStore);
if (this.aggregate && this.aggregate.getNewAggregateId) {
getNewIdFn = this.aggregate.getNewAggregateId.bind(this.aggregate);
} else if (this.getNewAggregateIdFn) {
getNewIdFn = this.getNewAggregateIdFn.bind(this);
}
if (getNewIdFn.length === 2) {
return getNewIdFn(cmd, callback);
}
getNewIdFn(callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q44232
|
train
|
function (fn) {
if (!fn || !_.isFunction(fn)) {
var err = new Error('Please pass a valid function!');
debug(err);
throw err;
}
this.structureLoader = customLoader(fn);
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q44233
|
train
|
function (cmd, err) {
if (!cmd || !_.isObject(cmd)) {
var err = new Error('Please pass a valid command!');
debug(err);
throw err;
}
if (!err || !_.isObject(err)) {
var err = new Error('Please pass a valid error!');
debug(err);
throw err;
}
var evt = {};
if (!!this.definitions.command.meta && !!this.definitions.event.meta) {
dotty.put(evt, this.definitions.event.meta, dotty.get(cmd, this.definitions.command.meta));
}
dotty.put(evt, this.definitions.event.correlationId, dotty.get(cmd, this.definitions.command.id));
dotty.put(evt, this.definitions.event.name, this.options.commandRejectedEventName);
dotty.put(evt, this.definitions.event.id, dotty.get(cmd, this.definitions.command.id) + '_rejected');
dotty.put(evt, this.definitions.event.aggregateId, dotty.get(cmd, this.definitions.command.aggregateId));
if (!!this.definitions.command.aggregate && !!this.definitions.event.aggregate) {
dotty.put(evt, this.definitions.event.aggregate, dotty.get(cmd, this.definitions.command.aggregate));
}
if (!!this.definitions.command.context && !!this.definitions.event.context) {
dotty.put(evt, this.definitions.event.context, dotty.get(cmd, this.definitions.command.context));
}
if (err instanceof ValidationError || err instanceof BusinessRuleError ||
err instanceof AggregateDestroyedError || err instanceof AggregateConcurrencyError ||
err instanceof DuplicateCommandError) {
dotty.put(evt, this.definitions.event.payload, {
command: cmd,
reason: {
name: err.name,
message: err.message,
more: err.more
}
});
if (!!this.definitions.event.revision && dotty.get(evt, this.definitions.event.revision) === undefined && err.more && err.more.aggregateRevision > -1) {
dotty.put(evt, this.definitions.event.revision, err.more.aggregateRevision);
}
} else {
evt = null;
}
return evt;
}
|
javascript
|
{
"resource": ""
}
|
|
q44234
|
train
|
function (fn) {
if (!fn || !_.isFunction(fn) || fn.length !== 1) {
var err = new Error('Please pass a valid function!');
debug(err);
throw err;
}
this.validatorExtension = fn;
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q44235
|
train
|
function (callback) {
debug('prepare eventStore...');
self.eventStore.on('connect', function () {
self.emit('connect');
});
self.eventStore.on('disconnect', function () {
self.emit('disconnect');
});
self.eventStore.init(callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q44236
|
train
|
function (callback) {
debug('prepare aggregateLock...');
self.aggregateLock.on('connect', function () {
self.emit('connect');
});
self.aggregateLock.on('disconnect', function () {
self.emit('disconnect');
});
self.aggregateLock.connect(callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q44237
|
train
|
function (callback) {
if (!self.commandBumper) {
return callback(null);
}
debug('prepare commandBumper...');
self.commandBumper.on('connect', function () {
self.emit('connect');
});
self.commandBumper.on('disconnect', function () {
self.emit('disconnect');
});
self.commandBumper.connect(callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q44238
|
train
|
function (cmd, callback) {
if (!cmd || !_.isObject(cmd) || !dotty.exists(cmd, this.definitions.command.name)) {
var err = new Error('Please pass a valid command!');
debug(err);
if (callback) callback(err);
return;
}
var self = this;
process.nextTick(function () {
if (callback && callback.length > 2) {
self.commandDispatcher.dispatch(cmd, function (err, eventsToDispatch, aggregateData, meta) {
self.onDispatched(cmd, err, eventsToDispatch, aggregateData, meta, callback);
});
return;
}
self.commandDispatcher.dispatch(cmd, function (err, eventsToDispatch) {
self.onDispatched(cmd, err, eventsToDispatch, null, null, callback);
});
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44239
|
train
|
function (evt, aggregateModel) {
if (!this.evtFn) {
return;
}
if (!this.payload || this.payload === '') {
this.evtFn(evt, aggregateModel);
return;
}
var payload = dotty.get(evt, this.payload);
this.evtFn(payload, aggregateModel);
}
|
javascript
|
{
"resource": ""
}
|
|
q44240
|
getValidator
|
train
|
function getValidator (options, schema) {
options = options || {};
options.schemas = options.schemas || {};
options.formats = options.formats || {};
if (!schema || !_.isObject(schema)) {
var err = new Error('Please pass a valid schema!');
debug(err);
throw err;
}
var tv4 = tv4Module.freshApi();
_.each(options.schemas, function (v, k) {
tv4.addSchema(k, v);
});
tv4.addFormat(options.formats);
return function (data) {
var validation = tv4.validateMultiple(data, schema);
if (validation.missing.length > 0) {
var missingString = validation.missing[0];
for (var m = 1, lenM = validation.missing.length; m < lenM; m++) {
missingString += ', ' + validation.missing[m];
}
var err = new Error('Validation schema(s) "' + missingString + '" missing!');
debug(err);
return err;
}
if (!validation.valid) {
var errors = validation.errors;
var firstError = validation.errors[0];
if (firstError.message.indexOf('not match any schemas') >= 0 && firstError.subErrors && firstError.subErrors.length > 0) {
firstError = firstError.subErrors[0];
errors = firstError.subErrors;
}
return new ValidationError(firstError.dataPath + ' => ' + firstError.message, errors);
}
return null;
};
}
|
javascript
|
{
"resource": ""
}
|
q44241
|
train
|
function (cmd) {
if (!cmd || !_.isObject(cmd)) {
var err = new Error('Please pass a valid command!');
debug(err);
throw err;
}
var aggregateId = null;
if (dotty.exists(cmd, this.definition.aggregateId)) {
aggregateId = dotty.get(cmd, this.definition.aggregateId);
} else {
debug('no aggregateId found, seems to be for a new aggregate');
}
var name = dotty.get(cmd, this.definition.name);
var version = 0;
if (dotty.exists(cmd, this.definition.version)) {
version = dotty.get(cmd, this.definition.version);
} else {
debug('no version found, handling as version: 0');
}
var aggregate = null;
if (dotty.exists(cmd, this.definition.aggregate)) {
aggregate = dotty.get(cmd, this.definition.aggregate);
} else {
debug('no aggregate found, will lookup in all aggregates');
}
var context = null;
if (dotty.exists(cmd, this.definition.context)) {
context = dotty.get(cmd, this.definition.context);
} else {
debug('no aggregateName found, will lookup in all contexts');
}
return {
name: name,
aggregateId: aggregateId,
version: version,
aggregate: aggregate,
context: context
};
}
|
javascript
|
{
"resource": ""
}
|
|
q44242
|
train
|
function (cmd, callback) {
if (!cmd || !_.isObject(cmd)) {
var err = new Error('Please pass a valid command!');
debug(err);
throw err;
}
if (!callback || !_.isFunction(callback)) {
var err = new Error('Please pass a valid callback!');
debug(err);
throw err;
}
var target = this.getTargetInformation(cmd);
var commandHandler = this.tree.getCommandHandler(target);
// if (!commandHandler) {
// commandHandler = this.tree.getCommandHandlerByOldTarget(target);
// }
if (!commandHandler) {
var err = new Error('No command handler found for ' + target.name);
debug(err);
return callback(err);
}
if (!this.commandBumper) {
return commandHandler.handle(cmd, callback);
}
var key = target.context + target.aggregate + target.aggregateId + dotty.get(cmd, this.definition.id);
this.commandBumper.add(key, function (err, added) {
if (err) {
return callback(err);
}
if (!added) {
return callback(new DuplicateCommandError('Command already seen!'));
}
commandHandler.handle(cmd, callback);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44243
|
train
|
function (evt, callback) {
var self = this;
var callbacked = false;
function handleError (err) {
debug(err);
callbacked = true;
callback(err);
}
try {
if (this.transformFn.length === 2) {
this.transformFn(_.cloneDeep(evt), function (err, newEvt) {
if (err) return handleError(err);
callbacked = true;
callback(null, newEvt);
});
} else {
var newEvt = this.transformFn(_.cloneDeep(evt));
callback(null, newEvt);
}
} catch (err) {
if (!callbacked) {
return handleError(err);
}
throw err;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44244
|
train
|
function (context) {
if (!context || !_.isObject(context)) {
var err = new Error('Please inject a valid context object!');
debug(err);
throw err;
}
this.context = context;
for (var r in this.snapshotConversionRegistrations) {
var reg = this.snapshotConversionRegistrations[r];
var meta = reg.meta;
var fn = reg.fn;
meta.context = meta.context || this.context.name;
meta.aggregate = meta.aggregate || this.name;
this.snapshotConversions[meta.context + '.' + meta.aggregate + '.' + meta.version] = fn;
}
for (var r in this.loadingSnapshotTransformerRegistrations) {
var reg = this.loadingSnapshotTransformerRegistrations[r];
var meta = reg.meta;
var fn = reg.fn;
meta.context = meta.context || this.context.name;
meta.aggregate = meta.aggregate || this.name;
this.loadingSnapshotTransformers[meta.context + '.' + meta.aggregate + '.' + meta.version] = fn;
}
for (var r in this.committingSnapshotTransformerRegistrations) {
var reg = this.committingSnapshotTransformerRegistrations[r];
var meta = reg.meta;
var fn = reg.fn;
meta.context = meta.context || this.context.name;
meta.aggregate = meta.aggregate || this.name;
this.committingSnapshotTransformers[meta.context + '.' + meta.aggregate + '.' + meta.version] = fn;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44245
|
train
|
function (command) {
if (!command || !_.isObject(command)) {
var err = new Error('Please inject a valid command object!');
debug(err);
throw err;
}
if (!command.payload && command.payload !== '') {
command.payload = this.defaultCommandPayload;
}
command.defineAggregate(this);
if (this.commands.indexOf(command) < 0) {
this.commands.push(command);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44246
|
train
|
function (event) {
if (!event || !_.isObject(event)) {
var err = new Error('Please inject a valid event object!');
debug(err);
throw err;
}
if (!event.payload && event.payload !== '') {
event.payload = this.defaultEventPayload;
}
if (this.events.indexOf(event) < 0) {
this.events.push(event);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44247
|
train
|
function (businessRule) {
if (!businessRule || !_.isObject(businessRule)) {
var err = new Error('Please inject a valid businessRule object!');
debug(err);
throw err;
}
if (this.businessRules.indexOf(businessRule) < 0) {
businessRule.defineAggregate(this);
this.businessRules.push(businessRule);
this.businessRules = _.sortBy(this.businessRules, function(br) {
return br.priority;
});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44248
|
train
|
function (loadingEventTransformer) {
if (!loadingEventTransformer || !_.isObject(loadingEventTransformer)) {
var err = new Error('Please inject a valid loadingEventTransformer object!');
debug(err);
throw err;
}
if (this.loadingEventTransformers.indexOf(loadingEventTransformer) < 0) {
this.loadingEventTransformers.push(loadingEventTransformer);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44249
|
train
|
function (committingEventTransformer) {
if (!committingEventTransformer || !_.isObject(committingEventTransformer)) {
var err = new Error('Please inject a valid committingEventTransformer object!');
debug(err);
throw err;
}
if (this.committingEventTransformers.indexOf(committingEventTransformer) < 0) {
this.committingEventTransformers.push(committingEventTransformer);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44250
|
train
|
function (commandHandler) {
if (!commandHandler || !_.isObject(commandHandler) || !_.isFunction(commandHandler.useAggregate)) {
var err = new Error('Please inject a valid commandHandler object!');
debug(err);
throw err;
}
commandHandler.useAggregate(this);
if (this.commandHandlers.indexOf(commandHandler) < 0) {
this.commandHandlers.push(commandHandler);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44251
|
train
|
function (name) {
if (!name || !_.isString(name)) {
var err = new Error('Please pass a valid string as name!');
debug(err);
throw err;
}
return _.filter(this.commands, function (cmd) {
return cmd.name === name;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44252
|
train
|
function (name, version) {
if (!name || !_.isString(name)) {
var err = new Error('Please pass a valid string as name!');
debug(err);
throw err;
}
version = version || 0;
if (!_.isNumber(version)) {
var err = new Error('Please pass a valid number as version!');
debug(err);
throw err;
}
return _.find(this.commands, function (cmd) {
return cmd.name === name && cmd.version === version;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44253
|
train
|
function (name, version) {
if (!name || !_.isString(name)) {
var err = new Error('Please pass a valid string as name!');
debug(err);
throw err;
}
version = version || 0;
if (!_.isNumber(version)) {
var err = new Error('Please pass a valid number as version!');
debug(err);
throw err;
}
return _.find(this.events, function (evt) {
return evt.name === name && evt.version === version;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44254
|
train
|
function (name, version) {
if (!name || !_.isString(name)) {
var err = new Error('Please pass a valid string as name!');
debug(err);
throw err;
}
version = version || 0;
if (!_.isNumber(version)) {
var err = new Error('Please pass a valid number as version!');
debug(err);
throw err;
}
var handler = _.find(this.commandHandlers, function (cmdHnd) {
return cmdHnd.name === name && cmdHnd.version === version;
});
if (handler) {
return handler;
}
if (!this.getCommand(name, version)) {
return null;
}
return this.defaultCommandHandler;
}
|
javascript
|
{
"resource": ""
}
|
|
q44255
|
train
|
function (name, version) {
if (!name || !_.isString(name)) {
var err = new Error('Please pass a valid string as name!');
debug(err);
throw err;
}
version = version || 0;
if (!_.isNumber(version)) {
var err = new Error('Please pass a valid number as version!');
debug(err);
throw err;
}
var found = _.find(this.loadingEventTransformers, function (evt) {
return evt.name === name && evt.version === version;
});
if (found) return found;
return _.find(this.loadingEventTransformers, function (evt) {
return evt.name === name && (evt.version === null || evt.version === undefined);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44256
|
train
|
function (id) {
if (!id || !_.isString(id)) {
var err = new Error('Please pass a valid string as id!');
debug(err);
throw err;
}
return new AggregateModel(id, this.modelInitValues);
}
|
javascript
|
{
"resource": ""
}
|
|
q44257
|
train
|
function (cmd, callback) {
var cmdName = dotty.get(cmd, this.definitions.command.name);
var err;
if (!cmdName) {
err = new Error('command has no command name in ' + this.definitions.command.name);
debug(err);
return callback(err);
}
var version = 0;
if (!!this.definitions.command.version) {
version = dotty.get(cmd, this.definitions.command.version);
}
var command = this.getCommand(cmdName, version);
if (!command) {
err = new Error('Command "' + cmdName + '" not found!');
debug(err);
return callback(err);
}
if (command.validate.length >= 2) {
return command.validate(cmd, callback);
}
try {
callback(command.validate(cmd));
} catch (e) {
callback(e);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44258
|
train
|
function (cmd, callback) {
var cmdName = dotty.get(cmd, this.definitions.command.name);
if (!cmdName) {
var err = new Error('command has no command name in ' + this.definitions.command.name);
debug(err);
throw err;
}
var version = 0;
if (!!this.definitions.command.version) {
version = dotty.get(cmd, this.definitions.command.version);
}
var command = this.getCommand(cmdName, version);
if (!command) {
var err = new Error('Command "' + cmdName + '" not found!');
debug(err);
throw err;
}
command.checkPreLoadConditions(cmd, callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q44259
|
train
|
function (changed, previous, events, command, callback) {
async.eachSeries(this.getBusinessRules(), function (rule, callback) {
rule.check(changed, previous, events, command, callback);
}, callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q44260
|
train
|
function (aggregateModel, cmd, callback) {
var cmdName = dotty.get(cmd, this.definitions.command.name);
if (!cmdName) {
var err = new Error('command has no command name in ' + this.definitions.command.name);
debug(err);
return callback(err);
}
var version = 0;
if (!!this.definitions.command.version) {
version = dotty.get(cmd, this.definitions.command.version);
}
var command = this.getCommand(cmdName, version);
if (!command) {
var err = new Error('Command "' + cmdName + '" not found!');
debug(err);
return callback(err);
}
var self = this;
aggregateModel.set = function () {
throw new Error('You are not allowed to set a value in this step!');
};
var previousModel = new AggregateModel(aggregateModel.id, aggregateModel);
this.checkPreConditions(cmd, aggregateModel, function (err) {
if (err) {
return callback(err);
}
// attach apply function
aggregateModel.apply = applyHelper(self, aggregateModel, cmd);
debug('handle command');
command.handle(cmd, aggregateModel);
// remove apply function
delete aggregateModel.apply;
var uncommittedEvents = aggregateModel.getUncommittedEvents();
async.each(uncommittedEvents, function (evt, callback) {
var isEvtIdDefined = !!dotty.get(evt, self.definitions.event.id);
if (isEvtIdDefined) {
debug('event id already defined');
return callback(null);
}
// generate new id for event
debug('generate new id for event');
self.getNewId(function (err, id) {
if (err) {
return callback(err);
}
dotty.put(evt, self.definitions.event.id, id);
callback(null);
});
}, function (err) {
if (err) {
return callback(err);
}
// check business rules
debug('check business rules');
self.checkBusinessRules(aggregateModel, previousModel, uncommittedEvents, cmd, function (err) {
if (!err) {
return callback(null);
}
// clean up...
aggregateModel.reset(previousModel);
aggregateModel.clearUncommittedEvents();
callback(err);
});
});
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44261
|
train
|
function (events, aggregateModel, notSameOrigin) {
if (!events) {
return;
}
if (!_.isArray(events)) {
events = [events];
}
var self = this;
events.forEach(function (evt) {
var evtName = dotty.get(evt, self.definitions.event.name);
if (!evtName) {
var err = new Error('event has no event name in ' + self.definitions.event.name);
debug(err);
throw err;
}
var version = 0;
if (!!self.definitions.event.version) {
version = dotty.get(evt, self.definitions.event.version);
}
var event = self.getEvent(evtName, version);
if (!event) {
if (notSameOrigin) {
debug('You don\'t want to handle event "' + evtName + '" of other event stream');
return;
}
var err = new Error('Event "' + evtName + '" not found!');
debug(err);
throw err;
}
event.apply(evt, aggregateModel);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44262
|
train
|
function (aggregateModel, snapshot, events, loadingTime, stream, streams, notSameOrigin) {
var self = this;
var isSnapshotNeeded = false;
if (snapshot) {
// load snapshot
debug('load snapshot ' + snapshot.id + ' from history', _.pick(snapshot, ['context', 'aggregate', 'version']), {
context: this.context.name,
aggregate: this.name,
version: this.version
});
if ((snapshot.context === this.context.name || !snapshot.context && this.context.name === '_general') &&
(snapshot.aggregate === this.name || !snapshot.aggregate) &&
snapshot.version === this.version) {
aggregateModel.set(snapshot.data);
} else {
if (!this.snapshotConversions[snapshot.context + '.' + snapshot.aggregate + '.' + snapshot.version]) {
var err = new Error('No snapshot conversion defined!');
debug(err);
throw err;
}
debug('convert snapshot from history');
this.snapshotConversions[snapshot.context + '.' + snapshot.aggregate + '.' + snapshot.version](snapshot.data, aggregateModel);
isSnapshotNeeded = true;
}
aggregateModel.setRevision({
context: stream.context,
aggregate: stream.aggregate,
aggregateId: stream.aggregateId
}, snapshot.revision + 1);
}
if (events && events.length > 0) {
// load events
debug('load events from history');
var maxRevision = _.reduce(events, function (res, evt) {
var rev = dotty.get(evt, self.definitions.event.revision);
if (rev > res) {
return rev;
}
return res;
}, 0);
if (!this.skipHistory || (this.skipHistory && this.applyLastEvent)) {
this.apply(events, aggregateModel, notSameOrigin);
}
aggregateModel.setRevision({
context: stream.context,
aggregate: stream.aggregate,
aggregateId: stream.aggregateId
}, maxRevision);
if (!isSnapshotNeeded) {
if (this.isSnapshotNeeded.length > 2) {
isSnapshotNeeded = this.isSnapshotNeeded(loadingTime, events, aggregateModel.toJSON(), streams);
} else {
isSnapshotNeeded = this.isSnapshotNeeded(loadingTime, events);
}
}
}
return isSnapshotNeeded;
}
|
javascript
|
{
"resource": ""
}
|
|
q44263
|
train
|
function (meta, fn) {
if (!_.isObject(meta) || meta.version === undefined || meta.version === null || !_.isNumber(meta.version)) {
throw new Error('Please pass in a version');
}
if (!_.isFunction(fn)) {
throw new Error('Please pass in a function');
}
var wrappedFn;
if (fn.length === 1) {
wrappedFn = function (s, cb) {
try {
cb(null, fn(s));
} catch (err) {
cb(err);
}
};
} else {
wrappedFn = fn;
}
this.loadingSnapshotTransformerRegistrations.push({ meta: meta, fn: wrappedFn });
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q44264
|
train
|
function (loadingTime, events) {
var snapshotThreshold = 100;
if (this.options.snapshotThreshold) {
snapshotThreshold = this.options.snapshotThreshold;
}
if (this.options.snapshotThresholdMs) {
return loadingTime >= this.options.snapshotThresholdMs;
}
return events.length >= snapshotThreshold;
}
|
javascript
|
{
"resource": ""
}
|
|
q44265
|
train
|
function (snapshot) {
if (!this.snapshotIgnores[snapshot.version]) {
return false;
}
return this.snapshotIgnores[snapshot.version](snapshot.data);
}
|
javascript
|
{
"resource": ""
}
|
|
q44266
|
train
|
function (meta, fn) {
if (!_.isObject(meta) || meta.version === undefined || meta.version === null || !_.isNumber(meta.version)) {
throw new Error('Please pass in a version');
}
if (!_.isFunction(fn)) {
throw new Error('Please pass in a function');
}
this.snapshotConversionRegistrations.push({ meta: meta, fn: fn });
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q44267
|
train
|
function (meta, fn) {
if (!_.isObject(meta) || meta.version === undefined || meta.version === null || !_.isNumber(meta.version)) {
throw new Error('Please pass in a version');
}
if (!fn) {
this.snapshotIgnores[meta.version] = function () {
return true;
};
return this;
}
if (_.isBoolean(fn)) {
this.snapshotIgnores[meta.version] = function () {
return fn;
};
return this;
}
this.snapshotIgnores[meta.version] = fn;
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q44268
|
train
|
function (fn) {
if (fn.length === 0) throw new Error('Please define your function to accept the command!');
if (fn.length === 1) {
var orgFn = fn;
fn = function(cmd, callback) {
callback(null, orgFn(cmd));
};
}
this.getNewAggregateId = fn;
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q44269
|
train
|
function (preCond) {
if (!preCond || !_.isObject(preCond)) {
var err = new Error('Please inject a valid preCondition object!');
debug(err);
throw err;
}
if (!preCond.payload && preCond.payload !== '') {
preCond.payload = this.aggregate.defaultPreConditionPayload;
}
if (this.preConditions.indexOf(preCond) < 0) {
preCond.defineAggregate(this.aggregate);
this.preConditions.push(preCond);
this.preConditions = _.sortBy(this.preConditions, function(pc) {
return pc.priority;
});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44270
|
train
|
function (preLoadCond) {
if (!preLoadCond || !_.isObject(preLoadCond)) {
var err = new Error('Please inject a valid preCondition object!');
debug(err);
throw err;
}
if (!preLoadCond.payload) {
preLoadCond.payload = this.aggregate.defaultPreLoadConditionPayload;
}
if (this.preLoadConditions.indexOf(preLoadCond) < 0) {
preLoadCond.defineAggregate(this.aggregate);
this.preLoadConditions.push(preLoadCond);
this.preLoadConditions = _.sortBy(this.preLoadConditions, function(pc) {
return pc.priority;
});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44271
|
train
|
function (validator) {
if (!_.isFunction(validator)) {
var err = new Error('Please pass in a function');
debug(err);
throw err;
}
if (validator.length == 2) {
return this.validator = validator;
}
this.validator = function (data, callback) {
callback(validator(data));
};
return this.validator;
}
|
javascript
|
{
"resource": ""
}
|
|
q44272
|
train
|
function (cmd, callback) {
if (this.preLoadConditions.length === 0) {
debug('no pre-load-condition for ' + this.name);
return callback(null);
}
var self = this;
async.eachSeries(this.preLoadConditions, function (preLoadCondition, callback) {
if (preLoadCondition.version === undefined || preLoadCondition.version === null || preLoadCondition.version === self.version) {
return preLoadCondition.check(cmd, callback);
}
callback(null);
}, callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q44273
|
train
|
function (cmd, aggregateModel, callback) {
if (this.existing === true && aggregateModel.get('_revision') === 0) {
var err = new BusinessRuleError('This command only wants to be handled, if aggregate already existing!', {
type: 'AggregateNotExisting',
aggregateId: aggregateModel.id,
aggregateRevision: aggregateModel.get('_revision')
});
debug(err);
return callback(err);
}
if (this.existing === false && aggregateModel.get('_revision') !== 0) {
var err = new BusinessRuleError('This command only wants to be handled, if aggregate not existing!', {
type: 'AggregateAlreadyExisting',
aggregateId: aggregateModel.id,
aggregateRevision: aggregateModel.get('_revision')
});
debug(err);
return callback(err);
}
if (this.preConditions.length === 0) {
debug('no pre-condition for ' + this.name);
return callback(null);
}
var self = this;
async.eachSeries(this.preConditions, function (preCondition, callback) {
if (preCondition.version === undefined || preCondition.version === null || preCondition.version === self.version) {
return preCondition.check(cmd, aggregateModel, callback);
}
callback(null);
}, callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q44274
|
entitytag
|
train
|
function entitytag (entity) {
if (entity.length === 0) {
// fast-path empty
return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"'
}
// compute hash of entity
var hash = crypto
.createHash('sha1')
.update(entity, 'utf8')
.digest('base64')
.substring(0, 27)
// compute length of entity
var len = typeof entity === 'string'
? Buffer.byteLength(entity, 'utf8')
: entity.length
return '"' + len.toString(16) + '-' + hash + '"'
}
|
javascript
|
{
"resource": ""
}
|
q44275
|
etag
|
train
|
function etag (entity, options) {
if (entity == null) {
throw new TypeError('argument entity is required')
}
// support fs.Stats object
var isStats = isstats(entity)
var weak = options && typeof options.weak === 'boolean'
? options.weak
: isStats
// validate argument
if (!isStats && typeof entity !== 'string' && !Buffer.isBuffer(entity)) {
throw new TypeError('argument entity must be string, Buffer, or fs.Stats')
}
// generate entity tag
var tag = isStats
? stattag(entity)
: entitytag(entity)
return weak
? 'W/' + tag
: tag
}
|
javascript
|
{
"resource": ""
}
|
q44276
|
isstats
|
train
|
function isstats (obj) {
// genuine fs.Stats
if (typeof Stats === 'function' && obj instanceof Stats) {
return true
}
// quack quack
return obj && typeof obj === 'object' &&
'ctime' in obj && toString.call(obj.ctime) === '[object Date]' &&
'mtime' in obj && toString.call(obj.mtime) === '[object Date]' &&
'ino' in obj && typeof obj.ino === 'number' &&
'size' in obj && typeof obj.size === 'number'
}
|
javascript
|
{
"resource": ""
}
|
q44277
|
stattag
|
train
|
function stattag (stat) {
var mtime = stat.mtime.getTime().toString(16)
var size = stat.size.toString(16)
return '"' + size + '-' + mtime + '"'
}
|
javascript
|
{
"resource": ""
}
|
q44278
|
defineKeywords
|
train
|
function defineKeywords(ajv, keyword) {
if (Array.isArray(keyword)) {
for (var i=0; i<keyword.length; i++)
get(keyword[i])(ajv);
return ajv;
}
if (keyword) {
get(keyword)(ajv);
return ajv;
}
for (keyword in KEYWORDS) get(keyword)(ajv);
return ajv;
}
|
javascript
|
{
"resource": ""
}
|
q44279
|
train
|
function(file) {
var deferred = $q.defer();
var reader = angular.extend(new FileReader(), {
onload: function(e) {
deferred.resolve(e.target.result);
if (!$rootScope.$$phase) $rootScope.$apply();
},
onerror: function(e) {
deferred.reject(e);
if (!$rootScope.$$phase) $rootScope.$apply();
},
onabort: function(e) {
deferred.reject(e);
if (!$rootScope.$$phase) $rootScope.$apply();
}
// onprogress: Gee, it'd be great to get some progress support from $q...
});
reader.readAsDataURL(file);
return angular.extend(deferred.promise, {
abort: function() { reader.abort(); }
});
}
|
javascript
|
{
"resource": ""
}
|
|
q44280
|
train
|
function(file) {
return {
name: file.name,
size: file.size,
lastModifiedDate: file.lastModifiedDate
};
}
|
javascript
|
{
"resource": ""
}
|
|
q44281
|
train
|
function(data) {
var extras = {};
if (data instanceof File) {
extras = this.meta(data);
data = data.toDataURL();
}
var parts = data.split(","), headers = parts[0].split(":"), body;
if (parts.length !== 2 || headers.length !== 2 || headers[0] !== "data") {
throw new Error("Invalid data URI.");
}
headers = headers[1].split(";");
body = (headers[1] === "base64") ? atob(parts[1]) : decodeURI(parts[1]);
var length = body.length, buffer = new ArrayBuffer(length), bytes = new Uint8Array(buffer);
for (var i = 0; i < length; i++) {
bytes[i] = body.charCodeAt(i);
}
return angular.extend(new Blob([bytes], { type: headers[0] }), extras);
}
|
javascript
|
{
"resource": ""
}
|
|
q44282
|
getLetterTime
|
train
|
function getLetterTime(timeString) {
var totalSeconds = 0;
var timeValues = {
's': 1,
'm': 1 * 60,
'h': 1 * 60 * 60,
'd': 1 * 60 * 60 * 24,
'w': 1 * 60 * 60 * 24 * 7,
};
var timePairs;
//expand to "1 h 30 m 20 s" and split
timeString = timeString.replace(/([smhdw])/g, ' $1 ').trim();
timePairs = timeString.split(' ');
for (var i = 0; i < timePairs.length; i += 2) {
totalSeconds += parseInt(timePairs[i], 10) *
timeValues[timePairs[i + 1] || 's'];
}
return totalSeconds;
}
|
javascript
|
{
"resource": ""
}
|
q44283
|
extractSass
|
train
|
function extractSass(files) {
// note: The way we're setting up webpack here seems a bit of a hack:
//
// Although the setup creates two bundles seperating the js and css as desired,
// it's also producing an extra styles.js file which we're throwing away/ignoring.
// The alternative, more supported way of things, is to leave the css inline
// within js and let the styles plugin add the css at runtime to the html page.
// At the moment keeping with the extracted css as:
// 1. more familar to angular 1 developers (?)
// 2. maintains backwards compatibility with the existing apps that expects
// the css to be delivered to the browser as a seperate file
const filename = env.prod ? `${libraryName}.min.css` : `${libraryName}.css`;
const extractor = new ExtractTextPlugin(filename);
let loader;
if (env.debug || env.prod) {
loader = 'css-loader?sourceMap!sass-loader?sourceMap';
} else {
loader = 'css-loader!sass-loader';
}
return {
entry: {
styles: files
},
module: {
rules: [
{
test: /\.scss$/,
loader: extractor.extract(loader),
include: files
}
]
},
plugins: [
extractor
]
};
}
|
javascript
|
{
"resource": ""
}
|
q44284
|
nextShallow
|
train
|
function nextShallow(stream) {
if (!stream.cursor) return false;
var cursor = stream.cursor;
cursor.x++;
var bbox = stream.bboxes[cursor.z];
if (cursor.x > bbox.maxX) {
cursor.x = bbox.minX;
cursor.y++;
}
if (cursor.y > bbox.maxY) {
stream.cursor = false;
return false;
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
q44285
|
nextDeep
|
train
|
function nextDeep(stream) {
if (!stream.cursor) return false;
var cursor = stream.cursor;
cursor.x++;
var bbox = stream.bboxes[cursor.z];
if (cursor.x > bbox.maxX) {
cursor.x = bbox.minX;
cursor.y++;
}
if (cursor.y > bbox.maxY) {
cursor.z++;
if (cursor.z > stream.maxzoom) {
stream.cursor = false;
return false;
}
bbox = stream.bboxes[cursor.z];
cursor.x = bbox.minX;
cursor.y = bbox.minY;
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
q44286
|
multiread
|
train
|
function multiread(stream, get) {
if (stream._multiread === undefined) {
stream._multiread = stream._multiread || [];
stream._multireading = stream._multireading || 0;
stream._multireadmax = stream._multireadmax || concurrency;
}
if (stream._multiread.length) {
push();
} else {
stream.once('_push', push);
}
while ((stream._multiread.length + stream._multireading) < stream._multireadmax) {
stream._multireading++;
if (!get(done)) break;
}
function done(item) {
stream._multireading--;
if (item === null && !stream._multireading) {
stream.emit('_push');
} else if (item) {
stream._multiread.push(item);
stream.emit('_push');
}
}
function push() {
if (stream._multiread.length) {
stream.push(stream._multiread.shift());
} else {
stream.push(null);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q44287
|
blockWrap
|
train
|
function blockWrap(contract, expression) {
return contract.slice(0, expression.start) + '{' + contract.slice(expression.start, expression.end) + '}' + contract.slice(expression.end);
}
|
javascript
|
{
"resource": ""
}
|
q44288
|
getModifierWhitespace
|
train
|
function getModifierWhitespace(contract, modifier){
const source = contract.slice(modifier.start, modifier.end);
const whitespace = source.match(crRegex) || [];
return whitespace.join('');
}
|
javascript
|
{
"resource": ""
}
|
q44289
|
createOrAppendInjectionPoint
|
train
|
function createOrAppendInjectionPoint(contract, key, value) {
if (contract.injectionPoints[key]) {
contract.injectionPoints[key].push(value);
} else {
contract.injectionPoints[key] = [value];
}
}
|
javascript
|
{
"resource": ""
}
|
q44290
|
timeout
|
train
|
async function timeout(promise, ms, errorMessage) {
let timer = null;
return Promise.race([
new Promise((resolve, reject) => {
timer = setTimeout(reject, ms, new BrowserError(errorMessage));
return timer;
}),
promise.then(value => {
clearTimeout(timer);
return value;
})
]);
}
|
javascript
|
{
"resource": ""
}
|
q44291
|
train
|
function(el, url) {
if (url) {
var rect = GetElementViewportRect(el);
if (rect) {
rects.push({'url': url,
'area': rect.area,
'rect': rect});
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44292
|
train
|
function() {
var timings = {};
var requests = win.performance.getEntriesByType("resource");
for (var i = 0; i < requests.length; i++)
timings[requests[i].name] = requests[i].responseEnd;
for (var j = 0; j < rects.length; j++) {
if (!('tm' in rects[j]))
rects[j].tm = timings[rects[j].url] !== undefined ? timings[rects[j].url] : 0;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44293
|
train
|
function() {
var paints = {'0':0};
var total = 0;
for (var i = 0; i < rects.length; i++) {
var tm = firstPaint;
if ('tm' in rects[i] && rects[i].tm > firstPaint)
tm = rects[i].tm;
if (paints[tm] === undefined)
paints[tm] = 0;
paints[tm] += rects[i].area;
total += rects[i].area;
}
// Add a paint area for the page background (count 10% of the pixels not
// covered by existing paint rects.
var pixels = Math.max(doc.documentElement.clientWidth, win.innerWidth || 0) *
Math.max(doc.documentElement.clientHeight, win.innerHeight || 0);
if (pixels > 0 ) {
pixels = Math.max(pixels - total, 0) * pageBackgroundWeight;
if (paints[firstPaint] === undefined)
paints[firstPaint] = 0;
paints[firstPaint] += pixels;
total += pixels;
}
// Calculate the visual progress
if (total) {
for (var time in paints) {
if (paints.hasOwnProperty(time)) {
progress.push({'tm': time, 'area': paints[time]});
}
}
progress.sort(function(a,b){return a.tm - b.tm;});
var accumulated = 0;
for (var j = 0; j < progress.length; j++) {
accumulated += progress[j].area;
progress[j].progress = accumulated / total;
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44294
|
train
|
function() {
if (progress.length) {
SpeedIndex = 0;
var lastTime = 0;
var lastProgress = 0;
for (var i = 0; i < progress.length; i++) {
var elapsed = progress[i].tm - lastTime;
if (elapsed > 0 && lastProgress < 1)
SpeedIndex += (1 - lastProgress) * elapsed;
lastTime = progress[i].tm;
lastProgress = progress[i].progress;
}
} else {
SpeedIndex = firstPaint;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q44295
|
toArray
|
train
|
function toArray(arrayLike) {
if (arrayLike === undefined || arrayLike === null) {
return [];
}
if (Array.isArray(arrayLike)) {
return arrayLike;
}
return [arrayLike];
}
|
javascript
|
{
"resource": ""
}
|
q44296
|
scriptsFromDirectory
|
train
|
async function scriptsFromDirectory(dirpath) {
const dir = (await readdir(dirpath))
.map(name => toFullPath(name, dirpath))
.filter(await filters.onlyFiles)
.filter(filters.onlyWithExtension('.js'));
const result = {};
for (const filepath of dir) {
const name = path.basename(filepath, '.js');
const script = await readFile(filepath, 'utf8');
result[name] = script;
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q44297
|
findAndParseScripts
|
train
|
async function findAndParseScripts(root, category) {
async function scriptsFromDirectory(dirpath) {
const dir = (await readdir(dirpath))
.map(name => toFullPath(name, dirpath))
.filter(await filters.onlyFiles)
.filter(filters.onlyWithExtension('.js'));
const result = {};
for (const filepath of dir) {
const name = path.basename(filepath, '.js');
const script = await readFile(filepath, 'utf8');
result[name] = script;
}
return result;
}
async function parseDirectory(dirPath) {
const categoryName = path.basename(dirPath);
return scriptsFromDirectory(dirPath).then(scripts => {
const categories = {};
categories[categoryName] = scripts;
return categories;
});
}
return stat(root).then(stats => {
if (stats.isFile()) {
return readFile(root, 'utf8').then(content => {
const name = path.basename(root, '.js');
let scripts = {};
scripts[name] = content;
let categories = {};
categories[category] = scripts;
return categories;
});
} else {
return parseDirectory(root);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q44298
|
toTimestamp
|
train
|
function toTimestamp(scale, input) {
var adapter = scale._adapter || defaultAdapter;
var options = scale.options.time;
var parser = options.parser;
var format = parser || options.format;
var value = input;
if (typeof parser === 'function') {
value = parser(value);
}
// Only parse if its not a timestamp already
if (typeof value !== 'number' && !(value instanceof Number) || !isFinite(value)) {
value = typeof format === 'string'
? adapter.parse(value, format)
: adapter.parse(value);
}
if (value !== null) {
return +value;
}
// Labels are in an incompatible format and no `parser` has been provided.
// The user might still use the deprecated `format` option for parsing.
if (!parser && typeof format === 'function') {
value = format(input);
// `format` could return something else than a timestamp, if so, parse it
if (typeof value !== 'number' && !(value instanceof Number) || !isFinite(value)) {
value = adapter.parse(value);
}
}
return value;
}
|
javascript
|
{
"resource": ""
}
|
q44299
|
update
|
train
|
function update(config) {
var me = this;
var preservation = config && config.preservation;
var tooltip, lastActive, tooltipLastActive, lastMouseEvent;
if (preservation) {
tooltip = me.tooltip;
lastActive = me.lastActive;
tooltipLastActive = tooltip._lastActive;
me._bufferedRender = true;
}
Chart.prototype.update.apply(me, arguments);
if (preservation) {
me._bufferedRender = false;
me._bufferedRequest = null;
me.lastActive = lastActive;
tooltip._lastActive = tooltipLastActive;
if (me.animating) {
// If the chart is animating, keep it until the duration is over
Chart.animationService.animations.forEach(function(animation) {
if (animation.chart === me) {
me.render({
duration: (animation.numSteps - animation.currentStep) * 16.66
});
}
});
} else {
// If the chart is not animating, make sure that all elements are at the final positions
me.data.datasets.forEach(function(dataset, datasetIndex) {
me.getDatasetMeta(datasetIndex).controller.transition(1);
});
}
if (tooltip._active) {
tooltip.update(true);
}
lastMouseEvent = me.streaming.lastMouseEvent;
if (lastMouseEvent) {
me.eventHandler(lastMouseEvent);
}
}
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.