@woosh/meep-engine 2.56.1 → 2.58.0

package/src/core/binary/serde/JsonSerializer.js

@@ -1,113 +0,0 @@
-import LineBuilder from "../../codegen/LineBuilder.js";
-import SchemeRegistry from "../../model/scheme/SchemeRegistry.js";
-
-function JsonSerializer(registry = new SchemeRegistry()) {
-    this.registry = registry;
-    this.serializers = {};
-}
-
-/**
- *
- * @param value
- * @param {Type} type
- * @param {Map} visitedObjects
- * @private
- */
-JsonSerializer.prototype.__serialize = function (value, type, visitedObjects) {
-    const existing = visitedObjects.get(value);
-    if (existing !== undefined) {
-        //cycle detected
-        return existing;
-    }
-
-    const serializer = this.getSerializer(typeName);
-
-    const result = serializer(value);
-
-    visitedObjects.put(value, result);
-
-    return result;
-};
-
-JsonSerializer.prototype.serialize = function (value) {
-    const type = value.constructor.@schema;
-
-    return this.__serialize(value, type, new Map());
-};
-
-JsonSerializer.prototype.addSerializer = function (name, serializer) {
-    this.serializers[name] = serializer;
-};
-
-/**
- *
- * @param {String} typeName
- * @returns {function}
- */
-JsonSerializer.prototype.getSerializer = function (typeName) {
-    let serializer = this.serializers[typeName];
-
-    if (serializer === undefined) {
-        const schema = this.registry.get(typeName);
-        serializer = this.buildSerializer(schema);
-        this.addSerializer(typeName, serializer);
-    }
-
-    return serializer;
-};
-
-/**
- *
- * @param {Type} type
- */
-JsonSerializer.prototype.buildSerializer = function (type) {
-
-    const fields = type.fields;
-
-    const fieldSerializers = [];
-    const fieldCount = fields.length;
-
-    const serializerNames = [];
-
-    for (let i = 0; i < fieldCount; i++) {
-        const field = fields[i];
-
-        const fieldType = field.type;
-
-        serializerNames[i] = "$" + field.name;
-
-        fieldSerializers[i] = this.getSerializer(fieldType.name);
-    }
-
-    const lb = new LineBuilder();
-
-    lb.add("return function(value){")
-        .indent()
-        .add("return {")
-        .indent();
-
-    for (let i = 0; i < fieldCount; i++) {
-        const field = fields[i];
-
-        const serializerName = serializerNames[i];
-
-        const lastLine = i + 1 >= fieldCount;
-
-        const accessorSnippet = "value." + field.name + (field.observed ? ".get()" : "");
-        const serializedValueSnippet = serializerName + "(" + accessorSnippet + ")";
-
-        lb.add(field.name + " : " + serializedValueSnippet + (lastLine ? "" : ","));
-    }
-
-    lb.dedent()
-        .add("};")
-        .dedent()
-        .add("};");
-
-
-    const builder = new Function(serializerNames, lb.build());
-
-    return builder(fieldSerializers);
-};
-
-export default JsonSerializer;

package/src/core/color/rgb2hsv.js

@@ -1,47 +0,0 @@
-/**
- *
- * @param {number} r 0 to 255
- * @param {number} g 0 to 255
- * @param {number} b 0 to 255
- * @returns {{h: number, s: number, v: number}}
- */
-export function rgb2hsv(r, g, b) {
-
-    r /= 255;
-    g /= 255;
-    b /= 255;
-
-
-    const max = Math.max(r, g, b);
-    const min = Math.min(r, g, b);
-
-    var h, s, v = max;
-
-    var d = max - min;
-
-    s = max === 0 ? 0 : d / max;
-
-    if (max === min) {
-        h = 0; // achromatic
-    } else {
-        switch (max) {
-            case r:
-                h = (g - b) / d + (g < b ? 6 : 0);
-                break;
-            case g:
-                h = (b - r) / d + 2;
-                break;
-            case b:
-                h = (r - g) / d + 4;
-                break;
-        }
-
-        h /= 6;
-    }
-
-    return {
-        h,
-        s,
-        v
-    };
-}

package/src/core/color/rgb_to_YCbCr_uint24.js

@@ -1,16 +0,0 @@
-import { rgb2uint24 } from "./rgb2uint24.js";
-
-export function rgb_to_YCbCr_uint24(r, g, b) {
-    const Y = 0.299 * r + 0.587 * g + 0.114 * b;
-    const Cb = -0.169 * r - 0.331 * g + 0.499 * b + 128;
-    const Cr = 0.499 * g - 0.418 * g - 0.0813 * b + 128;
-    /**
-     *
-     * @see https://en.wikipedia.org/wiki/YUV
-     * @param {number} r
-     * @param {number} g
-     * @param {number} b
-     * @returns {number}
-     */
-    return rgb2uint24(Y,Cb,Cr);
-}

