@woosh/meep-engine 2.54.0 → 2.56.0

package/src/core/cache/PersistentCacheAdapter.js

@@ -1,378 +0,0 @@
-import { IndexedDBStorage } from "../../engine/save/storage/IndexedDBStorage.js";
-import { assert } from "../assert.js";
-import { Base64 } from "../binary/Base64.js";
-import { BinaryBuffer } from "../binary/BinaryBuffer.js";
-
-const scratch_buffer = new BinaryBuffer();
-
-/**
- *
- * @type {number}
- */
-const BUFFER_MAX_RETAINED_SIZE = 131072;
-
-function cleanup_buffer() {
-    if (scratch_buffer.length > BUFFER_MAX_RETAINED_SIZE) {
-        scratch_buffer.position = 0;
-        scratch_buffer.setCapacity(BUFFER_MAX_RETAINED_SIZE);
-    }
-}
-
-/**
- * @template T
- * @param {T} object
- * @param {BinaryClassSerializationAdapter} adapter
- * @returns {string}
- */
-function object2string(object, adapter) {
-
-    scratch_buffer.position = 0;
-
-    // serialize key
-    adapter.serialize(scratch_buffer, object);
-
-    // convert key to string
-    const end = scratch_buffer.position;
-    const array_buffer = scratch_buffer.data.slice(0, end);
-
-    const result = Base64.encode(array_buffer);
-
-    cleanup_buffer();
-
-    return result;
-}
-
-/**
- * @template T
- * @param {string} string
- * @param {BinaryClassSerializationAdapter} adapter
- * @param {Class<T>} klass
- * @returns T
- */
-function string2object(string, adapter, klass) {
-    /**
-     *
-     * @type {T}
-     */
-    const result = new klass();
-
-    const arrayBuffer = Base64.decode(string);
-
-    scratch_buffer.fromArrayBuffer(arrayBuffer);
-
-    adapter.deserialize(scratch_buffer, result);
-
-    cleanup_buffer();
-
-    return result;
-}
-
-/**
- * Attaches to a cache instance and persists all the cache data asynchronously
- * Behaves similarly to WeakMap class with similar interface.
- * @template K,V
- */
-export class PersistentCacheAdapter {
-    /**
-     * @template K,V
-     * @param {string} storageKey
-     * @param {BinaryClassSerializationAdapter} keyAdapter
-     * @param {Class<K>|function} keyClass
-     * @param {BinaryClassSerializationAdapter} valueAdapter
-     * @param {Class<V>|function} valueClass
-     */
-    constructor({
-                    storageKey,
-                    keyAdapter,
-                    keyClass,
-                    valueAdapter,
-                    valueClass
-                }) {
-        assert.typeOf(storageKey, 'string', 'storageKey');
-
-        assert.defined(keyAdapter, 'keyAdapter');
-        assert.notNull(keyAdapter, 'keyAdapter');
-        assert.defined(keyClass, 'keyClass');
-        assert.notNull(keyClass, 'keyClass');
-
-        assert.defined(valueAdapter, 'valueAdapter');
-        assert.notNull(valueAdapter, 'valueAdapter');
-        assert.defined(valueClass, 'valueClass');
-        assert.notNull(valueClass, 'valueClass');
-
-        /**
-         *
-         * @type {string}
-         * @private
-         */
-        this.__storage_key = storageKey;
-        /**
-         *
-         * @type {BinaryClassSerializationAdapter}
-         * @private
-         */
-        this.__key_adapter = keyAdapter;
-        /**
-         *
-         * @type {Class<K>|Function}
-         * @private
-         */
-        this.__key_class = keyClass;
-
-        /**
-         *
-         * @type {BinaryClassSerializationAdapter}
-         * @private
-         */
-        this.__value_adapter = valueAdapter;
-        /**
-         *
-         * @type {Class<V>|Function}
-         * @private
-         */
-        this.__value_class = valueClass;
-
-        /**
-         *
-         * @type {Storage}
-         * @private
-         */
-        this.__storage = new IndexedDBStorage(`meep.core.persistent_cache/${storageKey}`);
-
-        /**
-         *
-         * @type {Cache|null}
-         * @private
-         */
-        this.__cache = null;
-    }
-
-    /**
-     *
-     * @param {Cache<K,V>} cache
-     * @param {boolean} ingest should data stored in the persisted cache be uploaded to the cache or not
-     */
-    async attach(cache, ingest = true) {
-        if (this.__cache !== null) {
-            throw new Error(`Adapted already connected to a cache`);
-        }
-
-        this.__cache = cache;
-
-        // connect signals
-        cache.onSet.add(this.__handle_set, this);
-        cache.onRemoved.add(this.__handle_remove, this);
-
-        if (ingest) {
-            await this.__ingest();
-        }
-    }
-
-    /**
-     *
-     * @return {Promise<void>}
-     * @private
-     */
-    async __ingest() {
-        /**
-         *
-         * @type {string[]}
-         */
-        const keys = await this.__storage.promiseList();
-
-        const key_count = keys.length;
-
-        const pairs = [];
-
-        /**
-         *
-         * @type {Promise[]}
-         */
-        const read_promises = [];
-
-        const start = performance.now();
-
-        for (let i = 0; i < key_count; i++) {
-            const key_string = keys[i];
-
-            const promise = new Promise(async (resolve, reject) => {
-                const key = string2object(key_string, this.__key_adapter, this.__key_class);
-
-                // read value
-                let value;
-
-                try {
-                    value = await this.__get_by_string_unsafe(key_string);
-                } catch (e) {
-
-                    // failed to read value, skip
-                    resolve();
-
-                    return;
-                }
-
-                // first read into temp array to prevent thrashing when adding one thing to cache would cause another thing to be removed
-                pairs.push([key, value]);
-
-                resolve();
-            });
-
-            read_promises.push(promise);
-        }
-
-        await Promise.all(read_promises);
-
-        console.log(`${this.__storage_key} : Ingesting ${key_count} values finished after ${performance.now() - start}ms`);
-
-        const cache = this.__cache;
-
-        // disconnect signals
-        cache.onSet.remove(this.__handle_set, this);
-        cache.onRemoved.remove(this.__handle_remove, this);
-
-        // add to cache
-        for (let i = 0; i < pairs.length; i++) {
-            const [key, value] = pairs[i];
-
-            cache.put(key, value);
-        }
-
-        // reconnect signals
-        cache.onSet.add(this.__handle_set, this);
-        cache.onRemoved.add(this.__handle_remove, this);
-
-    }
-
-    /**
-     *
-     * @param {K} key
-     * @param {V} value
-     * @private
-     */
-    __handle_set(key, value) {
-        this.set(key, value);
-    }
-
-    /**
-     *
-     * @param {K} key
-     * @private
-     */
-    __handle_remove(key) {
-        this.delete(key);
-    }
-
-
-    /**
-     *
-     * @param {K} key
-     * @param {V} value
-     * @private
-     */
-    async set(key, value) {
-        assert.defined(key, 'key');
-        assert.notNull(key, 'key');
-
-        assert.defined(value, 'value');
-        assert.notNull(value, 'value');
-
-        const key_string = object2string(key, this.__key_adapter);
-
-        // serialize value
-        scratch_buffer.position = 0;
-        this.__value_adapter.serialize(scratch_buffer, value);
-
-        cleanup_buffer();
-
-        const value_data = scratch_buffer.data.slice(0, scratch_buffer.position);
-
-        await this.__storage.promiseStoreBinary(key_string, value_data);
-    }
-
-    /**
-     *
-     * @param {K} key
-     * @returns {V|undefined}
-     * @private
-     */
-    async get(key) {
-        assert.defined(key, 'key');
-        assert.notNull(key, 'key');
-
-        const key_string = object2string(key, this.__key_adapter);
-
-        // check if value is present
-        const exists = await this.__storage.promiseContains(key_string);
-
-        if (!exists) {
-            // value doesn't exist
-            return undefined;
-        }
-
-        return this.__get_by_string_unsafe(key_string);
-    }
-
-    /**
-     * @param {string} key_string
-     * @return {Promise<V>}
-     * @private
-     */
-    async __get_by_string_unsafe(key_string) {
-
-        /**
-         *
-         * @type {ArrayBuffer}
-         */
-        const value_data = await this.__storage.promiseLoadBinary(key_string);
-
-        const value = new this.__value_class();
-
-        scratch_buffer.fromArrayBuffer(value_data);
-
-        try {
-            this.__value_adapter.deserialize(scratch_buffer, value);
-        } catch (e) {
-            // failed to deserialize
-            // console.error('Failed to deserialize the value: ', e);
-
-            // delete the value
-            this.__storage.promiseRemove(key_string);
-
-            throw new Error('Failed to deserialize');
-        } finally {
-            cleanup_buffer();
-        }
-
-        return value;
-    }
-
-    /**
-     *
-     * @param {K} key
-     * @returns {boolean}
-     * @private
-     */
-    async has(key) {
-        assert.defined(key, 'key');
-        assert.notNull(key, 'key');
-
-        const key_string = object2string(key, this.__key_adapter);
-
-        return await this.__storage.promiseContains(key_string);
-    }
-
-    /**
-     *
-     * @param {K} key
-     * @private
-     */
-    async delete(key) {
-        assert.defined(key, 'key');
-        assert.notNull(key, 'key');
-
-        const key_string = object2string(key, this.__key_adapter);
-
-        return await this.__storage.promiseRemove(key_string);
-    }
-}
-

