atomic-fns 1.2.0 → 2.0.0

package/dist/collections/SortedSet.d.ts

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

package/dist/collections/SortedSet.js

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

package/dist/collections/SortedTree.d.ts

@@ -1,103 +0,0 @@
-import type { Comparer } from '../operators/index.js';
-import { Mapping } from './abc.js';
-/**
- * A `SortedTree` 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 Comparable}
- * @see {@link Ordered}
- * @template K, V
- */
-export declare class SortedTree<K, V> extends Mapping<K, V> {
-    private readonly store;
-    /**
-     * Creates a new `SortedTree` object.
-     * @param {Iterable<[K, V]>} [iterable] Initialize the tree with entries.
-     * @param {Comparer} [compareFn] The `compare` function to sort keys.
-     */
-    constructor(iterable?: Iterable<[K, V]>, compareFn?: Comparer);
-    /**
-     * Adds a new `key` with a `null` value, if the `key` doesn't exist.
-     * @param {K} key
-     * @returns {this} Returns the Tree 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 Tree 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 tree and was removed.
-     * @param {K} key
-     * @returns {boolean} `true` if key was removed, otherwise `false`.
-     */
-    delete(key: K): boolean;
-    /**
-     * Removes all key/value pairs in the tree.
-     */
-    clear(): void;
-    /**
-     * Freezes the tree which prevents adding, updating or removing any keys.
-     * @returns {this}
-     */
-    freeze(): this;
-    /**
-     * Returns a new iterator of `[K, V]` pairs in reverse order of keys.
-     * @returns {IterableIterator<[K, V]>}
-     */
-    reversed(): IterableIterator<[K, V]>;
-    /**
-     * 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 tree.
-     * @param {K} key
-     * @returns {boolean} `true` if key is found, otherwise `false`.
-     */
-    contains(key: K): boolean;
-    /**
-     * Returns `true` if the `key` exists in the tree.
-     * @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 tree.
-     * @returns {IterableIterator<K>}
-     */
-    keys(): IterableIterator<K>;
-    /**
-     * Returns a new iterator of all values **ordered** by their keys.
-     * @returns {IterableIterator<V>}
-     */
-    values(): IterableIterator<V>;
-    /**
-     * Returns a new iterator of all key value pairs **ordered** by their keys.
-     * @returns {IterableIterator<[K, V]>}
-     */
-    entries(): IterableIterator<[K, V]>;
-}

package/dist/collections/SortedTree.js