package/src/core/fsm/StateMachine.js

@@ -1,440 +0,0 @@
-/**
- * Created by Alex on 01/09/2014.
- */
-
-
-import { assert } from "../assert.js";
-import { dispatchViaProxy } from "../events/signal/Signal.js";
-import Graph from "../graph/Graph.js";
-import Future from "../process/Future.js";
-import Transition from "./Transition.js";
-
-/**
- *
- * @enum {number}
- */
-export const StateMachineEventType = {
-    StateEntered: 0,
-    StateExited: 1
-};
-
-/**
- * @template {T}
- * @constructor
- */
-function StateMachine() {
-    this.graph = new Graph();
-    this.state = null;
-    this.isLocked = false;
-
-    /**
-     *
-     * @type {Map<any, Array>}
-     */
-    this.stateProcessorMap = new Map();
-
-    this.stateEntryHandlers = new Map();
-    this.stateExitHandlers = new Map();
-
-    /**
-     * Used for debug mainly
-     * @type {Array<T>}
-     * @private
-     */
-    this.__history = [];
-}
-
-/**
- *
- * @param {T} source
- * @param {T} target
- * @param {Transition~action} action
- * @param {Transition~condition} [condition]
- * @returns {Transition}
- */
-StateMachine.prototype.createTransition = function (source, target, action, condition) {
-    const transition = new Transition(source, target, action, condition);
-    this.addTransition(transition);
-    return transition;
-};
-
-/**
- *
- * @param {T} state
- * @param {StateMachineEventType} type
- * @param {function} handler
- */
-StateMachine.prototype.addEventHandler = function (state, type, handler) {
-    let eventMap;
-
-    if (type === StateMachineEventType.StateEntered) {
-        eventMap = this.stateEntryHandlers;
-    } else if (type === StateMachineEventType.StateExited) {
-        eventMap = this.stateExitHandlers;
-    } else {
-        throw new Error(`Unknown event type '${type}'`);
-    }
-
-    const handlers = eventMap.get(state);
-    if (handlers === undefined) {
-        eventMap.set(state, [handler]);
-    } else {
-        handlers.push(handler);
-    }
-};
-
-/**
- *
- * @param {T} state
- * @param {StateMachineEventType} type
- * @param {function} handler
- */
-StateMachine.prototype.removeEventHandler = function (state, type, handler) {
-    let eventMap;
-
-    if (type === StateMachineEventType.StateEntered) {
-        eventMap = this.stateEntryHandlers;
-    } else if (type === StateMachineEventType.StateExited) {
-        eventMap = this.stateExitHandlers;
-    } else {
-        throw new Error(`Unknown event type '${type}'`);
-    }
-
-
-    const handlers = eventMap.get(state);
-    if (handlers === undefined) {
-        //no handlers, clearly handler was not registered
-        console.warn('No listeners registered');
-    } else {
-        const i = handlers.indexOf(handler);
-
-        if (i === -1) {
-            console.warn('Listener not found');
-            return;
-        }
-
-        handlers.splice(i, 1);
-    }
-};
-
-/**
- *
- * @param {Transition} t
- */
-StateMachine.prototype.addTransition = function (t) {
-    this.graph.addEdge(t);
-};
-
-/**
- *
- * @param {T} s
- */
-StateMachine.prototype.addState = function (s) {
-    this.graph.addNode(s);
-};
-
-/**
- *
- * @param {T} state
- * @param {function():Promise<T>} processor
- */
-StateMachine.prototype.addStateProcessor = function (state, processor) {
-    assert.notEqual(state, undefined, 'state was undefined');
-    assert.equal(typeof processor, 'function', `processor must be a function, instead was '${typeof processor}'`)
-
-    if (!this.graph.containsNode(state)) {
-        throw new Error(`State ${state} is not found in the graph`);
-    }
-
-    const processors = this.stateProcessorMap.get(state);
-
-    if (processors === undefined) {
-        this.stateProcessorMap.set(state, [processor]);
-    } else {
-        processors.push(state);
-    }
-};
-
-/**
- *
- * @param {Array.<*>} states
- */
-StateMachine.prototype.addAllStates = function (states) {
-    let i = 0;
-    const l = states.length;
-    for (; i < l; i++) {
-        this.addState(states[i]);
-    }
-};
-
-
-/**
- *
- * @param {T} s
- */
-StateMachine.prototype.setState = function (s) {
-    // console.warn('setState', s);
-
-    const oldState = this.state;
-
-    this.state = s;
-
-    const exitHandlers = this.stateExitHandlers.get(oldState);
-
-    if (exitHandlers !== undefined) {
-        dispatchViaProxy(exitHandlers, [oldState, s]);
-    }
-
-    const entryHandlers = this.stateEntryHandlers.get(s);
-
-    if (entryHandlers !== undefined) {
-        dispatchViaProxy(entryHandlers, [s, oldState]);
-    }
-
-    this.__history.push(s);
-};
-
-/**
- *
- * @returns {T}
- */
-StateMachine.prototype.getState = function () {
-    return this.state;
-};
-
-/**
- * Causes the state machine to enter a given state
- * @param {T} s
- */
-StateMachine.prototype.enterState = function (s) {
-    if (this.isLocked) {
-        throw new Error(`State Machine is locked, unable to set state from '${this.state}' to '${s}'`);
-    }
-
-    this.setState(s);
-
-    //try all state processors in turn until all have been tried and failed or one has succeeded
-    const processors = this.stateProcessorMap.get(s);
-
-    const self = this;
-
-
-    function executeStateProcessors(sm, processors) {
-
-        let i = 0;
-        const numProcessors = processors.length;
-
-        function lockSM() {
-            sm.isLocked = true;
-        }
-
-        function unlockSM() {
-            sm.isLocked = false;
-        }
-
-        function executeNext() {
-
-            const processor = processors[i];
-
-            i++;
-
-            let pendingProcess;
-
-            try {
-                pendingProcess = processor();
-            } catch (e) {
-                console.warn('Exception in state processor function, treating as failure and continuing.', e);
-                handleTaskFailure();
-                return;
-            }
-
-            assert.ok((pendingProcess instanceof Promise || pendingProcess instanceof Future), `processor must return a promise or a future, instead returned something else (${pendingProcess})`);
-
-            self.__pendingProcess = pendingProcess;
-
-            pendingProcess.then(handleTaskCompletion, handleTaskFailure);
-        }
-
-        function handleTaskCompletion(newState) {
-            if (!self.graph.containsNode(newState)) {
-                //produced state is not contained in the graph, treat as failure
-                console.error(`Processor produced state that is not present in the graph, treating as failure.`);
-
-                handleTaskFailure();
-            } else {
-                let foundTraversableEdge = false;
-
-                self.graph.findTraversableEdges(s, newState, function (edge) {
-                    foundTraversableEdge = true;
-                });
-
-                if (!foundTraversableEdge) {
-                    console.error(`Processor requests an illegal move from state '${s}' to '${newState}', no valid transition exists. Treating as failure`);
-                    handleTaskFailure();
-                } else {
-                    //unlock
-                    unlockSM();
-                    //transition
-                    self.enterState(newState);
-                }
-            }
-        }
-
-        function handleTaskFailure() {
-            if (i === numProcessors) {
-                //we're done
-                unlockSM();
-            } else {
-                executeNext();
-            }
-        }
-
-        lockSM();
-
-        executeNext();
-    }
-
-    if (processors === undefined || processors.length === 0) {
-        //no state processors
-    } else {
-        executeStateProcessors(this, processors);
-    }
-};
-
-StateMachine.prototype.canTransitionTo = function (nextState) {
-    const source = this.state;
-    let result = false;
-    this.traverseValidTransitions(function (node, edge) {
-        if (node === nextState && edge.condition(source, node)) {
-            result = true;
-            //stop traversal
-            return false;
-        }
-    });
-    return result;
-};
-
-/**
- *
- * @param {Graph~visitor} visitor
- */
-StateMachine.prototype.traverseValidTransitions = function (visitor) {
-    const source = this.state;
-    this.graph.traverseSuccessors(source, function (node, edge) {
-        if (edge.condition(source, node)) {
-            return visitor(node, edge);
-        }
-    });
-};
-
-
-/**
- *
- * @param {Transition} transition
- * @param {T} targetState
- * @returns {Promise}
- */
-StateMachine.prototype.transitionOn = function (transition, targetState) {
-    assert.equal(transition.second, targetState, `transition destination is not equal to targetState`);
-
-    const sm = this;
-    return new Promise(function (resolve, reject) {
-        if (transition === null) {
-            //no transition was found
-            reject("no transition found");
-        }
-        //check lock on state machine
-        if (sm.isLocked) {
-            reject("state machine is locked, can not execute transition");
-        }
-
-        const stateFrom = sm.state;
-
-        //lock state machine
-        sm.isLocked = true;
-
-        let promise;
-
-        try {
-            promise = transition.action(stateFrom, targetState);
-        } catch (e) {
-            //failed to perform transition
-            promise = Promise.reject(e);
-        }
-
-        function handleTransitionSuccess() {
-            sm.isLocked = false;
-            sm.enterState(targetState);
-            resolve();
-        }
-
-        function handleTransitionFailed(e) {
-            sm.isLocked = false;
-            reject(e);
-        }
-
-        promise.then(handleTransitionSuccess, handleTransitionFailed);
-    });
-};
-
-/**
- *
- * @param {T} nextState Adjacent state
- * @returns {Promise}
- */
-StateMachine.prototype.transitionTo = function (nextState) {
-    const sm = this;
-    const state = sm.state;
-
-    return new Promise(function (resolve, reject) {
-        if (state === nextState) {
-            //already there
-            resolve();
-        }
-        let transition = null;
-
-        sm.traverseValidTransitions(function (target, t) {
-            if (t.second !== nextState) {
-                //wrong target
-                return;
-            }
-
-            transition = t;
-            //stop traversal
-            return false;
-        });
-
-        sm.transitionOn(transition, nextState).then(resolve, reject);
-    });
-};
-
-/**
- *
- * @param {*} targetState
- * @returns {Promise}
- */
-StateMachine.prototype.navigateTo = function (targetState) {
-    //find path
-    const graph = this.graph;
-
-    const start = this.state;
-
-    const path = graph.findPath(start, targetState);
-
-    if (path === null) {
-        return Promise.reject(`no path found from ${start} to '${targetState}'`);
-    }
-
-    let result = Promise.resolve();
-
-    let i = 1;
-    const l = path.length;
-    for (; i < l; i++) {
-        const next = path[i];
-        result = result.then(this.transitionTo(next));
-    }
-
-    return result;
-};
-
-export { StateMachine };

