142 lines
3.6 KiB
JavaScript
142 lines
3.6 KiB
JavaScript
import D from 'debug';
|
|
|
|
import {fastApply} from '@avocado/core';
|
|
import * as MathExt from '@avocado/math';
|
|
|
|
import * as Flow from './flow';
|
|
import * as Timing from './timing';
|
|
import * as Utility from './utility';
|
|
|
|
const debug = D('@avocado:behavior:context');
|
|
|
|
export class Context {
|
|
|
|
constructor() {
|
|
this.map = new Map();
|
|
this.addDefaults();
|
|
}
|
|
|
|
add(key, value) {
|
|
this.map.set(key, value);
|
|
}
|
|
|
|
addDefaults() {
|
|
this.add('context', this);
|
|
this.add('Flow', Flow);
|
|
this.add('Math', MathExt);
|
|
this.add('Timing', Timing);
|
|
this.add('Utility', Utility);
|
|
}
|
|
|
|
clear() {
|
|
this.map.clear();
|
|
this.addDefaults();
|
|
}
|
|
|
|
destroy() {
|
|
this.map.clear();
|
|
}
|
|
|
|
static renderSteps(steps) {
|
|
return steps.reduce((rendered, step) => {
|
|
switch (step.type) {
|
|
case 'key':
|
|
if (rendered) {
|
|
rendered += '.';
|
|
}
|
|
rendered += step.key;
|
|
break;
|
|
case 'invoke':
|
|
rendered += `(${step.args.length > 0 ? '...' : ''})`;
|
|
break;
|
|
}
|
|
return rendered;
|
|
}, '');
|
|
}
|
|
|
|
static renderStepsUntilNow(steps, step) {
|
|
const stepsUntilNow = steps.slice(0, steps.indexOf(step));
|
|
return this.renderSteps(stepsUntilNow);
|
|
}
|
|
|
|
takeStep(value, fn) {
|
|
if (value instanceof Promise) {
|
|
return value.then((value) => {
|
|
return fn(value);
|
|
});
|
|
}
|
|
else {
|
|
return fn(value);
|
|
}
|
|
}
|
|
|
|
traverse(traversal) {
|
|
const {steps, value} = traversal;
|
|
return this.traverseAndDo(steps, (node, previousNode, step, index) => {
|
|
const isLastStep = index === steps.length - 2;
|
|
// Traverse if we're not at the final step with a value.
|
|
if (!isLastStep || !value) {
|
|
return this.traverseOneStep(steps, previousNode, node, step);
|
|
}
|
|
// Try to set the value.
|
|
switch (step.type) {
|
|
case 'key':
|
|
return node[step.key] = value.get(this);
|
|
case 'invoke':
|
|
const rendered = this.constructor.renderStepsUntilNow(steps, step);
|
|
debug(`invalid assignment to function "${rendered}"`);
|
|
return;
|
|
}
|
|
});
|
|
}
|
|
|
|
traverseAndDo(steps, fn) {
|
|
const [first, ...rest] = steps;
|
|
if ('key' !== first.type) {
|
|
throw new TypeError(`First step in a traversal must be type "key"`);
|
|
}
|
|
let previousNode = null;
|
|
return rest.reduce((node, step, index) => {
|
|
return this.takeStep(node, (node) => {
|
|
const result = fn(node, previousNode, step, index);
|
|
previousNode = node;
|
|
return result;
|
|
});
|
|
}, this.map.get(first.key));
|
|
}
|
|
|
|
traverseOneStep(steps, previousNode, node, step) {
|
|
if ('undefined' === typeof node) {
|
|
const rendered = this.constructor.renderStepsUntilNow(steps, step);
|
|
debug(`"${rendered}" is traversed through but undefined`);
|
|
return;
|
|
}
|
|
switch (step.type) {
|
|
case 'key':
|
|
return node[step.key];
|
|
case 'invoke':
|
|
const args = step.args.map((arg) => arg.get(this));
|
|
// Pass the context itself as the last arg.
|
|
args.push(this);
|
|
// Any arg promises will be resolved; the arg values will be passed
|
|
// transparently to the invocation.
|
|
let hasPromise = false;
|
|
for (let i = 0; i < args.length; i++) {
|
|
if (args[i] instanceof Promise) {
|
|
hasPromise = true;
|
|
break;
|
|
}
|
|
}
|
|
if (hasPromise) {
|
|
return Promise.all(args).then((args) => {
|
|
return fastApply(previousNode, node, args);
|
|
});
|
|
}
|
|
else {
|
|
return fastApply(previousNode, node, args);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|