atomic-fns 1.2.0 → 2.0.0

package/dist/collections/Heap.d.ts

@@ -1,69 +0,0 @@
-import type { Comparer } from '../operators/index.js';
-import { compare } from '../operators/index.js';
-import { Collection } from './abc.js';
-export declare class Heap<T> extends Collection {
-    private readonly heap;
-    private readonly compare;
-    private count;
-    /**
-     * Initializes a new Heap instance.
-     *
-     * **Note:** When constructing the heap from an array, it will operate directly on this array. For other iterables, it will create a new array.
-     *
-     * @param {Iterable<T>} [container=[]] The initial values.
-     * @param {Comparer} [cmp=compare] Compare function. Defaults to smaller values first.
-     */
-    constructor(container?: Iterable<T>, cmp?: Comparer);
-    at(n: number): T;
-    get size(): number;
-    clear(): void;
-    /**
-     * Push element into a container in order.
-     * @param item The element to push.
-     */
-    add(item: T): void;
-    /**
-     * Removes the top element.
-     */
-    pop(): T | undefined;
-    /**
-     * Accesses the top element.
-     */
-    top(): T | undefined;
-    /**
-     * Check if element is in heap.
-     * @param item The item want to find.
-     * @return `true` if element exists.
-     */
-    contains(item: T): boolean;
-    /**
-     * Remove specified item from heap.
-     * @param item The item want to remove.
-     * @return `true` if the item was removed.
-     */
-    remove(item: T): boolean;
-    /**
-     * Returns an iterable with all the values in the heap.
-     * @returns {Iterable<T>} The values in the heap.
-     */
-    values(): IterableIterator<T>;
-}
-/**
- * Transform any array into a heap, in-place, in linear time.
- * @param {Array} heap
- * @param {Comparer} [compareFn=compare] Custom compare function
- */
-export declare function heapify(heap: any, compareFn?: typeof compare): void;
-/**
- * Push the value `item` onto the `heap`, maintaining the heap invariant.
- * @param {Array} heap
- * @param {*} item
- * @param {Comparer} [compareFn=compare] Custom compare function
- */
-export declare function heappush<T>(heap: T[], item: T, compareFn?: typeof compare): void;
-/**
- * Pop and return the smallest item from the `heap`, maintaining the heap invariant.
- * @param {Array} heap
- * @param {Comparer} [compareFn=compare] Custom compare function
- */
-export declare function heappop<T>(heap: T[], compareFn?: typeof compare): T;

package/dist/collections/Heap.js