package/src/core/fsm/Transition.js

@@ -1,65 +0,0 @@
-/**
- * Created by Alex on 24/03/2016.
- */
-
-
-import { Edge, EdgeDirectionType } from "../graph/Edge.js";
-
-const TransitionExecutionMode = {
-    Synchronous: 0,
-    Asynchronous: 1
-};
-
-/**
- * @callback Transition~action
- * @param {*} source Node of transition origin
- * @param {*} target Node of destination
- * @returns {Promise} Promise is evaluated to perform transition, and transition is not finished until promise is resolved
- */
-
-/**
- * @callback Transition~condition
- * @param {*} source
- * @param {*} target
- * @returns {boolean} judgement on validity of transition from source to target
- */
-
-/**
- *
- * @param {*} source
- * @param {*} target
- * @returns {boolean}
- */
-function fTrue(source, target) {
-    return true;
-}
-
-class Transition extends Edge {
-    /**
-     *
-     * @param {*} source
-     * @param {*} target
-     * @param {Transition~action} action
-     * @param {Transition~condition} condition
-     * @constructor
-     * @extends Edge
-     */
-    constructor(source, target, action, condition) {
-        super(source, target);
-        //make it a directed edge
-        this.direction = EdgeDirectionType.Forward;
-
-        this.action = action;
-        this.condition = (typeof condition === "function") ? condition : fTrue;
-    }
-
-    /**
-     * @inheritDoc Transition~action
-     */
-    static EmptyAction(source, target) {
-        return Promise.resolve();
-    }
-}
-
-
-export default Transition;

