atomic-fns 0.3.1 → 0.3.3-beta

package/core/collections/SortedMap.ts

@@ -0,0 +1,146 @@
+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<K, V> extends Mapping<K, V> {
+  private readonly store: SplayTree<K, V>
+
+  /**
+   * 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?) {
+    super()
+    this.store = new SplayTree(compareFn)
+    if (iterable) {
+      for (const pair of iterable) {
+        this.store.set(pair[0], pair[1] ?? (null as V))
+      }
+    }
+  }
+
+  /**
+   * 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.store.set(key, null as V)
+    return this
+  }
+
+  /**
+   * Returns the value associated with the `key` or `undefined`.
+   * @param {K} key
+   * @returns {?V} The key value or `undefined`.
+   */
+  get(key: K) {
+    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: K, value: V) {
+    return this.store.set(key, value)
+  }
+
+  /**
+   * 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: K) {
+    return this.store.remove(item) !== undefined
+  }
+
+  /**
+   * 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: K) {
+    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: K) {
+    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()
+  }
+}

package/core/collections/SortedSet.d.ts

@@ -0,0 +1,69 @@
+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 Compare}
+ * @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/core/collections/SortedSet.js

@@ -0,0 +1,99 @@
+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 Compare}
+ * @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/core/collections/SortedSet.ts

@@ -0,0 +1,110 @@
+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 Compare}
+ * @see {@link Ordered}
+ * @template K, V
+ */
+export class SortedSet<T> extends Collection {
+  private readonly store: SplayTree<T>
+  /**
+   * 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?) {
+    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: T) {
+    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: T) {
+    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: T) {
+    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: T) {
+    return this.store.contains(value)
+  }
+
+  /**
+   * Returns a new iterator of all values **in-order**.
+   * @returns {Iterable<T>}
+   */
+  values() {
+    return this.store.keys()
+  }
+}

package/core/collections/SortedTree.d.ts

@@ -0,0 +1,103 @@
+import { 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 Compare}
+ * @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.
+     * @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;
+    /**
+     * 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 {Iterable<[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 {Iterable<K>}
+     */
+    keys(): IterableIterator<K>;
+    /**
+     * Returns a new iterator of all values **ordered** by their keys.
+     * @returns {Iterable<V>}
+     */
+    values(): IterableIterator<V>;
+    /**
+     * Returns a new iterator of all key value pairs **ordered** by their keys.
+     * @returns {Iterable<[K, V]>}
+     */
+    entries(): IterableIterator<[K, V]>;
+}

package/core/collections/SortedTree.js

@@ -0,0 +1,141 @@
+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 Compare}
+ * @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.
+     * @param {K} key
+     * @returns {this} Returns the Tree object.
+     */
+    add(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 {Iterable<[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 {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();
+    }
+}