@@ -1,142 +0,0 @@
-import { Mapping } from './abc.js';
-import { BTree } from './BTree.js';
-/**
- * A `SortedTree` 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 Comparable}
- * @see {@link Ordered}
- * @template K, V
- */
-export class SortedTree extends Mapping {
-    store;
-    /**
-     * Creates a new `SortedTree` object.
-     * @param {Iterable<[K, V]>} [iterable] Initialize the tree with entries.
-     * @param {Comparer} [compareFn] The `compare` function to sort keys.
-     */
-    constructor(iterable, compareFn) {
-        super();
-        this.store = new BTree(iterable, compareFn);
-    }
-    /**
-     * Adds a new `key` with a `null` value, if the `key` doesn't exist.
-     * @param {K} key
-     * @returns {this} Returns the Tree object.
-     */
-    add(key) {
-        if (!this.store.contains(key))
-            this.store.set(key, null);
-        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 Tree object.
-     */
-    set(key, value) {
-        this.store.set(key, value);
-        return this;
-    }
-    /**
-     * Returns the smallest key in the tree.
-     * @returns {?K}
-     */
-    min() {
-        return this.store.minKey();
-    }
-    /**
-     * Returns the largest key in the tree.
-     * @returns {?K}
-     */
-    max() {
-        return this.store.maxKey();
-    }
-    /**
-     * Returns `true` if the `key` existed in the tree and was removed.
-     * @param {K} key
-     * @returns {boolean} `true` if key was removed, otherwise `false`.
-     */
-    delete(key) {
-        return this.store.remove(key);
-    }
-    /**
-     * Removes all key/value pairs in the tree.
-     */
-    clear() {
-        return this.store.clear();
-    }
-    /**
-     * Freezes the tree which prevents adding, updating or removing any keys.
-     * @returns {this}
-     */
-    freeze() {
-        this.store.freeze();
-        return this;
-    }
-    /**
-     * Returns a new iterator of `[K, V]` pairs in reverse order of keys.
-     * @returns {IterableIterator<[K, V]>}
-     */
-    reversed() {
-        return this.store.reversed();
-    }
-    /**
-     * 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 tree.
-     * @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 tree.
-     * @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 tree.
-     * @returns {IterableIterator<K>}
-     */
-    keys() {
-        return this.store.keys();
-    }
-    /**
-     * Returns a new iterator of all values **ordered** by their keys.
-     * @returns {IterableIterator<V>}
-     */
-    values() {
-        return this.store.values();
-    }
-    /**
-     * Returns a new iterator of all key value pairs **ordered** by their keys.
-     * @returns {IterableIterator<[K, V]>}
-     */
-    entries() {
-        return this.store.entries();
-    }
-}

package/dist/collections/SplayTree.d.ts

@@ -1,107 +0,0 @@
-import { type Comparer } from '../operators/index.js';
-import { Mapping } from './abc.js';
-/**
- * Base SplayTree node class.
- * @private
- */
-declare class Node<K = any, V = any> {
-    key: K;
-    value: V;
-    left?: Node<K, V>;
-    right?: Node<K, V>;
-    constructor(key: K, value: V);
-    get height(): number;
-}
-/**
- * A splay tree is a *self-balancing binary* search tree with the additional property that recently accessed elements are quick to access again.
- * Insertion, look-up and removal in O(log n) *amortized* time.
- * For many patterns of non-random operations splay trees can take better than logarithmic time, without requiring advance knowledge of the pattern.
- * @see {@link https://en.wikipedia.org/wiki/Splay_tree Splay tree}
- * @see {@link https://web.archive.org/web/20220930173835/http://www14.in.tum.de/personen/albers/papers/ipl02.pdf Randomized Splay Trees}
- * @template K, V
- */
-export declare class SplayTree<K, V = any> extends Mapping<K, V> {
-    protected root?: Node<K, V>;
-    protected cmp: Comparer;
-    protected randSplay: number;
-    protected count: number;
-    /**
-     * Create a new randomized Splay Tree
-     * @param compareFn
-     * @param p When an element is accessed, with probability `p` splay the tree. With probability `1 - p`, leave the tree as it is.
-     */
-    constructor(compareFn?: any, p?: number);
-    top(): K | undefined;
-    get size(): number;
-    empty(): boolean;
-    get height(): number;
-    /**
-     *  Returns the value for `key` or `undefined` if the key is not found.
-     * @param key The key to find.
-     * @returns {?V} The value for the key or `undefined`.
-     */
-    get(key: K): V | undefined;
-    private findNode;
-    /**
-     * Inserts the `key` and `value` in the tree, or updates the value if the `key` exists.
-     * @param {K} key A key which can be any comparable value
-     * @param {V} value A value associated with the key
-     * @returns
-     */
-    set(key: K, value: V): void;
-    private insert;
-    /**
-     * Removes a specified key if it exists in the tree. The removed value is returned or `undefined` if not found.
-     * @param {K} key The key to remove.
-     * @returns {?V} The removed value associated with `key`.
-     */
-    remove(key: K): V | undefined;
-    /**
-     * Returns the minimum key in the tree or subtree.
-     * @returns The minimum key.
-     */
-    min(root?: Node<K, V>): K | undefined;
-    /**
-     * Returns the maximum key in the tree or subtree.
-     * @returns The maximum key.
-     */
-    max(root?: Node<K, V>): K | undefined;
-    /**
-     * Returns the largest key that is less than a given key.
-     * @param key The given key
-     * @returns {?K} The largest key found or `undefined`.
-     */
-    lowerBound(key: any): K | undefined;
-    /**
-     * This is the simplified top-down splaying method proposed by Sleator and Tarjan in {@link https://doi.org/10.1145%2F3828.3835 Self-Adjusting Binary Search Trees}.
-     * @param key
-     * @see {@link https://doi.org/10.1145%2F3828.3835 Self-Adjusting Binary Search Trees}
-     */
-    splay(key: any): void;
-    add(key: K): void;
-    /**
-     * Returns `true` if the given key is in the tree.
-     * @param {K} key The key to find.
-     * @returns `true` if found.
-     */
-    contains(key: K): boolean;
-    /** Alias of remove but returns `true` if the key was found instead of the deleted value. */
-    delete(key: K): boolean;
-    clear(): void;
-    /**
-     * Returns an ordered iterable of all the keys in the tree.
-     * @returns {Iterable<K>} An iterable of keys in-order.
-     */
-    keys(): Iterable<K>;
-    /**
-     * Returns an ordered iterable of all the keys and values in the tree.
-     * @returns {Iterable<[K,V]>} A iterable of `[key, value]` pairs sorted by key.
-     */
-    entries(): Iterable<[K, V]>;
-    /**
-     * Returns an ordered iterable of all the values in the tree.
-     * @returns {Iterable<V>} An iterable of values sorted by key.
-     */
-    values(): Iterable<V>;
-}
-export {};