@woosh/meep-engine 2.165.6 → 2.165.7

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

@@ -1,45 +1,334 @@
-import Signal from "../../events/signal/Signal";
-
-export default class List<T> {
-    get length(): number
-
-    on: {
-        added: Signal<T, number>,
-        removed: Signal<T, number>,
-        changed: Signal<void>,
-    }
-
-    constructor(elements?: T[])
-
-    get(index: number): 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
-}
+export default List;
+/**
+ *
+ * List structure with event signals for observing changes.
+ * @template T
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+declare class List<T> {
+    /**
+     * @param {T[]} [array]
+     */
+    constructor(array?: T[]);
+    /**
+     * @readonly
+     */
+    readonly on: {
+        /**
+         * @readonly
+         * @type {Signal<T,number>}
+         */
+        readonly added: any;
+        /**
+         * @readonly
+         * @type {Signal<T,number>}
+         */
+        readonly removed: any;
+        /**
+         * Captures both {@link #on.added} and {@link #on.removed} signals.
+         * Useful shortcut if you don't care about actual modifications, just the fact that something has changed.
+         * @readonly
+         * @type {Signal<>}
+         */
+        readonly changed: any;
+    };
+    /**
+     * @readonly
+     * @type {T[]}
+     */
+    readonly data: T[];
+    /**
+     * Number of elements in the list
+     * @type {number}
+     */
+    length: number;
+    /**
+     * Retrieve element at a given position in the list
+     * @param {number} index
+     * @returns {T|undefined}
+     */
+    get(index: number): T | undefined;
+    /**
+     * Set element at a given position inside the list
+     * @param {number} index
+     * @param {T} value
+     */
+    set(index: number, value: T): void;
+    /**
+     *
+     * @param {T} el
+     * @returns {this}
+     */
+    add(el: T): this;
+    /**
+     * Only add element if it doesn't already exist in the list
+     * Useful when you wish to ensure uniqueness of elements inside the list
+     * Note that this operation is rather slow as it triggers a linear scan
+     * If the list gets large - consider using a {@link Set} class instead
+     * @param {T} el
+     * @return {boolean} true if element was added, false if element already existed in the list
+     */
+    addUnique(el: T): boolean;
+    /**
+     * Insert element at a specific position into the list
+     * This operation will result in a larger list
+     * @param {number} index
+     * @param {T} el
+     * @returns {List}
+     * @throws {Error} when trying to insert past list end
+     */
+    insert(index: number, el: T): List<any>;
+    /**
+     * Reduces the list to a subsection but removing everything before startIndex and everything after endIndex
+     * @param {int} startIndex
+     * @param {int} endIndex up to this index, not including it
+     * @returns {number}
+     */
+    crop(startIndex: int, endIndex: int): number;
+    /**
+     * Replace the data, replacements is performed surgically, meaning that diff is computed and add/remove operations are performed on the set
+     * This method is tailored to work well with visualisation as only elements that's missing from the new set is removed, and only elements that are new to are added
+     * Conversely, relevant events are dispatched that can observe. This results in fewer changes required to the visualisation
+     * @param {T[]} new_data
+     */
+    patch(new_data: T[]): void;
+    /**
+     *
+     * @param {Array.<T>} elements
+     */
+    addAll(elements: Array<T>): void;
+    /**
+     *
+     * @param {Array.<T>} elements
+     * @see addUnique
+     * @see addAll
+     */
+    addAllUnique(elements: Array<T>): void;
+    /**
+     *
+     * @param {number} index
+     * @param {number} removeCount
+     * @returns {T[]}
+     */
+    removeMany(index: number, removeCount: number): T[];
+    /**
+     *
+     * @param {number} index
+     * @returns {T}
+     */
+    remove(index: number): T;
+    /**
+     *
+     * @param {T[]} elements
+     * @returns {boolean} True is all specified elements were found and removed, False if some elements were not present in the list
+     */
+    removeAll(elements: T[]): boolean;
+    /**
+     *
+     * @param {T} value
+     * @return {boolean}
+     */
+    removeOneOf(value: T): boolean;
+    /**
+     *
+     * @param {function(a:T, b:T):number} [compare_function]
+     * @returns {this}
+     */
+    sort(compare_function: any): this;
+    /**
+     * Copy of this list
+     * The copy is shallow
+     * @returns {List.<T>}
+     */
+    clone(): List<T>;
+    /**
+     * Returns a shallow copy array with elements in range from start to end (end not included)
+     * Same as {@link Array.prototype.slice}
+     * @param {number} [start]
+     * @param {number} [end]
+     * @return {T[]}
+     */
+    slice(start?: number, end?: number): T[];
+    /**
+     *
+     * @param {function(element:T):boolean} condition
+     * @returns {boolean}
+     */
+    some(condition: any): boolean;
+    /**
+     *
+     * @param {function(T):boolean} condition must return boolean value
+     * @param {*} [thisArg]
+     * @see removeOneIf
+     */
+    removeIf(condition: (arg0: T) => boolean, thisArg?: any): void;
+    /**
+     *
+     * @param {function(T):boolean} condition
+     * @param {*} [thisArg]
+     * @return {boolean}
+     * @see removeIf
+     */
+    removeOneIf(condition: (arg0: T) => boolean, thisArg?: any): boolean;
+    /**
+     * INVARIANT: List length must not change during the traversal
+     * @param {function(el:T, index:number):?} f
+     * @param {*} [thisArg]
+     */
+    forEach(f: any, thisArg?: any): void;
+    /**
+     * @param {function(*,T):*} f
+     * @param {*} initial
+     * @returns {*}
+     */
+    reduce(f: (arg0: any, arg1: T) => any, initial: any): any;
+    /**
+     *
+     * @param {function(T):boolean} f
+     * @returns {Array.<T>}
+     */
+    filter(f: (arg0: T) => boolean): Array<T>;
+    /**
+     *
+     * @param {function(el:T):boolean} matcher
+     * @returns {T|undefined}
+     */
+    find(matcher: any): T | undefined;
+    /**
+     *
+     * @param {function(T):boolean} matcher
+     * @returns {number} Index of the first match or -1
+     */
+    findIndex(matcher: (arg0: T) => boolean): number;
+    /**
+     *
+     * @param {function(el:T):boolean} matcher
+     * @param {function(el:T, index:number):*} callback
+     * @returns {boolean}
+     */
+    visitFirstMatch(matcher: any, callback: any): boolean;
+    /**
+     *
+     * @param {T} v
+     * @returns {boolean}
+     */
+    contains(v: T): boolean;
+    /**
+     * Does the list contain at least one of the given options?
+     * @param {T[]} options
+     * @returns {boolean}
+     */
+    containsAny(options: T[]): boolean;
+    /**
+     * List has no elements
+     * @returns {boolean}
+     */
+    isEmpty(): boolean;
+    /**
+     *
+     * @param {T} el
+     * @returns {number}
+     */
+    indexOf(el: T): number;
+    /**
+     * @template R
+     * @param {function(T):R} callback
+     * @param {*} [thisArg]
+     * @returns {R[]}
+     */
+    map<R>(callback: (arg0: T) => R, thisArg?: any): R[];
+    /**
+     * @deprecated use `#reset` directly in combination with `this.on.removed` signal
+     * @param {function(element:T,index:number)} callback
+     * @param {*} [thisArg]
+     */
+    resetViaCallback(callback: any, thisArg?: any): void;
+    /**
+     * Clears the list and removes all elements
+     */
+    reset(): void;
+    /**
+     * Note that elements must have .clone method for this to work
+     * @param {List<T>} other
+     * @param {function} [removeCallback]
+     * @param {*} [thisArg] Used on removeCallback
+     */
+    deepCopy(other: List<T>, removeCallback?: Function, thisArg?: any): void;
+    /**
+     *
+     * @param {List<T>|T[]} other
+     */
+    copy(other: List<T> | T[]): void;
+    /**
+     * NOTE: do not modify resulting array
+     * @returns {T[]}
+     */
+    asArray(): T[];
+    toJSON(): any;
+    /**
+     * @template J
+     * @param {J[]} json
+     * @param {function} constructor
+     */
+    fromJSON<J>(json: J[], constructor: Function): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer: BinaryBuffer): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param constructor
+     */
+    fromBinaryBuffer(buffer: BinaryBuffer, constructor: any): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {function(buffer:BinaryBuffer)} factory
+     */
+    fromBinaryBufferViaFactory(buffer: BinaryBuffer, factory: any): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {function(buffer:BinaryBuffer)} factory
+     */
+    addFromBinaryBufferViaFactory(buffer: BinaryBuffer, factory: any): void;
+    /**
+     * @template J
+     * @param {J[]} data
+     * @param {function(J):T} factory
+     */
+    addFromJSONViaFactory<J_1>(data: J_1[], factory: (arg0: J_1) => T): void;
+    /**
+     * NOTE: Elements must have `hash` method for this to work
+     *
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * First element in the list
+     * @returns {T|undefined}
+     */
+    first(): T | undefined;
+    /**
+     * Last element in the list
+     * @return {T|undefined}
+     */
+    last(): T | undefined;
+    /**
+     * Perform element-wise equality comparison with another list
+     * @param {List} other
+     * @returns {boolean}
+     */
+    equals(other: List<any>): boolean;
+    /**
+     *
+     * @param {List<T>} other
+     * @returns {number}
+     */
+    compare(other: List<T>): number;
+}
+//# sourceMappingURL=List.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"List.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/List.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"List.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/List.js"],"names":[],"mappings":"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"}

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