@@ -1,181 +0,0 @@
-import { compare } from '../operators/index.js';
-import { Collection } from './abc.js';
-export class Heap extends Collection {
-    heap;
-    compare;
-    count = 0;
-    /**
-     * Initializes a new Heap instance.
-     *
-     * **Note:** When constructing the heap from an array, it will operate directly on this array. For other iterables, it will create a new array.
-     *
-     * @param {Iterable<T>} [container=[]] The initial values.
-     * @param {Comparer} [cmp=compare] Compare function. Defaults to smaller values first.
-     */
-    constructor(container = [], cmp = compare) {
-        super();
-        this.compare = cmp;
-        if (Array.isArray(container)) {
-            // use the provided array to avoid copying.
-            this.heap = container;
-        }
-        else {
-            this.heap = Array.from(container);
-        }
-        this.count = this.heap.length;
-        const halfLength = this.count >> 1;
-        // Heapify the items
-        for (let parent = (this.count - 1) >> 1; parent >= 0; --parent) {
-            heapifyDown(this.heap, parent, halfLength, this.compare);
-        }
-    }
-    at(n) {
-        return this.heap.at(n);
-    }
-    get size() {
-        return this.count;
-    }
-    clear() {
-        this.count = 0;
-        this.heap.length = 0;
-    }
-    /**
-     * Push element into a container in order.
-     * @param item The element to push.
-     */
-    add(item) {
-        this.heap.push(item);
-        heapifyUp(this.heap, this.count, this.compare);
-        this.count += 1;
-    }
-    /**
-     * Removes the top element.
-     */
-    pop() {
-        if (!this.count)
-            return;
-        const value = this.heap[0];
-        const last = this.heap.pop();
-        this.count -= 1;
-        if (this.count) {
-            this.heap[0] = last;
-            heapifyDown(this.heap, 0, this.count >> 1, this.compare);
-        }
-        return value;
-    }
-    /**
-     * Accesses the top element.
-     */
-    top() {
-        if (!this.count)
-            return;
-        return this.heap[0];
-    }
-    /**
-     * Check if element is in heap.
-     * @param item The item want to find.
-     * @return `true` if element exists.
-     */
-    contains(item) {
-        if (!this.count)
-            return false;
-        return this.heap.includes(item);
-    }
-    /**
-     * Remove specified item from heap.
-     * @param item The item want to remove.
-     * @return `true` if the item was removed.
-     */
-    remove(item) {
-        const index = Number.isNaN(item) ? this.heap.findIndex(Number.isNaN) : this.heap.indexOf(item);
-        if (index < 0)
-            return false;
-        if (index === 0) {
-            this.pop();
-        }
-        else if (index === this.count - 1) {
-            this.heap.pop();
-            this.count -= 1;
-        }
-        else {
-            this.heap.splice(index, 1, this.heap.pop());
-            this.count -= 1;
-            heapifyUp(this.heap, index, this.compare);
-            heapifyDown(this.heap, index, this.count >> 1, this.compare);
-        }
-        return true;
-    }
-    /**
-     * Returns an iterable with all the values in the heap.
-     * @returns {Iterable<T>} The values in the heap.
-     */
-    values() {
-        return this.heap[Symbol.iterator]();
-    }
-}
-function heapifyDown(heap, i, halfLength, compareFn = compare) {
-    const item = heap[i];
-    while (i < halfLength) {
-        let left = (i << 1) | 1;
-        const right = left + 1;
-        let minItem = heap[left];
-        if (right < heap.length && compareFn(minItem, heap[right]) > 0) {
-            left = right;
-            minItem = heap[right];
-        }
-        if (compareFn(minItem, item) >= 0)
-            break;
-        heap[i] = minItem;
-        i = left;
-    }
-    heap[i] = item;
-}
-function heapifyUp(heap, i, compareFn) {
-    const item = heap[i];
-    while (i > 0) {
-        const parent = (i - 1) >> 1;
-        const parentItem = heap[parent];
-        if (compareFn(parentItem, item) <= 0)
-            break;
-        heap[i] = parentItem;
-        i = parent;
-    }
-    heap[i] = item;
-}
-/**
- * Transform any array into a heap, in-place, in linear time.
- * @param {Array} heap
- * @param {Comparer} [compareFn=compare] Custom compare function
- */
-export function heapify(heap, compareFn = compare) {
-    const size = heap.length;
-    const halfLength = size >> 1;
-    for (let parent = (size - 1) >> 1; parent >= 0; --parent) {
-        heapifyDown(heap, parent, halfLength, compareFn);
-    }
-}
-/**
- * Push the value `item` onto the `heap`, maintaining the heap invariant.
- * @param {Array} heap
- * @param {*} item
- * @param {Comparer} [compareFn=compare] Custom compare function
- */
-export function heappush(heap, item, compareFn = compare) {
-    heap.push(item);
-    heapifyUp(heap, heap.length - 1, compareFn);
-}
-/**
- * Pop and return the smallest item from the `heap`, maintaining the heap invariant.
- * @param {Array} heap
- * @param {Comparer} [compareFn=compare] Custom compare function
- */
-export function heappop(heap, compareFn = compare) {
-    const last = heap.pop();
-    if (heap.length) {
-        const item = heap[0];
-        heap[0] = last;
-        heapifyDown(heap, 0, heap.length >> 1, compareFn);
-        return item;
-    }
-    return last;
-}

package/dist/collections/LRUCache.d.ts

