@woosh/meep-engine 2.110.1 → 2.110.4

package/build/meep.cjs

@@ -97940,71 +97940,89 @@ class ImmutableObjectPool {
     }
 }
 
+/**
+ * Object Pool pattern implementation.
+ * Reuse objects instead of relying on garbage collector. Useful in cases where creating or destroying an object is costly, and objects are relatively short-lived
+ * @template T
+ */
 class ObjectPoolFactory {
     /**
-     * @template T
+     * @private
+     * @type {Array<T>}
+     */
+    pool = [];
+
+    /**
+     * @type {number}
+     */
+    maxSize = 256;
+
+    /**
      * @param {function():T} creator
      * @param {function(T)} destroyer
      * @param {function(T)} resetter
-     * @constructor
      */
-    constructor(creator, destroyer, resetter) {
+    constructor(
+        creator,
+        destroyer = noop,
+        resetter = noop
+    ) {
+
         /**
          * @private
          * @type {function(): T}
          */
         this.creator = creator;
+
         /**
          * @private
          * @type {function(T)}
          */
         this.destroyer = destroyer;
+
         /**
          * @private
          * @type {function(T)}
          */
         this.resetter = resetter;
 
-        /**
-         * @private
-         * @type {Array<T>}
-         */
-        this.pool = [];
-
-        /**
-         * @private
-         * @type {number}
-         */
-        this.maxSize = 256;
     }
 
     /**
      *
      * @returns {T}
      */
-    create() {
-        if (this.pool.length > 0) {
-            const oldInstance = this.pool.pop();
+    get() {
+        const pool = this.pool;
+
+        if (pool.length > 0) {
+
+            const oldInstance = pool.pop();
 
             //reset the object
             this.resetter(oldInstance);
 
             return oldInstance;
+
         } else {
+
             const newInstance = this.creator();
 
             return newInstance;
+
         }
     }
 
     /**
      *
      * @param {T} object
-     * @returns {boolean}
+     * @returns {boolean} true if object was added back to the pool, false if pool was full and object was destroyed instead
      */
     release(object) {
 
-        if (this.pool.length >= this.maxSize) {
+        const pool = this.pool;
+
+        if (pool.length >= this.maxSize) {
             //pool is too large, destroy and discard the object
             if (this.destroyer !== noop) {
                 this.destroyer(object);
@@ -98014,11 +98032,18 @@ class ObjectPoolFactory {
         }
 
         //add it to the pool
-        this.pool.push(object);
+        pool.push(object);
 
         return true;
     }
-}
+}
+
+
+/**
+ * @deprecated use `get` instead
+ * @type {function(): T}
+ */
+ObjectPoolFactory.prototype.create = ObjectPoolFactory.prototype.get;
 
 /**
  * Will invoke A.equals(B) on members if such exists