@@ -1,18 +1,37 @@
-import List from "./List";
-
-export class ListForwarder<T> {
-
-    public destination: List<T>
-
-    constructor()
-
-    add(source: List<T>): boolean
-
-    remove(source: List<T>): boolean
-
-    link(): void
-
-    unlink(): void
-
-    isLinked(): boolean
-}
+/**
+ * @template T
+ */
+export class ListForwarder<T> {
+    /**
+     *
+     * @param {List<T>} v
+     */
+    set destination(arg: List<T>);
+    /**
+     *
+     * @return {List<T>}
+     */
+    get destination(): List<T>;
+    /**
+     *
+     * @param {List<T>} source
+     * @return {boolean}
+     */
+    add(source: List<T>): boolean;
+    /**
+     *
+     * @param {List<T>} source
+     * @return {boolean}
+     */
+    remove(source: List<T>): boolean;
+    link(): void;
+    unlink(): void;
+    /**
+     *
+     * @return {boolean}
+     */
+    isLinked(): boolean;
+    #private;
+}
+import List from "./List.js";
+//# sourceMappingURL=ListForwarder.d.ts.map

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

@@ -1,40 +1,199 @@
-export class HashMap<K, V> implements Iterable<[V, K]> {
-    constructor({
-                    keyHashFunction,
-                    keyEqualityFunction,
-                    capacity,
-                    loadFactor
-                }: {
-        keyHashFunction?: (k: K) => number,
-        keyEqualityFunction?: (a: K, b: K) => boolean,
-        capacity?: number,
-        loadFactor?: number
-    })
-
-    constructor()
-
-    get size(): number
-
-    set(key: K, value: V): void
-
-    get(key: K): V | undefined
-
-    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
-
-    clear(): void
-
-    forEach(callback: (value: V, key: K, map: this) => any, thisArg?: any): void
-
-    [Symbol.iterator](): IterableIterator<[K, V]>
-
-    values(): IterableIterator<V>
-
-    keys(): IterableIterator<K>
-}
-
+/**
+ * Implements part of {@link Map} interface
+ * NOTE: as with any hash-based data structure, keys are assumed to be immutable. If you modified keys after inserting them into the map, it will cause the hash table to become invalid. You can fix this by forcing rehashing, but generally - try to avoid changing keys in the first place.
+ *
+ * @template K,V
+ * @extends Map<K,V>
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class HashMap<K, V> {
+    /**
+     * @template K, V
+     * @param {function(K):number} [keyHashFunction] function to compute hash of a given key
+     * @param {function(K,K):boolean} [keyEqualityFunction] function to compute equality between two keys
+     * @param {number} [capacity] initial number of buckets in the hash table
+     * @param {number} [loadFactor] a measure of how full the hash table is allowed to get before its capacity is automatically increased
+     */
+    constructor({ keyHashFunction, keyEqualityFunction, capacity, loadFactor }?: (arg0: K_1) => number);
+    /**
+     * Index pointers to entries array,
+     * number of bins is always power or two
+     * @type {Uint32Array}
+     * @private
+     */
+    private __bins;
+    /**
+     * Note that dead entries are marked as such with a special reserved hash values, so records can be reused for new entries
+     * @type {Array<HashMapEntry<K,V>>}
+     * @private
+     */
+    private __entries;
+    /**
+     * Pointer to the end of allocated entries segment
+     * @type {number}
+     * @private
+     */
+    private __entries_bound;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __entries_start;
+    /**
+     * number of records in the map
+     * @type {number}
+     * @private
+     */
+    private __size;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __bin_count;
+    /**
+     * Always exactly half of the number of bins
+     * @type {number}
+     * @private
+     */
+    private __entries_allocated_count;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __bin_count_power_of_two;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __entries_count_power_of_two;
+    /**
+     * Mask used to map from hash to a bin index
+     * @type {number}
+     * @private
+     */
+    private __bin_count_mask;
+    /**
+     * How full the table can get before number of buckets is increased
+     * @type {number}
+     * @private
+     */
+    private __load_factor;
+    /**
+     * Used to track modifications to prevent concurrent changes during iteration
+     * @private
+     * @type {number}
+     */
+    private __version;
+    /**
+     *
+     * @type {function(K): number}
+     * @readonly
+     * @private
+     */
+    private readonly keyHashFunction;
+    /**
+     *
+     * @type {function(K, K): boolean}
+     * @readonly
+     * @private
+     */
+    private readonly keyEqualityFunction;
+    /**
+     *
+     * @return {number}
+     */
+    get size(): number;
+    /**
+     * Proportion between actual number of records in the map and the bucket count (number of potential hashes)
+     * @returns {number}
+     */
+    getCurrentLoad(): number;
+    /**
+     * Given a hash, compute index of a bucket to which this hash belongs
+     * @param {number} hash
+     * @returns {number}
+     * @private
+     */
+    private compute_bin_index;
+    /**
+     *
+     * @param {K} key
+     * @param {V} value
+     */
+    set(key: K, value: V): void;
+    /**
+     *
+     * @param {K} key
+     * @returns {V|undefined}
+     */
+    get(key: K): V | undefined;
+    /**
+     * If key exists in the map - returns stored value, if it doesn't - invokes `compute` function and stores produced value in the map; then returns that value
+     *
+     * Inspired by Java's implementation
+     * @param {K} key
+     * @param {function(K):V} compute
+     * @param {*} [compute_context]
+     * @return {V}
+     */
+    getOrCompute(key: K, compute: (arg0: K) => V, compute_context?: any): V;
+    /**
+     * Returns existing value if key exists, if it doesn't - sets it and returns what was passed in
+     * @param {K} key
+     * @param {V} value this value will be written at the key location if the key wasn't found in the Map
+     * @return {V}
+     */
+    getOrSet(key: K, value: V): V;
+    /**
+     *
+     * @param {K} key
+     * @returns {boolean}
+     */
+    delete(key: K): boolean;
+    /**
+     *
+     * @param {function(message:string, key:K, value:V)} callback
+     * @param {*} [thisArg]
+     * @returns {boolean}
+     */
+    verifyHashes(callback: any, thisArg?: any): boolean;
+    /**
+     * Rebuild table, useful for when table is resized
+     */
+    rebuild(): void;
+    forEach(callback: any, thisArg: any): void;
+    /**
+     *
+     * @param {K} key
+     * @returns {boolean}
+     */
+    has(key: K): boolean;
+    /**
+     * Remove all data from the Map
+     */
+    clear(): void;
+    /**
+     *
+     * @returns {Iterator<[K,V]>}
+     */
+    entries(): Iterator<[K, V]>;
+    /**
+     *
+     * @returns {Iterator<V>}
+     */
+    values(): Iterator<V>;
+    /**
+     *
+     * @returns {Iterator<K>}
+     */
+    keys(): Iterator<K>;
+    [Symbol.iterator](): Generator<(K | V)[], void, unknown>;
+    #private;
+}
+//# sourceMappingURL=HashMap.d.ts.map