@woosh/meep-engine 2.84.8 → 2.84.10

package/src/core/cache/LoadingCache.js

@@ -1,6 +1,7 @@
 //
 
 import { assert } from "../assert.js";
+import { returnZero } from "../function/returnZero.js";
 import { current_time_in_seconds } from "../time/current_time_in_seconds.js";
 import { Cache } from "./Cache.js";
 
@@ -17,6 +18,7 @@ class Record {
         this.value = value;
         this.time = time;
         this.failed = false;
+        this.weight = 0;
     }
 }
 
@@ -27,6 +29,15 @@ class Record {
  */
 const DEFAULT_TIME_TO_LIVE = Infinity;
 
+/**
+ * @template T
+ * @param {Record<T>} record
+ * @returns {number}
+ */
+function record_get_value_weight(record) {
+    return record.weight;
+}
+
 /**
  * Asynchronous cache capable of resolving its own values by keys
  * Modelled on Guava's LoadingCache concept
@@ -54,6 +65,11 @@ export class LoadingCache {
      * @type {boolean}
      */
     #policyRetryFailed = true;
+    /**
+     *
+     * @type {function(V): number}
+     */
+    #value_weigher;
 
     /**
      * @see {@link Cache} for more details on what each parameter means
@@ -71,7 +87,7 @@ export class LoadingCache {
     constructor({
                     maxWeight,
                     keyWeigher,
-                    valueWeigher,
+                    valueWeigher = returnZero,
                     keyHashFunction,
                     keyEqualityFunction,
                     capacity,
@@ -85,7 +101,7 @@ export class LoadingCache {
         this.#internal = new Cache({
             maxWeight,
             keyWeigher,
-            valueWeigher,
+            valueWeigher: record_get_value_weight,
             keyHashFunction,
             keyEqualityFunction,
             capacity,
@@ -94,14 +110,16 @@ export class LoadingCache {
         this.#timeToLive = timeToLive;
         this.#load = load;
         this.#policyRetryFailed = retryFailed;
+        this.#value_weigher = valueWeigher;
     }
 
     /**
      *
      * @param {K} key
+     * @returns {boolean}
      */
     invalidate(key) {
-        this.#internal.remove(key);
+        return this.#internal.remove(key);
     }
 
     /**
@@ -131,6 +149,12 @@ export class LoadingCache {
 
         this.#internal.put(key, record);
 
+        promise.then((value) => {
+            // re-score value based on actual data
+            record.weight = this.#value_weigher(value);
+            this.#internal.updateElementWeight(key);
+        });
+
         promise.catch(() => {
             // mark as failure
             record.failed = true;

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

@@ -1,5 +1,5 @@
-import { LoadingCache } from "./LoadingCache.js";
 import { delay } from "../process/delay.js";
+import { LoadingCache } from "./LoadingCache.js";
 
 test("successful load", async () => {
     const cache = new LoadingCache({
@@ -11,6 +11,18 @@ test("successful load", async () => {
     expect(await cache.get(1)).toEqual(17);
 });
 
+test("when loader throws an exception, we should get a failed promise", async () => {
+    const cache = new LoadingCache({
+        load(key) {
+            throw 1;
+        }
+    });
+
+    const promise = cache.get("a");
+
+    await expect(promise).rejects.toEqual(1);
+});
+
 test("record reuse", async () => {
     const load = jest.fn(async () => 17);
 
@@ -32,18 +44,21 @@ test("timeout reload reuse", async () => {
 
     const cache = new LoadingCache({
         load,
-        timeToLive: 0.00001
+        timeToLive: 0.0000001
     });
 
-    expect(await cache.get(1)).toEqual(11);
+    const request_1 = await cache.get(1);
+    expect(request_1).toEqual(11);
 
-    await delay(1);
+    await delay(2);
 
-    expect(await cache.get(1)).toEqual(5);
+    const request_2 = await cache.get(1);
+    expect(request_2).toEqual(5);
 
-    await delay(1);
+    await delay(2);
 
-    expect(await cache.get(1)).toEqual(3);
+    const request_3 = await cache.get(1);
+    expect(request_3).toEqual(3);
 });
 
 test("insert element directly", async () => {

package/src/core/collection/array/arraySetSortingDiff.js

@@ -22,17 +22,17 @@ export function arraySetSortingDiff(a, b, compare) {
 
     const common = [];
 
-    let lA = uniqueA.length;
-    let lB = uniqueB.length;
+    let length_a = uniqueA.length;
+    let length_b = uniqueB.length;
 
     let i;
     let j;
     let cursor_j = 0;
 
-    for (i = 0; i < lA; i++) {
+    for (i = 0; i < length_a; i++) {
         const el_a = uniqueA[i];
 
-        for (j = cursor_j; j < lB; j++) {
+        for (j = cursor_j; j < length_b; j++) {
             const el_b = uniqueB[j];
 
             const diff = compare(el_a, el_b);
@@ -46,8 +46,8 @@ export function arraySetSortingDiff(a, b, compare) {
                 i--;
                 j--;
 
-                lA--;
-                lB--;
+                length_a--;
+                length_b--;
 
             } else if (diff > 0) {
                 cursor_j++;