@woosh/meep-engine 2.43.39 → 2.43.42

package/core/binary/BitSet.js

@@ -86,7 +86,6 @@ function BitSet() {
     this.__data_uint32 = new Uint32Array(this.__capacity >> 5);
 
     /**
-     *
      * @type {number}
      */
     this.__shrinkFactor = SHRINK_FACTOR;
@@ -201,7 +200,7 @@ BitSet.prototype.__setLength = function (new_length) {
  * @returns {int} Index of previous set bit, or -1 if no set bit found
  */
 BitSet.prototype.previousSetBit = function (fromIndex) {
-    assert.ok(fromIndex >= 0, `fromIndex must be greater or equal to 0, instead was ${fromIndex}`);
+    assert.isNonNegativeInteger(fromIndex, `fromIndex`);
 
     const index = min2(fromIndex, this.__length - 1);
 
@@ -354,21 +353,6 @@ BitSet.prototype.nextClearBit = function (fromIndex) {
     return set_length;
 };
 
-/**
- * Slow method for scanning through bitset, used for debugging
- * @param {BitSet} set
- * @returns {number}
- */
-function scanToFirstClearBit(set) {
-    for (let i = 0; i <= set.size(); i++) {
-        if (set.get(i) === false) {
-            return i;
-        }
-    }
-
-    return -1;
-}
-
 /**
  *
  * @param {int} bitIndex
@@ -443,7 +427,9 @@ BitSet.prototype.setRange = function (startIndex, endIndex) {
  * @param {number} endIndex clear up to here, excluding this position
  */
 BitSet.prototype.clearRange = function (startIndex, endIndex) {
-    //TODO this can be done more efficiently
+    assert.greaterThanOrEqual(startIndex, 0, "invalid start index");
+    assert.greaterThanOrEqual(endIndex, 0, "invalid end index");
+
     for (let i = startIndex; i < endIndex; i++) {
         this.set(i, false);
     }

package/core/color/Color.js

@@ -5,7 +5,7 @@ import { min2 } from "../math/min2.js";
 import { max2 } from "../math/max2.js";
 import { min3 } from "../math/min3.js";
 import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
 import { rgb2hsv } from "./rgb2hsv.js";
 import { rgb2uint24 } from "./rgb2uint24.js";
 import { clamp01 } from "../math/clamp01.js";

package/core/geom/ConicRay.js

@@ -1,7 +1,7 @@
 import { assert } from "../assert.js";
 import Vector3 from "./Vector3.js";
 import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
 import { epsilonEquals } from "../math/epsilonEquals.js";
 import { EPSILON } from "../math/EPSILON.js";
 

package/core/geom/Quaternion.js

@@ -11,7 +11,7 @@ import { lerp } from "../math/lerp.js";
 import Vector3 from "./Vector3.js";
 import { v3_dot } from "./v3_dot.js";
 import { min2 } from "../math/min2.js";
-import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
 import { epsilonEquals } from "../math/epsilonEquals.js";
 import { EPSILON } from "../math/EPSILON.js";
 

package/core/geom/Vector1.js

@@ -6,7 +6,7 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { clamp } from "../math/clamp.js";
-import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
 
 
 class Vector1 extends Number {

package/core/geom/Vector3.js

@@ -13,7 +13,7 @@ import { v3_length } from "./v3_length.js";
 import { v3_angle_between } from "./v3_angle_between.js";
 import { v3_lerp } from "./v3_lerp.js";
 import { v3_slerp } from "./v3_slerp.js";
-import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
 import { epsilonEquals } from "../math/epsilonEquals.js";
 import { EPSILON } from "../math/EPSILON.js";
 

package/core/geom/Vector4.js

@@ -6,7 +6,7 @@ import { assert } from "../assert.js";
 import { Signal } from "../events/signal/Signal.js";
 import { lerp } from "../math/lerp.js";
 import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
 
 /**
  *

package/core/math/hash/computeHashFloatArray.js

@@ -1,4 +1,4 @@
-import { computeHashFloat } from "./computeHashFloat.js";
+import { computeHashFloat } from "../../primitives/numbers/computeHashFloat.js";
 
 /**
  *

package/core/math/hash/computeObjectHash.js

@@ -1,5 +1,5 @@
 import { computeStringHash } from "../../primitives/strings/computeStringHash.js";
-import { computeHashFloat } from "./computeHashFloat.js";
+import { computeHashFloat } from "../../primitives/numbers/computeHashFloat.js";
 
 /**
  * Recursively computes object hash

package/core/math/interval/NumericInterval.js

@@ -7,7 +7,7 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { inverseLerp } from "../inverseLerp.js";
-import { computeHashFloat } from "../hash/computeHashFloat.js";
+import { computeHashFloat } from "../../primitives/numbers/computeHashFloat.js";
 
 export class NumericInterval {
     /**

package/core/model/BoundedValue.js

@@ -5,7 +5,7 @@
 
 import Signal from "../events/signal/Signal.js";
 import { inverseLerp } from "../math/inverseLerp.js";
-import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
 
 /**
  *

package/core/model/node-graph/Connection.js

@@ -3,13 +3,26 @@ import { noop } from "../../function/Functions.js";
 import { objectKeyByValue } from "../object/objectKeyByValue.js";
 import { PortDirection } from "./node/PortDirection.js";
 
+/**
+ *
+ * @type {number}
+ */
+let id_counter = 0;
+
 export class Connection {
     constructor() {
+        /**
+         * @readonly
+         * @type {number}
+         */
+        this.id = id_counter++;
+
         /**
          *
          * @type {NodeInstancePortReference}
          */
         this.source = null;
+
         /**
          *
          * @type {NodeInstancePortReference}
@@ -65,8 +78,8 @@ export class Connection {
      * @param {NodeInstancePortReference} endpoint
      */
     setSource(endpoint) {
-        assert.notEqual(endpoint, undefined, 'endpoint is undefined');
-        assert.notEqual(endpoint, null, 'endpoint is null');
+        assert.defined(endpoint, 'endpoint');
+        assert.notNull(endpoint, 'endpoint');
 
         this.source = endpoint;
     }
@@ -76,8 +89,8 @@ export class Connection {
      * @param {NodeInstancePortReference} endpoint
      */
     setTarget(endpoint) {
-        assert.notEqual(endpoint, undefined, 'endpoint is undefined');
-        assert.notEqual(endpoint, null, 'endpoint is null');
+        assert.defined(endpoint, 'endpoint');
+        assert.notNull(endpoint, 'endpoint');
 
         this.target = endpoint;
     }
@@ -88,9 +101,37 @@ export class Connection {
      * @returns {boolean}
      */
     isAttachedToNode(id) {
-        assert.typeOf(id, 'number', 'id');
-        assert.ok(Number.isInteger(id), `id must be an integer, instead was '${id}'`);
+        assert.isNumber(id, 'id');
+        assert.isInteger(id, 'id');
 
         return this.source.instance.id === id || this.target.instance.id === id;
     }
+
+    /**
+     *
+     * @param {Connection} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.target === other.target
+            && this.source === other.source
+            ;
+    }
+
+    hash() {
+        const source_hash = this.source !== null ? this.source.id : 0;
+        const target_hash = this.target !== null ? this.target.id : 0;
+
+        // shuffle bits a bit to get better spread
+        return ((source_hash << 16) | (source_hash >>> 16))
+            ^ (target_hash)
+            ;
+    }
 }
+
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Connection.prototype.isConnection = true;

package/core/model/node-graph/Connection.spec.js

@@ -0,0 +1,21 @@
+import { Connection } from "./Connection.js";
+
+test("stable hash", () => {
+    const a = new Connection();
+    const b = new Connection();
+
+    expect(a.hash()).toEqual(b.hash());
+});
+
+test("equality of fresh instances", () => {
+    const a = new Connection();
+    const b = new Connection();
+
+    expect(a.equals(b)).toBe(true);
+});
+
+test("equality on self", () => {
+    const thing = new Connection();
+
+    expect(thing.equals(thing)).toBe(true);
+});

package/core/model/node-graph/DataType.js

@@ -1,3 +1,5 @@
+import { assert } from "../../assert.js";
+
 export class DataType {
     constructor() {
         /**
@@ -14,7 +16,15 @@ export class DataType {
     }
 
     toString() {
-        return `${this.id}:'${this.name}'`;
+        return `{DataType: id=${this.id}, name='${this.name}' }`;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        return this.id;
     }
 
     /**
@@ -25,18 +35,31 @@ export class DataType {
     equals(other) {
         return this.id === other.id && this.name === other.name;
     }
-}
 
-/**
- *
- * @param {number} id
- * @param {string} name
- */
-DataType.from = function (id, name) {
-    const r = new DataType();
+    toJSON() {
+        return { ...this };
+    }
 
-    r.id = id;
-    r.name = name;
+    fromJSON({ id, name }) {
+        assert.isNonNegativeInteger(id, 'id');
+        assert.isString(name, 'name');
 
-    return r;
-};
+        this.id = id;
+        this.name = name;
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @param {string} name
+     * @returns {DataType}
+     */
+    static from(id, name) {
+        const r = new DataType();
+
+        r.id = id;
+        r.name = name;
+
+        return r;
+    }
+}

package/core/model/node-graph/DataType.spec.js

@@ -0,0 +1,28 @@
+import { DataType } from "./DataType.js";
+
+test('to/from json', () => {
+    const a = DataType.from(7, 'kitty');
+
+    const b = new DataType();
+
+    b.fromJSON(a.toJSON());
+
+    expect(b.id).toBe(a.id);
+    expect(b.name).toBe(a.name);
+
+});
+
+test('equals', () => {
+    const a = DataType.from(7, 'kitty');
+    const b = DataType.from(7, 'kitty');
+    const c = DataType.from(7, 'fluffy');
+    const d = DataType.from(9, 'kitty');
+
+
+    expect(a.equals(b)).toBe(true);
+
+    expect(a.equals(c)).toBe(false);
+    expect(a.equals(d)).toBe(false);
+
+    expect(c.equals(d)).toBe(false);
+});

package/core/model/node-graph/NodeGraph.js

@@ -43,7 +43,7 @@ export class NodeGraph {
 
     /**
      *
-     * @param {function(NodeInstance)} visitor
+     * @param {function(NodeInstance):*} visitor
      * @param [thisArg]
      */
     traverseNodes(visitor, thisArg) {
@@ -52,7 +52,7 @@ export class NodeGraph {
 
     /**
      *
-     * @param {function(Connection)} visitor
+     * @param {function(Connection):*} visitor
      * @param [thisArg]
      */
     traverseConnections(visitor, thisArg) {
@@ -62,34 +62,61 @@ export class NodeGraph {
     /**
      *
      * @param {number} id
-     * @returns {NodeInstance}
+     * @returns {NodeInstance|undefined}
      */
     getNode(id) {
-        return this.nodes.find(node => node.id === id);
+        const nodes = this.nodes;
+        const n = nodes.length;
+
+        for (let i = 0; i < n; i++) {
+            const node = nodes[i];
+
+            if (node.id === id) {
+                return node;
+            }
+        }
+
+        // node not found, return undefined
+        return undefined;
     }
 
     /**
      *
      * @param {number} id
-     * @returns {Connection}
+     * @returns {Connection|undefined}
      */
     getConnection(id) {
-        return this.connections.find(connection => connection.id === id);
+        const connections = this.connections;
+        const n = connections.length;
+
+        for (let i = 0; i < n; i++) {
+            const connection = connections[i];
+
+            if (connection.id === id) {
+                return connection;
+            }
+        }
+
+        // nothing found, undefined will be returned
+        return undefined;
     }
 
     /**
      *
      * @param {number} node_id
      * @param {number} port_id
-     * @returns {NodeInstancePortReference}
+     * @returns {NodeInstancePortReference|undefined}
      */
     getConnectionEndpoint(node_id, port_id) {
 
         const nodeInstance = this.getNode(node_id);
 
-        const endpoint = nodeInstance.getEndpoint(port_id);
+        if (nodeInstance === undefined) {
+            // no node
+            return undefined;
+        }
 
-        return endpoint;
+        return nodeInstance.getEndpoint(port_id);
     }
 
     /**
@@ -123,7 +150,7 @@ export class NodeGraph {
 
         const id_obtained = this.__idpNodes.getSpecific(node.id);
 
-        if (!id_obtained) {
+        if (id_obtained === false) {
             throw new Error(`Node with id '${node.id}' already exists`);
         }
 
@@ -195,13 +222,13 @@ export class NodeGraph {
         //get endpoints
         const sourceEndpoint = sourceNodeInstance.getEndpoint(sourcePort);
 
-        if (sourceEndpoint === null) {
+        if (sourceEndpoint === undefined) {
             throw new Error(`Source port '${sourcePort}' not found`);
         }
 
         const targetEndpoint = targetNodeInstance.getEndpoint(targetPort);
 
-        if (targetEndpoint === null) {
+        if (targetEndpoint === undefined) {
             throw new Error(`Target port '${targetPort}' not found`);
         }
 
@@ -241,6 +268,7 @@ export class NodeGraph {
      *
      * @param {number} id
      * @param {number[]} result IDs of attached connections
+     * @returns {number} number of found connections
      */
     getConnectionsAttachedToNode(id, result) {
         let count = 0;
@@ -262,3 +290,9 @@ export class NodeGraph {
         return count;
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+NodeGraph.prototype.isNodeGraph = true;

package/core/model/node-graph/node/NodeDescription.js

@@ -1,5 +1,4 @@
 import { assert } from "../../../assert.js";
-import { BitSet } from "../../../binary/BitSet.js";
 import { NodeParameterDataType } from "./parameter/NodeParameterDataType.js";
 import { NodeParameterDescription } from "./parameter/NodeParameterDescription.js";
 import { Port } from "./Port.js";
@@ -11,17 +10,22 @@ import { Port } from "./Port.js";
  * @returns {number}
  */
 function pickNewSetId(things) {
-    const ids = new BitSet();
 
-    things.forEach((v, id) => ids.set(id, true));
 
-    const id = ids.nextClearBit(0);
+    const n = things.length;
+
+    let r = n;
+
+    for (let i = 0; i < n; i++) {
+
+        if (things[i] === undefined) {
+            r = i;
+            break;
+        }
 
-    if (id === -1) {
-        return 0;
-    } else {
-        return id;
     }
+
+    return r;
 }
 
 export class NodeDescription {
@@ -61,22 +65,22 @@ export class NodeDescription {
     createParameter(name, type, defaultValue) {
 
         assert.typeOf(name, 'string', 'name');
-        assert.ok(Object.values(NodeParameterDataType).includes(type), `Unknown type '${type}'`);
+        assert.enum(type, NodeParameterDataType, 'type');
 
+        let _default = defaultValue;
 
         //if default value is not given, pick one
-        if (defaultValue === undefined) {
+        if (_default === undefined) {
             switch (type) {
-                case NodeParameterDataType.Integer:
                 //intended fallthrough
-                case  NodeParameterDataType.Float:
-                    defaultValue = 0;
+                case  NodeParameterDataType.Number:
+                    _default = 0;
                     break;
                 case NodeParameterDataType.Boolean:
-                    defaultValue = false;
+                    _default = false;
                     break;
                 case NodeParameterDataType.String:
-                    defaultValue = "";
+                    _default = "";
                     break;
                 default:
                     throw new Error(`Unknown data type '${type}'`);
@@ -90,7 +94,7 @@ export class NodeDescription {
 
         pd.name = name;
         pd.type = type;
-        pd.defaultValue = defaultValue;
+        pd.defaultValue = _default;
         pd.id = id;
 
         assert.ok(pd.validate(console.error), 'parameter is not valid');
@@ -185,3 +189,9 @@ export class NodeDescription {
         return this.ports
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+NodeDescription.prototype.isNodeDescription = true;

package/core/model/node-graph/node/NodeDescription.spec.js

@@ -0,0 +1,14 @@
+import { NodeDescription } from "./NodeDescription.js";
+import { DataType } from "../DataType.js";
+import { PortDirection } from "./PortDirection.js";
+
+const DUMMY_TYPE = DataType.from(0, 'dummy');
+
+test('ports are assigned unique IDs', () => {
+    const node = new NodeDescription();
+
+    const id_a = node.createPort(DUMMY_TYPE, 'a', PortDirection.Unspecified);
+    const id_b = node.createPort(DUMMY_TYPE, 'b', PortDirection.Unspecified);
+
+    expect(id_a).not.toEqual(id_b);
+});

package/core/model/node-graph/node/NodeInstance.js

@@ -4,13 +4,19 @@ import { NodeInstancePortReference } from "./NodeInstancePortReference.js";
 import { PortDirection } from "./PortDirection.js";
 import { isArrayEqual } from "../../../collection/array/isArrayEqual.js";
 
+/**
+ *
+ * @type {number}
+ */
+let id_counter = 0;
+
 export class NodeInstance {
     constructor() {
         /**
          *
          * @type {number}
          */
-        this.id = 0;
+        this.id = id_counter++;
 
         /**
          *
@@ -148,8 +154,8 @@ export class NodeInstance {
 
     /**
      *
-     * @param {number} port Port Id
-     * @returns {ConnectionEndpoint|null}
+     * @param {number} port Port ID
+     * @returns {NodeInstancePortReference|undefined}
      */
     getEndpoint(port) {
         const endpoints = this.endpoints;
@@ -161,7 +167,7 @@ export class NodeInstance {
         }
 
         //not found
-        return null;
+        return undefined;
     }
 
     hash() {

package/core/model/node-graph/node/NodeInstancePortReference.js

@@ -1,12 +1,24 @@
 import { assert } from "../../../assert.js";
 import { computeHashIntegerArray } from "../../../collection/array/computeHashIntegerArray.js";
 
+/**
+ *
+ * @type {number}
+ */
+let id_counter = 0;
+
 /**
  * Reference for a port of a node instance
  */
 export class NodeInstancePortReference {
 
     constructor() {
+        /**
+         * @readonly
+         * @type {number}
+         */
+        this.id = id_counter++;
+
         /**
          *
          * @type {NodeInstance}
@@ -75,3 +87,9 @@ export class NodeInstancePortReference {
             ;
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+NodeInstancePortReference.prototype.isNodeInstancePortReference = true;