@woosh/meep-engine 2.49.4 → 2.49.6

package/package.json

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

package/src/core/cache/LoadingCache.d.ts

@@ -1,18 +1,19 @@
-export declare class LoadingCache<K,V>{
-    constructor(options:{
+export declare class LoadingCache<K, V> {
+    constructor(options: {
         maxWeight?: number,
         keyWeigher?: (key: K) => number,
         valueWeigher?: (value: V) => number,
         keyHashFunction?: (key: K) => number,
         keyEqualityFunction?: (a: K, b: K) => boolean,
         capacity?: number,
-        timeToLive?:number,
-        load:(key:K)=> Promise<V>
+        timeToLive?: number,
+        load: (key: K) => Promise<V>,
+        retryFailed?: boolean
     })
 
-    invalidate(key:K):void
+    invalidate(key: K): void
 
-    clear():void
+    clear(): void
 
-    get(key:K):Promise<V>
+    get(key: K): Promise<V>
 }

package/src/core/cache/LoadingCache.js

@@ -3,17 +3,18 @@
 import { Cache } from "./Cache.js";
 
 /**
- * @template {V}
+ * @template R
  */
 class Record {
     /**
-     *
-     * @param {V} value
+     * @template R
+     * @param {R} value
      * @param {number} time
      */
     constructor(value, time) {
         this.value = value;
         this.time = time;
+        this.failed = false;
     }
 }
 
@@ -38,6 +39,12 @@ export class LoadingCache {
      */
     #load
 
+    /**
+     *
+     * @type {boolean}
+     */
+    #policyRetryFailed = true;
+
     /**
      * @see {@link Cache} for more details on what each parameter means
      * @param maxWeight
@@ -48,6 +55,7 @@ export class LoadingCache {
      * @param capacity
      * @param {number} [timeToLive] in seconds
      * @param load
+     * @param {boolean} [retryFailed]
      */
     constructor({
                     maxWeight,
@@ -57,7 +65,8 @@ export class LoadingCache {
                     keyEqualityFunction,
                     capacity,
                     timeToLive = DEFAULT_TIME_TO_LIVE,
-                    load
+                    load,
+                    retryFailed = true
                 }) {
 
         this.#internal = new Cache({
@@ -71,6 +80,7 @@ export class LoadingCache {
 
         this.#timeToLive = timeToLive;
         this.#load = load;
+        this.#policyRetryFailed = retryFailed;
     }
 
     /**
@@ -96,17 +106,36 @@ export class LoadingCache {
     async get(key) {
         const currentTime = performance.now() * 1e-3;
 
+        /**
+         *
+         * @type {Record<Promise<V>>}
+         */
         let record = this.#internal.get(key);
 
-        if (record === null || (record.time + this.#timeToLive) < currentTime) {
+        if (record === null
+            || (record.time + this.#timeToLive) < currentTime  // timeout
+            || (record.failed && this.#policyRetryFailed) // load failed and we're configured to retry
+        ) {
+
+            // record needs to be loaded
 
-            // missing or stale record
-            const promise = this.#load(key);
+            let promise;
+
+            try {
+                promise = this.#load(key);
+            }catch (e){
+                promise = Promise.reject(e);
+            }
 
             record = new Record(promise, currentTime);
 
             this.#internal.put(key, record);
 
+            promise.catch(() => {
+                // mark as failure
+                record.failed = true;
+            });
+
         }
 
 

package/src/core/cache/LoadingCache.spec.js

@@ -0,0 +1,47 @@
+import { LoadingCache } from "./LoadingCache.js";
+import { delay } from "../process/delay.js";
+
+test("successful load", async () => {
+    const cache = new LoadingCache({
+        async load(key) {
+            return 17;
+        }
+    });
+
+    expect(await cache.get(1)).toEqual(17);
+});
+
+test("record reuse", async () => {
+    const load = jest.fn(async () => 17);
+
+    const cache = new LoadingCache({
+        load
+    });
+
+    expect(await cache.get(1)).toEqual(17);
+    expect(await cache.get(1)).toEqual(17);
+
+    expect(load).toHaveBeenCalledTimes(1);
+});
+
+test("timeout reload reuse", async () => {
+
+    const values = [3, 5, 11];
+
+    const load = jest.fn(async () => values.pop());
+
+    const cache = new LoadingCache({
+        load,
+        timeToLive: 0.00001
+    });
+
+    expect(await cache.get(1)).toEqual(11);
+
+    await delay(1);
+
+    expect(await cache.get(1)).toEqual(5);
+
+    await delay(1);
+
+    expect(await cache.get(1)).toEqual(3);
+});