package/src/core/collection/LazyStream.js

@@ -1,23 +0,0 @@
-/**
- * @template A,B
- * @param {A[]} source
- * @param {function(A,index:number):B} transformer
- * @returns {B[]}
- */
-export function lazyArrayMap(source, transformer) {
-    return new Proxy(source, {
-        get(target, p, receiver) {
-            if (/^([0-9]+)$/.test(p)) {
-
-                const targetElement = target[p];
-
-                const resultElement = transformer(targetElement, p);
-
-                return resultElement;
-            } else {
-
-                return target[p];
-            }
-        }
-    });
-}

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

@@ -1,13 +0,0 @@
-import { lazyArrayMap } from "./LazyStream.js";
-
-test('lazyArrayMap', () => {
-    const source = [1, 2, 3];
-
-    const map = lazyArrayMap(source, a => a * 2);
-
-    expect(map.length).toBe(source.length);
-
-    for (let i = 0; i < source.length; i++) {
-        expect(map[i]).toBe(source[i] * 2);
-    }
-});

package/src/core/collection/heap/BinaryHeap.js

@@ -1,153 +0,0 @@
-/**
- * @deprecated use {@link FastBinaryHeap} instead
- * @param scoreFunction
- * @constructor
- */
-function BinaryHeap(scoreFunction) {
-    this.content = [];
-    this.hash = [];
-    this.scoreFunction = scoreFunction;
-}
-
-BinaryHeap.prototype = {
-    push: function (element) {
-        const content = this.content;
-        const length = content.length;
-        // Add the new element to the end of the array.
-        content.push(element);
-        //update hash
-        this.hash[element] = length;
-
-        // Allow it to sink down.
-        this.sinkDown(length);
-    },
-    pop: function () {
-        // Store the first element so we can return it later.
-        const content = this.content;
-        const hash = this.hash;
-        const result = content[0];
-        //update hash
-        delete hash[result];
-        // Get the element at the end of the array.
-        const end = content.pop();
-        // If there are any elements left, put the end element at the
-        // start, and let it bubble up.
-        const length = content.length;
-        if (length > 0) {
-            content[0] = end;
-            hash[end] = 0;
-            this.bubbleUp(0);
-        }
-        return result;
-    },
-    contains: function (node) {
-        return this.hash[node] !== void 0;
-    },
-    remove: function (node) {
-
-        const length = this.content.length;
-        const i = this.hash[node];
-
-        // When it is found, the process seen in 'pop' is repeated
-        // to fill up the hole.
-        const end = this.content.pop();
-        if (i !== length) {
-            this.content[i] = end;
-
-            if (this.scoreFunction(end) < this.scoreFunction(node)) {
-                this.sinkDown(i);
-            } else {
-                this.bubbleUp(i);
-            }
-        }
-    },
-    size: function () {
-        return this.content.length;
-    },
-    rescoreElement: function (node) {
-        this.sinkDown(this.hash[node]);
-    },
-    sinkDown: function (n) {
-        // Fetch the element that has to be sunk.
-        const content = this.content;
-        const hash = this.hash;
-        const element = content[n];
-
-        // When at 0, an element can not sink any further.
-        while (n > 0) {
-
-            // Compute the parent element's index, and fetch it.
-            const parentN = ((n + 1) >> 1) - 1,
-                parent = content[parentN];
-            // Swap the elements if the parent is greater.
-            if (this.scoreFunction(element) < this.scoreFunction(parent)) {
-                content[parentN] = element;
-                content[n] = parent;
-                //update hash
-                hash[element] = parentN;
-                hash[parent] = n;
-                // Update 'n' to continue at the new position.
-                n = parentN;
-            }
-            // Found a parent that is less, no need to sink any further.
-            else {
-                break;
-            }
-        }
-    },
-    bubbleUp: function (n) {
-        // Look up the target element and its score.
-        const content = this.content;
-        const hash = this.hash;
-        const scoreFunction = this.scoreFunction;
-        const length = content.length,
-            element = content[n],
-            elemScore = scoreFunction(element);
-
-        for (; ;) {
-            // Compute the indices of the child elements.
-            const child2N = (n + 1) << 1,
-                child1N = child2N - 1;
-            // This is used to store the new position of the element, if any.
-            let swap = null,
-                child1Score;
-            // If the first child exists (is inside the array)...
-            if (child1N < length) {
-                // Look it up and compute its score.
-                const child1 = content[child1N];
-                child1Score = scoreFunction(child1);
-
-                // If the score is less than our element's, we need to swap.
-                if (child1Score < elemScore) {
-                    swap = child1N;
-                }
-
-            }
-
-            // Do the same checks for the other child.
-            if (child2N < length) {
-                const child2 = content[child2N],
-                    child2Score = scoreFunction(child2);
-                if (child2Score < (swap === null ? elemScore : child1Score)) {
-                    swap = child2N;
-                }
-            }
-
-            // If the element needs to be moved, swap it, and continue.
-            if (swap !== null) {
-                const swapContent = content[swap];
-                content[n] = swapContent;
-                content[swap] = element;
-                //update hash
-                hash[element] = swap;
-                hash[swapContent] = n;
-                n = swap;
-            }
-            // Otherwise, we are done.
-            else {
-                break;
-            }
-        }
-    }
-};
-export default BinaryHeap;

