@woosh/meep-engine 2.43.4 → 2.43.5

package/core/collection/map/AsyncMapWrapper.js

@@ -1,8 +1,20 @@
 import { AbstractAsyncMap } from "./AbstractAsyncMap.js";
 
+/**
+ * Wraps synchronous {@link Map}-implementing object
+ */
 export class AsyncMapWrapper extends AbstractAsyncMap {
-    constructor(source) {
+    /**
+     *
+     * @param {Map} [source]
+     */
+    constructor(source = new Map()) {
         super();
+        /**
+         *
+         * @type {Map}
+         * @private
+         */
         this._source = source;
     }
 

package/core/collection/map/CachedAsyncMap.js

@@ -1,10 +1,17 @@
 import { AbstractAsyncMap } from "./AbstractAsyncMap.js";
 
+/**
+ * Two-tier key-value storage. Intended to accelerate slow asynchronous
+ * storage with a fast but limited (in space and reliability) cache in front.
+ *
+ * First tier (volatile) is considered to be fast an unreliable,
+ * whereas second tier (persisted) is considered to be reliable, but slow.
+ */
 export class CachedAsyncMap extends AbstractAsyncMap {
     /**
      *
-     * @param {AbstractAsyncMap} volatile
-     * @param {AbstractAsyncMap} persisted
+     * @param {AbstractAsyncMap} volatile data here may be lost at any point, this is our "cache"
+     * @param {AbstractAsyncMap} persisted data here is stored reliably
      */
     constructor(volatile, persisted) {
         super();

package/core/collection/map/CachedAsyncMap.spec.js

@@ -0,0 +1,47 @@
+import { CachedAsyncMap } from "./CachedAsyncMap.js";
+import { AsyncMapWrapper } from "./AsyncMapWrapper.js";
+
+test("'get' retrieves data if it is available in volatile level", async () => {
+
+    const first = new Map();
+
+    const sut = new CachedAsyncMap(new AsyncMapWrapper(first), new AsyncMapWrapper());
+
+    first.set(1, 3);
+
+    expect(await sut.get(1)).toBe(3);
+});
+
+test("'get' retrieves data if it is available in persisted level", async () => {
+
+    const second = new Map();
+
+    const sut = new CachedAsyncMap(new AsyncMapWrapper(), new AsyncMapWrapper(second));
+
+    second.set(1, 3);
+
+    expect(await sut.get(1)).toBe(3);
+});
+
+test("'set' propagates data into volatile level", async () => {
+
+    const first = new Map();
+
+    const sut = new CachedAsyncMap(new AsyncMapWrapper(first), new AsyncMapWrapper());
+
+    await sut.set(1, 3);
+
+    expect(first.get(1)).toBe(3);
+});
+
+
+test("'set' propagates data into persisted level", async () => {
+
+    const second = new Map();
+
+    const sut = new CachedAsyncMap(new AsyncMapWrapper(), new AsyncMapWrapper(second));
+
+    await sut.set(1, 3);
+
+    expect(second.get(1)).toBe(3);
+});

package/engine/graphics/micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js

@@ -89,7 +89,15 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
 
                 this.__geometry_building_promises.set(geometry_id, p);
 
-                p.then(mg => this.__geometry_map.set(geometry_id, mg));
+                p.then(mg => {
+                    if (mg !== undefined) {
+                        this.__geometry_map.set(geometry_id, mg);
+                    }
+                });
+
+                p.finally(() => {
+                    this.__geometry_building_promises.delete(geometry_id);
+                });
             }
             return undefined;
         }

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.43.4",
+  "version": "2.43.5",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",