@woosh/meep-engine 2.50.2 → 2.51.0

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

@@ -1,5 +1,6 @@
 import { jest } from "@jest/globals";
 import { Cache } from "./Cache.js";
+import { returnOne } from "../function/Functions.js";
 
 test("constructor doesn't throw", () => {
     new Cache({});
@@ -162,3 +163,35 @@ test("calling 'evictOne' on empty cache should return false", () => {
 
     expect(cache.evictOne()).toBe(false);
 });
+
+test("recomputeWeight", () => {
+    const cache = new Cache({
+        valueWeigher: () => 3,
+        keyWeigher: returnOne
+    });
+
+    cache.set(1, 1);
+
+    expect(cache.weight).toBe(4);
+
+    cache.recomputeWeight();
+
+    expect(cache.weight).toBe(4);
+});
+
+test("silentRemove should not notify", () => {
+
+    const cache = new Cache();
+
+    cache.set("x", 1);
+
+    const mock = jest.fn();
+
+    cache.onRemoved.add(mock);
+
+    cache.silentRemove("x");
+
+    expect(cache.contains('x')).toBe(false);
+
+    expect(mock).not.toHaveBeenCalled();
+});

package/src/core/cache/CacheElement.js

@@ -1,6 +1,7 @@
 /**
  * Doubly-linked list implementation for key-value pairs
  * @template Key, Value
+ * @class
  */
 export class CacheElement {
     /**

package/src/core/cache/FrequencySketch.js

@@ -4,7 +4,12 @@ import { ceilPowerOfTwo } from "../binary/operations/ceilPowerOfTwo.js";
 import { min2 } from "../math/min2.js";
 
 const SEED = [ // A mixture of seeds from FNV-1a, CityHash, and Murmur3
-    0x97cb3127, 0xbe98f273, 0x2f90404f, 0x84222325];
+    0x97cb3127,
+    0xbe98f273,
+    0x2f90404f,
+    0x84222325
+];
+
 const RESET_MASK = 0x77777777;
 const ONE_MASK = 0x11111111;
 
@@ -49,28 +54,26 @@ const MAX_INT_32 = 2147483647;
  * @template T
  */
 export class FrequencySketch {
-    constructor() {
-        /**
-         *
-         * @type {number}
-         */
-        this.sampleSize = 0;
-        /**
-         *
-         * @type {number}
-         */
-        this.tableMask = 0;
-        /**
-         *
-         * @type {Uint32Array|null}
-         */
-        this.table = null;
-        /**
-         *
-         * @type {number}
-         */
-        this.size = 0;
-    }
+    /**
+     *
+     * @type {number}
+     */
+    sampleSize = 0;
+    /**
+     *
+     * @type {number}
+     */
+    tableMask = 0;
+    /**
+     *
+     * @type {Uint32Array|null}
+     */
+    table = null;
+    /**
+     *
+     * @type {number}
+     */
+    size = 0;
 
     /**
      * Initializes and increases the capacity of this <tt>FrequencySketch</tt> instance, if necessary,

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

@@ -0,0 +1,5 @@
+import { FrequencySketch } from "./FrequencySketch.js";
+
+test("constructor does not throw", () => {
+    expect(() => new FrequencySketch()).not.toThrow();
+});

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

@@ -18,4 +18,6 @@ export declare class LoadingCache<K, V> {
     clear(): void
 
     get(key: K): Promise<V>
+
+    put(key: K, value: V): void
 }

package/src/core/cache/LoadingCache.js

@@ -51,13 +51,13 @@ export class LoadingCache {
 
     /**
      * @see {@link Cache} for more details on what each parameter means
-     * @param maxWeight
-     * @param keyWeigher
-     * @param valueWeigher
-     * @param keyHashFunction
-     * @param keyEqualityFunction
-     * @param capacity
-     * @param {number} [timeToLive] in seconds
+     * @param [maxWeight]
+     * @param [keyWeigher]
+     * @param [valueWeigher]
+     * @param [keyHashFunction]
+     * @param [keyEqualityFunction]
+     * @param [capacity]
+     * @param {number} [timeToLive] in seconds, default is 10 seconds
      * @param load
      * @param {boolean} [retryFailed]
      */
@@ -141,6 +141,15 @@ export class LoadingCache {
         return record.value;
     }
 
+    /**
+     * Directly insert value into the cache
+     * @param {K} key
+     * @param {V} value
+     */
+    put(key, value) {
+        this.#internal.put(key, new Record(Promise.resolve(value), current_time_in_seconds()));
+    }
+
     /**
      *
      * @param {K} key

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

@@ -45,3 +45,27 @@ test("timeout reload reuse", async () => {
 
     expect(await cache.get(1)).toEqual(3);
 });
+
+test("insert element directly", async () => {
+
+    const cache = new LoadingCache({
+        load: async () => 3
+    });
+
+    cache.put("x", 1);
+
+    expect(await cache.get("x")).toEqual(1);
+});
+
+test("clear", async () => {
+
+    const cache = new LoadingCache({
+        load: async () => 3
+    });
+
+    cache.put("x", 1);
+
+    cache.clear();
+
+    expect(await cache.get("x")).toEqual(3);
+});

package/src/core/collection/HashMap.d.ts

@@ -21,6 +21,8 @@ export class HashMap<K, V> implements Iterable<[V, K]> {
 
     getOrCompute(key: K, compute: (k: K) => V, thisArg?: any): V
 
+    getOrSet(key: K, default_value: V): V
+
     has(key: K): boolean
 
     delete(key: K): boolean

package/src/core/collection/HashMap.spec.js

@@ -83,6 +83,23 @@ test("getOrCompute", () => {
     expect(map.getOrCompute("y", compute)).toBe(3);
 });
 
+test("getOrSet", () => {
+
+    const map = new HashMap({
+        keyHashFunction: returnOne,
+        keyEqualityFunction: strictEquals
+    });
+
+    map.getOrSet(3, "hello");
+
+    expect(map.get(3)).toBe("hello");
+
+    map.getOrSet(3, "kitty");
+
+    expect(map.get(3)).toBe("hello");
+
+});
+
 test("retrieval works as intended after hash map grows", () => {
     const m = new HashMap({
         keyHashFunction: passThrough,
@@ -155,7 +172,12 @@ test("key iterator", () => {
 
     map.set(7, "hello");
 
-    expect(map.keys().next().value).toBe(7);
+    const iterator = map.keys();
+    expect(iterator.next().value).toBe(7);
+    expect(iterator.next()).toEqual({
+        done: true,
+        value: undefined
+    });
 });
 
 test("value iterator", () => {
@@ -166,7 +188,34 @@ test("value iterator", () => {
 
     map.set(7, "hello");
 
-    expect(map.values().next().value).toBe("hello");
+    const iterator = map.values();
+    expect(iterator.next().value).toBe("hello");
+    expect(iterator.next()).toEqual({
+        done: true,
+        value: undefined
+    });
+});
+
+test("forEach", () => {
+    const map = new HashMap({
+        keyHashFunction: returnOne,
+        keyEqualityFunction: strictEquals
+    });
+
+    const mock = jest.fn();
+
+    map.forEach(mock);
+
+    expect(mock).not.toHaveBeenCalled();
+
+    map.set(7, "hello");
+    map.set(3, "kitty");
+
+    map.forEach(mock);
+
+    expect(mock).toHaveBeenCalledTimes(2);
+    expect(mock).toHaveBeenCalledWith("kitty", 3, map);
+    expect(mock).toHaveBeenCalledWith("hello", 7, map);
 });
 
 

package/src/core/collection/list/List.d.ts

@@ -12,21 +12,33 @@ export default class List<T> {
 
     get(index: number): T
 
-    add(el: T): List<T>
+    add(el: T): this
 
     addAll(el: T[]): void
 
+    insert(index: number, element: T): this
+
     remove(index: number): T
 
     removeOneOf(value: T): boolean
 
+    removeIf(condition: (element: T) => boolean, thisArg?: any): void
+
+    removeOneIf(condition: (element: T) => boolean, thisArg?: any): void
+
+    reset(): void
+
     asArray(): T[]
 
     forEach(f: (element: T, index: number) => any, thisArg?: any): void
 
+    map<X>(f: (element: T, index: number) => X, thisArg?: any): X[]
+
     isEmpty(): boolean
 
     indexOf(el: T): number
 
+    find(matcher: (element: T) => boolean): T | undefined
+
     equals(other: List<T>): boolean
 }