package/src/core/primitives/strings/StringUtils.js

@@ -1,105 +0,0 @@
-/**
- * @author Alex Goldring 2018
- * @copyright Alex Goldring 2018
- */
-
-/**
- * Compute byte size of a UTF8 string
- * @param {string} value
- * @returns {number}
- */
-export function computeUTF8StringByteSize(value) {
-    const length = value.length;
-
-    let p = 0;
-
-    for (let i = 0; i < length; i++) {
-        let c = value.charCodeAt(i);
-        while (c > 0xff) {
-            p++;
-            c >>= 8;
-        }
-        p++;
-    }
-
-    return p;
-}
-
-/**
- *
- * @param {string} string
- * @returns {string}
- */
-export function capitalize(string) {
-    const length = string.length;
-
-    if (length === 0) {
-        return string;
-    } else {
-        return string.charAt(0).toLocaleUpperCase() + string.substring(1);
-    }
-}
-
-/**
- * @example: ['abra', 'abc', 'abode'] => 'ab'
- * @param {String[]} strings
- * @returns string
- */
-export function computeCommonPrefix(strings) {
-    let i, j;
-
-    const numInputs = strings.length;
-
-    let result = "";
-
-    if (numInputs === 0) {
-        return result;
-    }
-
-    const firstString = strings[0];
-
-    let lengthLimit = firstString.length;
-
-    for (i = 1; i < numInputs; i++) {
-        lengthLimit = Math.min(strings[i].length, lengthLimit);
-    }
-
-
-    main_loop:for (i = 0; i < lengthLimit; i++) {
-        const letter0 = firstString.charAt(i);
-
-        for (j = 1; j < numInputs; j++) {
-
-            const string = strings[j];
-
-            const letter1 = string.charAt(i);
-
-            if (letter0 !== letter1) {
-                break main_loop;
-            }
-        }
-
-        result += letter0;
-    }
-
-    return result;
-}
-
-/**
- *
- * @param {string} string
- * @returns {string}
- */
-export function camelToKebab(string) {
-    return string.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-}
-
-
-/**
- *
- * @param {string} string
- * @returns {string}
- */
-export function kebabToUnderscore(string) {
-    return string.replace('-', '_');
-}

