@woosh/meep-engine 2.47.14 → 2.47.16

package/build/meep.module.js

@@ -117641,78 +117641,90 @@ class MaxRectanglesPacker {
  */
 
 /**
- *
- * @constructor
+ * Pool of unsigned integer IDs, useful when you don't want to just keep incrementing ID counter and want to re-use IDs after they are no longer needed
+ * Main use case is when your IDs are array indices, having compact IDs lets you use fixed size array even as objects are added and removed as you're able to reuse slots in an efficient manner
  */
-function IdPool() {
+class IdPool {
     /**
      * @private
      * @type {BitSet}
      */
-    this.bitSet = new BitSet();
-}
+    #set = new BitSet();
 
-/**
- *
- * @returns {number}
- */
-IdPool.prototype.get = function () {
-    const bitIndex = this.bitSet.nextClearBit(0);
+    /**
+     * Looks up next available ID without reserving it
+     * If you want to also reserve the ID - use {@link get} instead
+     * @returns {number}
+     */
+    peek() {
+        return this.#set.nextClearBit(0);
+    }
 
-    this.bitSet.set(bitIndex, true);
+    /**
+     *
+     * @returns {number}
+     */
+    get() {
+        const id = this.peek();
 
-    return bitIndex;
-};
+        this.#set.set(id, true);
 
-/**
- * Attempt to request a specific ID from the pool.
- * @param {number} id
- * @return {boolean} true if request succeeds, false otherwise
- */
-IdPool.prototype.getSpecific = function (id) {
-    if (this.isUsed(id)) {
-        return false;
+        return id;
     }
 
-    this.bitSet.set(id, true);
-    return true;
-};
+    /**
+     * Attempt to request a specific ID from the pool.
+     * @param {number} id
+     * @return {boolean} true if request succeeds, false otherwise
+     */
+    getSpecific(id) {
+        if (this.isUsed(id)) {
+            return false;
+        }
 
-/**
- *
- * @param {number} id
- * @returns {boolean}
- */
-IdPool.prototype.isUsed = function (id) {
-    return this.bitSet.get(id);
-};
+        this.#set.set(id, true);
+        return true;
+    }
 
-/**
- * Traverse all IDs currently in use
- * @param {function(id:number)} visitor
- */
-IdPool.prototype.traverseUsed = function (visitor) {
-    assert.equal(typeof visitor, 'function', `visitor must be a function, instead was '${typeof visitor}'`);
+    /**
+     *
+     * @param {number} id
+     * @returns {boolean}
+     */
+    isUsed(id) {
+        return this.#set.get(id);
+    }
 
-    const bitSet = this.bitSet;
+    /**
+     * Traverse all IDs currently in use
+     * @param {function(id:number)} visitor
+     */
+    traverseUsed(visitor) {
+        assert.isFunction(visitor, "visitor");
 
-    for (let i = bitSet.nextSetBit(0); i !== -1; i = bitSet.nextSetBit(i + 1)) {
-        visitor(i);
-    }
+        const set = this.#set;
 
-};
+        for (let i = set.nextSetBit(0); i !== -1; i = set.nextSetBit(i + 1)) {
+            visitor(i);
+        }
 
-/**
- *
- * @param {number} id
- */
-IdPool.prototype.release = function (id) {
-    this.bitSet.clear(id);
-};
+    }
 
-IdPool.prototype.reset = function () {
-    this.bitSet.reset();
-};
+    /**
+     *
+     * @param {number} id
+     */
+    release(id) {
+        this.#set.clear(id);
+    }
+
+    /**
+     * Release all used IDs
+     */
+    reset() {
+        this.#set.reset();
+    }
+}
 
 class AtlasPatch {
     constructor() {

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.47.14",
+  "version": "2.47.16",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/IdPool.js

@@ -7,77 +7,89 @@ import { assert } from "./assert.js";
 import { BitSet } from "./binary/BitSet.js";
 
 /**
- *
- * @constructor
+ * Pool of unsigned integer IDs, useful when you don't want to just keep incrementing ID counter and want to re-use IDs after they are no longer needed
+ * Main use case is when your IDs are array indices, having compact IDs lets you use fixed size array even as objects are added and removed as you're able to reuse slots in an efficient manner
  */
-function IdPool() {
+class IdPool {
     /**
      * @private
      * @type {BitSet}
      */
-    this.bitSet = new BitSet();
-}
+    #set = new BitSet();
 
-/**
- *
- * @returns {number}
- */
-IdPool.prototype.get = function () {
-    const bitIndex = this.bitSet.nextClearBit(0);
+    /**
+     * Looks up next available ID without reserving it
+     * If you want to also reserve the ID - use {@link get} instead
+     * @returns {number}
+     */
+    peek() {
+        return this.#set.nextClearBit(0);
+    }
 
-    this.bitSet.set(bitIndex, true);
+    /**
+     *
+     * @returns {number}
+     */
+    get() {
+        const id = this.peek();
 
-    return bitIndex;
-};
+        this.#set.set(id, true);
 
-/**
- * Attempt to request a specific ID from the pool.
- * @param {number} id
- * @return {boolean} true if request succeeds, false otherwise
- */
-IdPool.prototype.getSpecific = function (id) {
-    if (this.isUsed(id)) {
-        return false;
+        return id;
     }
 
-    this.bitSet.set(id, true);
-    return true;
-};
+    /**
+     * Attempt to request a specific ID from the pool.
+     * @param {number} id
+     * @return {boolean} true if request succeeds, false otherwise
+     */
+    getSpecific(id) {
+        if (this.isUsed(id)) {
+            return false;
+        }
 
-/**
- *
- * @param {number} id
- * @returns {boolean}
- */
-IdPool.prototype.isUsed = function (id) {
-    return this.bitSet.get(id);
-};
+        this.#set.set(id, true);
+        return true;
+    }
 
-/**
- * Traverse all IDs currently in use
- * @param {function(id:number)} visitor
- */
-IdPool.prototype.traverseUsed = function (visitor) {
-    assert.equal(typeof visitor, 'function', `visitor must be a function, instead was '${typeof visitor}'`);
+    /**
+     *
+     * @param {number} id
+     * @returns {boolean}
+     */
+    isUsed(id) {
+        return this.#set.get(id);
+    }
 
-    const bitSet = this.bitSet;
+    /**
+     * Traverse all IDs currently in use
+     * @param {function(id:number)} visitor
+     */
+    traverseUsed(visitor) {
+        assert.isFunction(visitor, "visitor");
 
-    for (let i = bitSet.nextSetBit(0); i !== -1; i = bitSet.nextSetBit(i + 1)) {
-        visitor(i);
-    }
+        const set = this.#set;
 
-};
+        for (let i = set.nextSetBit(0); i !== -1; i = set.nextSetBit(i + 1)) {
+            visitor(i);
+        }
 
-/**
- *
- * @param {number} id
- */
-IdPool.prototype.release = function (id) {
-    this.bitSet.clear(id);
-};
+    }
 
-IdPool.prototype.reset = function () {
-    this.bitSet.reset();
-};
+    /**
+     *
+     * @param {number} id
+     */
+    release(id) {
+        this.#set.clear(id);
+    }
+
+    /**
+     * Release all used IDs
+     */
+    reset() {
+        this.#set.reset();
+    }
+}
 
 export default IdPool;

package/src/core/json/abstractJSONSerializer.js

@@ -12,37 +12,37 @@ export function abstractJSONSerializer(source, serializers, classNames) {
         return source;
     }
 
-        // parameter is an object
+    // parameter is an object
 
-        // extract type name
-        const Klass = source.constructor;
-        let typeName = classNames.get(Klass);
+    // extract type name
+    const Klass = source.constructor;
+    let typeName = classNames.get(Klass);
 
-        if (typeName === undefined) {
-            // try fallback to "typeName" field on constructor
-            typeName = Klass.typeName;
-        }
+    if (typeName === undefined) {
+        // try fallback to "typeName" field on constructor
+        typeName = Klass.typeName;
+    }
 
-        if (typeName === undefined) {
-            throw new Error(`Failed to resolve type name. No name found in classNames registry and no .typeName field on the constructor`);
-        }
+    if (typeName === undefined) {
+        throw new Error(`Failed to resolve type name. No name found in classNames registry and no .typeName field on the constructor {name: '${Klass.name}}'`);
+    }
 
-        let serializer = serializers.get(typeName);
-        let serializerContext = undefined;
+    let serializer = serializers.get(typeName);
+    let serializerContext = undefined;
 
-        if (serializer === undefined) {
-            serializer = source.toJSON;
-            serializerContext = source;
-        }
+    if (serializer === undefined) {
+        serializer = source.toJSON;
+        serializerContext = source;
+    }
 
-        if (serializer === undefined) {
-            throw new Error(`Failed to resolve serializer for object type '${typeName}'. No serializer found in serializers registry and no .toJSON method on object itself`);
-        }
+    if (serializer === undefined) {
+        throw new Error(`Failed to resolve serializer for object type '${typeName}'. No serializer found in serializers registry and no .toJSON method on object itself`);
+    }
 
-        return {
-            type: typeName,
-            data: serializer.call(serializerContext, source)
-        };
+    return {
+        type: typeName,
+        data: serializer.call(serializerContext, source)
+    };
 
 
 }

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

@@ -127,6 +127,7 @@ export class NodeGraph {
      * Merge foreign nodes and associated connections into this graph
      * New node instances and connections will be created to reflect these inside this graph
      * NOTE: parameters on merged nodes are shallow copies
+     * NOTE: if IDs are available - copied nodes will have the same IDs as the originals
      * @param {NodeInstance[]} nodes
      * @param {Connection[]} [connections]
      * @returns {{connections:Connection[], nodes:NodeInstance[]}} local created instances
@@ -147,12 +148,28 @@ export class NodeGraph {
         for (let i = 0; i < additional_node_count; i++) {
             const other_node = nodes[i];
 
-            const this_node_id = this.createNode(other_node.description);
-            this_nodes[other_node.id] = this_node_id;
+            const other_node_id = other_node.id;
 
-            // copy parameters
-            const this_node = this.getNode(this_node_id);
+            const this_node = new NodeInstance();
+            this_node.setDescription(other_node.description);
+
+
+            // attempt to gain the same ID
+            const can_use_same_id = this.__idpNodes.isUsed(other_node_id);
+
+            let this_node_id;
+            if (can_use_same_id) {
+                this_node_id = other_node_id;
+            } else {
+                this_node_id = this.__idpNodes.peek();
+            }
 
+            this.addNode(this_node);
+
+
+            this_nodes[other_node_id] = this_node_id;
+
+            // copy parameters
             this_node.setParameters(other_node.parameters);
 
         }
@@ -376,13 +393,13 @@ export class NodeGraph {
     createNode(node) {
         const nodeInstance = new NodeInstance();
 
-        const id = this.__idpNodes.get();
+        const id = this.__idpNodes.peek();
 
         nodeInstance.id = id;
         nodeInstance.setDescription(node);
 
         //record the node
-        this.nodes.add(nodeInstance);
+        this.addNode(nodeInstance);
 
         return id;
     }

package/src/core/model/node-graph/node/NodeInstance.d.ts

@@ -11,4 +11,8 @@ export class NodeInstance {
     readonly endpoints: NodeInstancePortReference[]
 
     readonly connections: List<Connection>
+
+    setDescription(d: NodeDescription): void
+
+    setParameters(hash: { [key: string]: any }): void
 }