@@ -1,83 +0,0 @@
-import { Mapping } from './abc.js';
-/**
- * Implements a Least Recently Used fixed-capacity cache which supports updating, removing, and accessing keys in O(1).
- * @template K, V
- */
-export declare class LRUCache<K = any, V = any> extends Mapping<K, V> {
-    protected items: Map<K, V>;
-    protected maxSize: number;
-    private eviction;
-    /**
-     * Creates a new instance of fixed size.
-     * @param {number} capacity
-     */
-    constructor(capacity?: number);
-    /**
-     * Adds a new element with a specified `key` and `value` to the cache. If an element with the same key already exists, the element will be updated.
-     * @param {K} key
-     * @param {V} value
-     * @returns {this}
-     */
-    set(key: K, value: V): this;
-    /** An idle Map iterator pins every hash table the Map has outgrown, so it cannot live forever. */
-    private wrote;
-    /**
-     * This is just an alias of {@link LRUCache.set}.
-     * @param {K} key The key to add (note value will be `undefined`)
-     * @returns {this}
-     */
-    add(key: K): this;
-    /**
-     * Returns `true` if the specified `key` is found on the cache.
-     * @param {K} key
-     * @returns {boolean}
-     */
-    contains(key: K): boolean;
-    /**
-     * Get the value associated with the specified `key`, or `undefined` it not found.
-     * @param {K} key
-     * @returns {?V} The associated value or `undefined`
-     */
-    get(key: K): V | undefined;
-    /**
-     * Removes all keys and values from the cache.
-     * @returns {this}
-     */
-    clear(): this;
-    /**
-     * Removes a key from the cache and returns `true` if the key existed or `false` otherwise.
-     * @param {K} key
-     * @returns {boolean} `true` if the key existed and was removed
-     */
-    delete(key: K): boolean;
-    /**
-     * Removes the value associated with the specified `key` from the cache and returns the removed value if the key existed.
-     * @param {K} key
-     * @returns {?V} The value if it was removed or `undefined`.
-     */
-    remove(key: K): V | undefined;
-    /**
-     * Returns the total number of elements in the cache.
-     */
-    get size(): number;
-    /**
-     * Returns the total capacity of the cache.
-     */
-    get capacity(): number;
-    /**
-     * Returns an iterable of all the keys in the cache, from least to most recently used.
-     * @returns {IterableIterator<K>}
-     */
-    keys(): IterableIterator<K>;
-    /**
-     * Returns an iterable of all the values in the cache, from least to most recently used.
-     * @returns {IterableIterator<V>}
-     */
-    values(): IterableIterator<V>;
-    /**
-     * Returns an iterable of all the [key, value] pairs in the cache, from least to most recently used.
-     * @returns {IterableIterator<[K, V]>}
-     */
-    entries(): IterableIterator<[K, V]>;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-}

package/dist/collections/LRUCache.js

@@ -1,139 +0,0 @@
-import { Mapping } from './abc.js';
-/**
- * Implements a Least Recently Used fixed-capacity cache which supports updating, removing, and accessing keys in O(1).
- * @template K, V
- */
-export class LRUCache extends Mapping {
-    items = new Map();
-    maxSize;
-    /**
-     * Creates a new instance of fixed size.
-     * @param {number} capacity
-     */
-    constructor(capacity = 1024) {
-        super();
-        this.maxSize = capacity;
-        // Not enumerable, so two caches compare by their items
-        Object.defineProperty(this, 'eviction', { value: { keys: this.items.keys(), writes: 0 } });
-    }
-    /**
-     * Adds a new element with a specified `key` and `value` to the cache. If an element with the same key already exists, the element will be updated.
-     * @param {K} key
-     * @param {V} value
-     * @returns {this}
-     */
-    set(key, value) {
-        // Delete the previous key to update the new insertion order
-        this.items.delete(key);
-        this.items.set(key, value);
-        this.wrote();
-        if (this.items.size > this.maxSize) {
-            // Because ES6 maps remember insertion order, we can evict the first key
-            const lastKey = this.eviction.keys.next().value;
-            this.items.delete(lastKey);
-        }
-        return this;
-    }
-    /** An idle Map iterator pins every hash table the Map has outgrown, so it cannot live forever. */
-    wrote() {
-        const { eviction } = this;
-        if (++eviction.writes >= this.items.size) {
-            eviction.writes = 0;
-            eviction.keys = this.items.keys();
-        }
-    }
-    /**
-     * This is just an alias of {@link LRUCache.set}.
-     * @param {K} key The key to add (note value will be `undefined`)
-     * @returns {this}
-     */
-    add(key) {
-        return this.set(key, undefined);
-    }
-    /**
-     * Returns `true` if the specified `key` is found on the cache.
-     * @param {K} key
-     * @returns {boolean}
-     */
-    contains(key) {
-        return this.items.has(key);
-    }
-    /**
-     * Get the value associated with the specified `key`, or `undefined` it not found.
-     * @param {K} key
-     * @returns {?V} The associated value or `undefined`
-     */
-    get(key) {
-        if (this.items.has(key)) {
-            const value = this.items.get(key);
-            // Delete the previous key to update the new insertion order
-            this.items.delete(key);
-            this.items.set(key, value);
-            this.wrote();
-            return value;
-        }
-    }
-    /**
-     * Removes all keys and values from the cache.
-     * @returns {this}
-     */
-    clear() {
-        this.items.clear();
-        return this;
-    }
-    /**
-     * Removes a key from the cache and returns `true` if the key existed or `false` otherwise.
-     * @param {K} key
-     * @returns {boolean} `true` if the key existed and was removed
-     */
-    delete(key) {
-        return this.items.delete(key);
-    }
-    /**
-     * Removes the value associated with the specified `key` from the cache and returns the removed value if the key existed.
-     * @param {K} key
-     * @returns {?V} The value if it was removed or `undefined`.
-     */
-    remove(key) {
-        const value = this.items.get(key);
-        this.items.delete(key);
-        return value;
-    }
-    /**
-     * Returns the total number of elements in the cache.
-     */
-    get size() {
-        return this.items.size;
-    }
-    /**
-     * Returns the total capacity of the cache.
-     */
-    get capacity() {
-        return this.maxSize;
-    }
-    /**
-     * Returns an iterable of all the keys in the cache, from least to most recently used.
-     * @returns {IterableIterator<K>}
-     */
-    keys() {
-        // A snapshot: get and set re-insert keys, so a live Map iterator would never reach the end
-        return [...this.items.keys()].values();
-    }
-    /**
-     * Returns an iterable of all the values in the cache, from least to most recently used.
-     * @returns {IterableIterator<V>}
-     */
-    values() {
-        return [...this.items.values()].values();
-    }
-    /**
-     * Returns an iterable of all the [key, value] pairs in the cache, from least to most recently used.
-     * @returns {IterableIterator<[K, V]>}
-     */
-    entries() {
-        return [...this.items.entries()].values();
-    }
-    [Symbol.iterator]() {
-        return this.entries();
-    }
-}

