@woosh/meep-engine 2.47.15 → 2.47.16

package/build/meep.module.js

@@ -117641,87 +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();
 
-/**
- * Looks up next available ID without reserving it
- * If you want to also reserve the ID - use {@link get} instead
- * @returns {number}
- */
-IdPool.prototype.peek = function () {
-    return 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);
+    }
 
-/**
- *
- * @returns {number}
- */
-IdPool.prototype.get = function () {
-    const bitIndex = this.peek();
+    /**
+     *
+     * @returns {number}
+     */
+    get() {
+        const id = this.peek();
 
-    this.bitSet.set(bitIndex, true);
+        this.#set.set(id, true);
 
-    return bitIndex;
-};
+        return id;
+    }
 
-/**
- * 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;
+    /**
+     * 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;
+        }
+
+        this.#set.set(id, true);
+        return true;
     }
 
-    this.bitSet.set(id, true);
-    return true;
-};
+    /**
+     *
+     * @param {number} id
+     * @returns {boolean}
+     */
+    isUsed(id) {
+        return this.#set.get(id);
+    }
 
-/**
- *
- * @param {number} id
- * @returns {boolean}
- */
-IdPool.prototype.isUsed = function (id) {
-    return this.bitSet.get(id);
-};
+    /**
+     * Traverse all IDs currently in use
+     * @param {function(id:number)} visitor
+     */
+    traverseUsed(visitor) {
+        assert.isFunction(visitor, "visitor");
 
-/**
- * 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}'`);
+        const set = this.#set;
 
-    const bitSet = this.bitSet;
+        for (let i = set.nextSetBit(0); i !== -1; i = set.nextSetBit(i + 1)) {
+            visitor(i);
+        }
 
-    for (let i = bitSet.nextSetBit(0); i !== -1; i = bitSet.nextSetBit(i + 1)) {
-        visitor(i);
     }
 
-};
-
-/**
- *
- * @param {number} id
- */
-IdPool.prototype.release = function (id) {
-    this.bitSet.clear(id);
-};
+    /**
+     *
+     * @param {number} id
+     */
+    release(id) {
+        this.#set.clear(id);
+    }
 
-IdPool.prototype.reset = function () {
-    this.bitSet.reset();
-};
+    /**
+     * 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.15",
+  "version": "2.47.16",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/IdPool.js

@@ -7,86 +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();
 
-/**
- * Looks up next available ID without reserving it
- * If you want to also reserve the ID - use {@link get} instead
- * @returns {number}
- */
-IdPool.prototype.peek = function () {
-    return 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);
+    }
 
-/**
- *
- * @returns {number}
- */
-IdPool.prototype.get = function () {
-    const bitIndex = this.peek();
+    /**
+     *
+     * @returns {number}
+     */
+    get() {
+        const id = this.peek();
 
-    this.bitSet.set(bitIndex, true);
+        this.#set.set(id, true);
 
-    return bitIndex;
-};
+        return id;
+    }
 
-/**
- * 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;
+    /**
+     * 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;
+        }
+
+        this.#set.set(id, true);
+        return true;
     }
 
-    this.bitSet.set(id, true);
-    return true;
-};
+    /**
+     *
+     * @param {number} id
+     * @returns {boolean}
+     */
+    isUsed(id) {
+        return this.#set.get(id);
+    }
 
-/**
- *
- * @param {number} id
- * @returns {boolean}
- */
-IdPool.prototype.isUsed = function (id) {
-    return this.bitSet.get(id);
-};
+    /**
+     * Traverse all IDs currently in use
+     * @param {function(id:number)} visitor
+     */
+    traverseUsed(visitor) {
+        assert.isFunction(visitor, "visitor");
 
-/**
- * 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}'`);
+        const set = this.#set;
 
-    const bitSet = this.bitSet;
+        for (let i = set.nextSetBit(0); i !== -1; i = set.nextSetBit(i + 1)) {
+            visitor(i);
+        }
 
-    for (let i = bitSet.nextSetBit(0); i !== -1; i = bitSet.nextSetBit(i + 1)) {
-        visitor(i);
     }
 
-};
-
-/**
- *
- * @param {number} id
- */
-IdPool.prototype.release = function (id) {
-    this.bitSet.clear(id);
-};
+    /**
+     *
+     * @param {number} id
+     */
+    release(id) {
+        this.#set.clear(id);
+    }
 
-IdPool.prototype.reset = function () {
-    this.bitSet.reset();
-};
+    /**
+     * 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)
+    };
 
 
 }