package/src/core/primitives/strings/StringUtils.spec.js

@@ -1,42 +0,0 @@
-import { camelToKebab, capitalize, computeCommonPrefix } from "./StringUtils.js";
-
-test("common prefix", () => {
-    expect(computeCommonPrefix([])).toBe("");
-
-    expect(computeCommonPrefix([""])).toBe("");
-
-    expect(computeCommonPrefix(["a"])).toBe("a");
-
-    expect(computeCommonPrefix(["abc"])).toBe("abc");
-
-    expect(computeCommonPrefix(["aa"])).toBe("aa");
-
-    expect(computeCommonPrefix(["aa", "ab"])).toBe("a");
-
-    expect(computeCommonPrefix(["abc", "abb"])).toBe("ab");
-
-    expect(computeCommonPrefix(["abc", "abc"])).toBe("abc");
-
-    expect(computeCommonPrefix(["abc", "abc", "a"])).toBe("a");
-
-    expect(computeCommonPrefix(["abc", "abc", ""])).toBe("");
-});
-
-test("capitalize", () => {
-    expect(capitalize("")).toBe("");
-
-    expect(capitalize("a")).toBe("A");
-
-    expect(capitalize("A")).toBe("A");
-
-    expect(capitalize("aa")).toBe("Aa");
-
-    expect(capitalize("AA")).toBe("AA");
-});
-
-test('camelToKebab', () => {
-    expect(camelToKebab('a')).toBe('a');
-    expect(camelToKebab('aA')).toBe('a-a');
-    expect(camelToKebab('helloWoRLD')).toBe('hello-wo-rld');
-    expect(camelToKebab('A')).toBe('a');
-});