package/dist/collections/SortedMap.d.ts

@@ -1,92 +0,0 @@
-import { Mapping } from './abc.js';
-/**
- * A `SortedMap` is a map that holds key value pairs ordered by keys. Any primitive value (and objects that implement {@link Comparable} or {@link Ordered} interfaces) can be used as keys or values.
- * @see {@link operators.compare}
- * @see {@link operators.lt}
- * @template K, V
- */
-export declare class SortedMap<K, V> extends Mapping<K, V> {
-    private readonly store;
-    /**
-     * Creates a new `SortedMap` object.
-     * @param {Iterable<[K, V]>} [iterable] Initialize the map with entries.
-     * @param {Comparer} [compareFn] The `compare` function to sort keys.
-     */
-    constructor(iterable?: Iterable<[K, V]>, compareFn?: any);
-    /**
-     * Adds a new `key` with a `null` value, if the `key` doesn't exist.
-     * @param {K} key
-     * @returns {this} Returns the Map object.
-     */
-    add(key: K): this;
-    /**
-     * Returns the value associated with the `key` or `undefined`.
-     * @param {K} key
-     * @returns {?V} The key value or `undefined`.
-     */
-    get(key: K): V | undefined;
-    /**
-     * Sets the value for the given `key`.
-     * @param {K} key
-     * @param {V} value
-     * @returns {this} Returns the Map object.
-     */
-    set(key: K, value: V): this;
-    /**
-     * Returns the smallest key in the tree.
-     * @returns {?K}
-     */
-    min(): K | undefined;
-    /**
-     * Returns the largest key in the tree.
-     * @returns {?K}
-     */
-    max(): K | undefined;
-    /**
-     * Returns `true` if the `key` existed in the map and was removed.
-     * @param {K} key
-     * @returns {boolean} `true` if key was removed, otherwise `false`.
-     */
-    delete(item: K): boolean;
-    /**
-     * Removes all key/value pairs in the tree.
-     */
-    clear(): void;
-    /**
-     * Returns the total key/value pairs in the tree.
-     * @returns {number}
-     */
-    get size(): number;
-    /**
-     * Check if there are no key/value pairs in the tree.
-     * @returns {boolean} `true` if is empty.
-     */
-    empty(): boolean;
-    /**
-     * Returns `true` if the `key` exists in the map.
-     * @param {K} key
-     * @returns {boolean} `true` if key is found, otherwise `false`.
-     */
-    contains(key: K): boolean;
-    /**
-     * Returns `true` if the `key` exists in the map.
-     * @param {K} key
-     * @returns {boolean} `true` if key is found, otherwise `false`.
-     */
-    has(key: K): boolean;
-    /**
-     * Returns a new iterator of all **ordered** keys in the map.
-     * @returns {Iterable<K>}
-     */
-    keys(): Iterable<K>;
-    /**
-     * Returns a new iterator of all values **ordered** by their keys.
-     * @returns {Iterable<V>}
-     */
-    values(): Iterable<V>;
-    /**
-     * Returns a new iterator of all key value pairs **ordered** by their keys.
-     * @returns {Iterable<[K, V]>}
-     */
-    entries(): Iterable<[K, V]>;
-}