package/src/core/geom/Bezier.js

@@ -1,24 +0,0 @@
-/**
- *
- * @param {Vector2} result
- * @param {number} p0x
- * @param {number} p0y
- * @param {number} p1x
- * @param {number} p1y
- * @param {number} p2x
- * @param {number} p2y
- * @param {number} t
- */
-export function computeQuadraticBezier2D(result, p0x, p0y, p1x, p1y, p2x, p2y, t) {
-    const minus = 1 - t;
-    const minus2 = minus * minus;
-
-    const f = minus * 2 * t;
-    const t2 = t * t;
-
-
-    const x0 = p0x * minus2 + p1x * f + p2x * t2;
-    const y0 = p0y * minus2 + p1y * f + p2y * t2;
-
-    result.set(x0, y0);
-}

package/src/core/geom/Bezier.spec.js

@@ -1,16 +0,0 @@
-import { computeQuadraticBezier2D } from "./Bezier.js";
-import Vector2 from "./Vector2.js";
-
-test("computeQuadraticBezier2D hits knots",()=>{
-    const v2 = new Vector2();
-
-    computeQuadraticBezier2D(v2,1,3,5,7,11,13,0);
-
-    expect(v2.x).toBeCloseTo(1);
-    expect(v2.y).toBeCloseTo(3);
-
-    computeQuadraticBezier2D(v2,1,3,5,7,11,13,1);
-
-    expect(v2.x).toBeCloseTo(11);
-    expect(v2.y).toBeCloseTo(13);
-});