package/dist/collections/SortedMap.js

@@ -1,131 +0,0 @@
-import { Mapping } from './abc.js';
-import { SplayTree } from './SplayTree.js';
-/**
- * A `SortedMap` is a map that holds key value pairs ordered by keys. Any primitive value (and objects that implement {@link Comparable} or {@link Ordered} interfaces) can be used as keys or values.
- * @see {@link operators.compare}
- * @see {@link operators.lt}
- * @template K, V
- */
-export class SortedMap extends Mapping {
-    store;
-    /**
-     * Creates a new `SortedMap` object.
-     * @param {Iterable<[K, V]>} [iterable] Initialize the map with entries.
-     * @param {Comparer} [compareFn] The `compare` function to sort keys.
-     */
-    constructor(iterable, compareFn) {
-        super();
-        this.store = new SplayTree(compareFn);
-        if (iterable) {
-            for (const pair of iterable) {
-                this.store.set(pair[0], pair[1] ?? null);
-            }
-        }
-    }
-    /**
-     * Adds a new `key` with a `null` value, if the `key` doesn't exist.
-     * @param {K} key
-     * @returns {this} Returns the Map object.
-     */
-    add(key) {
-        this.store.add(key);
-        return this;
-    }
-    /**
-     * Returns the value associated with the `key` or `undefined`.
-     * @param {K} key
-     * @returns {?V} The key value or `undefined`.
-     */
-    get(key) {
-        return this.store.get(key);
-    }
-    /**
-     * Sets the value for the given `key`.
-     * @param {K} key
-     * @param {V} value
-     * @returns {this} Returns the Map object.
-     */
-    set(key, value) {
-        this.store.set(key, value);
-        return this;
-    }
-    /**
-     * Returns the smallest key in the tree.
-     * @returns {?K}
-     */
-    min() {
-        return this.store.min();
-    }
-    /**
-     * Returns the largest key in the tree.
-     * @returns {?K}
-     */
-    max() {
-        return this.store.max();
-    }
-    /**
-     * Returns `true` if the `key` existed in the map and was removed.
-     * @param {K} key
-     * @returns {boolean} `true` if key was removed, otherwise `false`.
-     */
-    delete(item) {
-        return this.store.delete(item);
-    }
-    /**
-     * Removes all key/value pairs in the tree.
-     */
-    clear() {
-        return this.store.clear();
-    }
-    /**
-     * Returns the total key/value pairs in the tree.
-     * @returns {number}
-     */
-    get size() {
-        return this.store.size;
-    }
-    /**
-     * Check if there are no key/value pairs in the tree.
-     * @returns {boolean} `true` if is empty.
-     */
-    empty() {
-        return this.store.empty();
-    }
-    /**
-     * Returns `true` if the `key` exists in the map.
-     * @param {K} key
-     * @returns {boolean} `true` if key is found, otherwise `false`.
-     */
-    contains(key) {
-        return this.store.contains(key);
-    }
-    /**
-     * Returns `true` if the `key` exists in the map.
-     * @param {K} key
-     * @returns {boolean} `true` if key is found, otherwise `false`.
-     */
-    has(key) {
-        return this.store.contains(key);
-    }
-    /**
-     * Returns a new iterator of all **ordered** keys in the map.
-     * @returns {Iterable<K>}
-     */
-    keys() {
-        return this.store.keys();
-    }
-    /**
-     * Returns a new iterator of all values **ordered** by their keys.
-     * @returns {Iterable<V>}
-     */
-    values() {
-        return this.store.values();
-    }
-    /**
-     * Returns a new iterator of all key value pairs **ordered** by their keys.
-     * @returns {Iterable<[K, V]>}
-     */
-    entries() {
-        return this.store.entries();
-    }
-}