atomic-fns 1.1.7 → 1.2.0

package/dist/collections/LRUCache.d.ts

@@ -6,6 +6,7 @@ import { Mapping } from './abc.js';
 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
@@ -18,6 +19,8 @@ export declare class LRUCache<K = any, V = any> extends Mapping<K, V> {
      * @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`)
@@ -62,17 +65,17 @@ export declare class LRUCache<K = any, V = any> extends Mapping<K, V> {
      */
     get capacity(): number;
     /**
-     * Returns an iterable of all the keys in the cache, in insertion order.
+     * 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, in insertion order.
+     * 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, in insertion order.
+     * 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]>;

package/dist/collections/LRUCache.js

@@ -13,6 +13,8 @@ export class LRUCache extends Mapping {
     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.
@@ -21,16 +23,25 @@ export class LRUCache extends Mapping {
      * @returns {this}
      */
     set(key, value) {
-        if (this.items.size === this.maxSize) {
-            // Because ES6 maps remember insertion order, we can evict the first key
-            const lastKey = this.items.keys().next().value;
-            this.items.delete(lastKey);
-        }
         // 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`)
@@ -58,6 +69,7 @@ export class LRUCache extends Mapping {
             // Delete the previous key to update the new insertion order
             this.items.delete(key);
             this.items.set(key, value);
+            this.wrote();
             return value;
         }
     }
@@ -100,25 +112,26 @@ export class LRUCache extends Mapping {
         return this.maxSize;
     }
     /**
-     * Returns an iterable of all the keys in the cache, in insertion order.
+     * Returns an iterable of all the keys in the cache, from least to most recently used.
      * @returns {IterableIterator<K>}
      */
     keys() {
-        return this.items.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, in insertion order.
+     * Returns an iterable of all the values in the cache, from least to most recently used.
      * @returns {IterableIterator<V>}
      */
     values() {
-        return this.items.values();
+        return [...this.items.values()].values();
     }
     /**
-     * Returns an iterable of all the [key, value] pairs in the cache, in insertion order.
+     * 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();
+        return [...this.items.entries()].values();
     }
     [Symbol.iterator]() {
         return this.entries();

package/dist/collections/SortedMap.js

@@ -28,7 +28,7 @@ export class SortedMap extends Mapping {
      * @returns {this} Returns the Map object.
      */
     add(key) {
-        this.store.set(key, null);
+        this.store.add(key);
         return this;
     }
     /**
@@ -69,7 +69,7 @@ export class SortedMap extends Mapping {
      * @returns {boolean} `true` if key was removed, otherwise `false`.
      */
     delete(item) {
-        return this.store.remove(item) !== undefined;
+        return this.store.delete(item);
     }
     /**
      * Removes all key/value pairs in the tree.

package/dist/collections/SortedTree.d.ts

@@ -1,4 +1,4 @@
-import { Comparer } from '../operators/index.js';
+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.
@@ -15,7 +15,7 @@ export declare class SortedTree<K, V> extends Mapping<K, V> {
      */
     constructor(iterable?: Iterable<[K, V]>, compareFn?: Comparer);
     /**
-     * Adds a new `key` with a `null` value.
+     * Adds a new `key` with a `null` value, if the `key` doesn't exist.
      * @param {K} key
      * @returns {this} Returns the Tree object.
      */

package/dist/collections/SortedTree.js

@@ -18,12 +18,13 @@ export class SortedTree extends Mapping {
         this.store = new BTree(iterable, compareFn);
     }
     /**
-     * Adds a new `key` with a `null` value.
+     * 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) {
-        this.store.set(key, null);
+        if (!this.store.contains(key))
+            this.store.set(key, null);
         return this;
     }
     /**

package/dist/collections/SplayTree.d.ts

@@ -1,4 +1,4 @@
-import { Comparer } from '../operators/index.js';
+import { type Comparer } from '../operators/index.js';
 import { Mapping } from './abc.js';
 /**
  * Base SplayTree node class.
@@ -41,13 +41,15 @@ export declare class SplayTree<K, V = any> extends Mapping<K, V> {
      * @returns {?V} The value for the key or `undefined`.
      */
     get(key: K): V | undefined;
+    private findNode;
     /**
-     * Inserts the `key` and `value` in the tree if the `key` does not exist.
+     * 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.
@@ -83,7 +85,7 @@ export declare class SplayTree<K, V = any> extends Mapping<K, V> {
      * @returns `true` if found.
      */
     contains(key: K): boolean;
-    /** Alias of remove but just returns `true` instead of the deleted value. */
+    /** Alias of remove but returns `true` if the key was found instead of the deleted value. */
     delete(key: K): boolean;
     clear(): void;
     /**
@@ -97,8 +99,8 @@ export declare class SplayTree<K, V = any> extends Mapping<K, V> {
      */
     entries(): Iterable<[K, V]>;
     /**
-     * Returns an ordered iterable of all the keys and values in the tree.
-     * @returns {Iterable<V>} A iterable of `[key, value]` pairs sorted by key.
+     * Returns an ordered iterable of all the values in the tree.
+     * @returns {Iterable<V>} An iterable of values sorted by key.
      */
     values(): Iterable<V>;
 }

package/dist/collections/SplayTree.js

@@ -1,4 +1,4 @@
-import { compare, eq } from '../operators/index.js';
+import { compare } from '../operators/index.js';
 import { Mapping } from './abc.js';
 /**
  * Base SplayTree node class.
@@ -14,22 +14,29 @@ class Node {
         this.value = value;
     }
     get height() {
-        if (this.left && this.right)
-            return 1 + Math.max(this.right.height, this.left.height);
-        if (this.right)
-            return 1 + this.right.height;
-        if (this.left)
-            return 1 + this.left.height;
-        return 0;
+        let height = -1;
+        let level = [this];
+        while (level.length) {
+            height += 1;
+            level = level.flatMap((node) => [node.left, node.right].filter(Boolean));
+        }
+        return height;
     }
 }
-// In-order traversal of a tree
-function* traverse(node) {
-    while (node) {
-        yield* traverse(node.left);
-        yield node;
+// In-order snapshot of a tree: reads splay it, so a live walk would lose its place
+function traverse(node) {
+    const nodes = [];
+    const stack = [];
+    while (node || stack.length) {
+        while (node) {
+            stack.push(node);
+            node = node.left;
+        }
+        node = stack.pop();
+        nodes.push(node);
         node = node.right;
     }
+    return nodes;
 }
 /**
  * A splay tree is a *self-balancing binary* search tree with the additional property that recently accessed elements are quick to access again.
@@ -75,6 +82,9 @@ export class SplayTree extends Mapping {
      * @returns {?V} The value for the key or `undefined`.
      */
     get(key) {
+        return this.findNode(key)?.value;
+    }
+    findNode(key) {
         if (!this.root)
             return;
         // Note: deterministic splaying (always moves key to front):
@@ -86,7 +96,7 @@ export class SplayTree extends Mapping {
         if (Math.random() <= this.randSplay) {
             this.splay(key);
             if (this.cmp(key, this.root.key) === 0)
-                return this.root.value;
+                return this.root;
             else
                 return undefined;
         }
@@ -95,7 +105,7 @@ export class SplayTree extends Mapping {
         while (current) {
             const rank = this.cmp(key, current.key);
             if (rank === 0)
-                return current.value;
+                return current;
             if (rank < 0)
                 current = current.left;
             else
@@ -103,12 +113,15 @@ export class SplayTree extends Mapping {
         }
     }
     /**
-     * Inserts the `key` and `value` in the tree if the `key` does not exist.
+     * 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, value) {
+        this.insert(key, value, true);
+    }
+    insert(key, value, overwrite) {
         if (!this.root) {
             this.root = new Node(key, value);
             this.count += 1;
@@ -120,7 +133,8 @@ export class SplayTree extends Mapping {
         const rank = this.cmp(key, this.root.key);
         if (rank === 0) {
             // Update the value
-            this.root.value = value;
+            if (overwrite)
+                this.root.value = value;
             return;
         }
         const node = new Node(key, value);
@@ -147,7 +161,7 @@ export class SplayTree extends Mapping {
             return;
         }
         this.splay(key);
-        if (!eq(key, this.root.key)) {
+        if (this.cmp(key, this.root.key) !== 0) {
             return;
         }
         const removed = this.root;
@@ -229,7 +243,6 @@ export class SplayTree extends Mapping {
         if (!this.root)
             return;
         let stub, left, right;
-        // eslint-disable-next-line
         stub = left = right = new Node(null, null);
         let root = this.root;
         while (true) {
@@ -284,7 +297,7 @@ export class SplayTree extends Mapping {
         this.root = root;
     }
     add(key) {
-        return this.set(key, null);
+        this.insert(key, null, false);
     }
     /**
      * Returns `true` if the given key is in the tree.
@@ -292,13 +305,13 @@ export class SplayTree extends Mapping {
      * @returns `true` if found.
      */
     contains(key) {
-        return this.get(key) !== undefined;
+        return this.findNode(key) !== undefined;
     }
-    /** Alias of remove but just returns `true` instead of the deleted value. */
+    /** Alias of remove but returns `true` if the key was found instead of the deleted value. */
     delete(key) {
-        // since remove throws, this will throw too
+        const size = this.count;
         this.remove(key);
-        return true;
+        return this.count < size;
     }
     clear() {
         if (!this.root)
@@ -327,8 +340,8 @@ export class SplayTree extends Mapping {
         }
     }
     /**
-     * Returns an ordered iterable of all the keys and values in the tree.
-     * @returns {Iterable<V>} A iterable of `[key, value]` pairs sorted by key.
+     * Returns an ordered iterable of all the values in the tree.
+     * @returns {Iterable<V>} An iterable of values sorted by key.
      */
     *values() {
         for (const node of traverse(this.root)) {

package/dist/collections/Trie.d.ts

@@ -23,7 +23,7 @@ export declare class Trie extends Collection {
     /**
      * Generates all results that start with the given string.
      * @param word A prefix string
-     * @param {number} [limit=20] The number of results to return.
+     * @param {number} [limit] The number of results to return. Defaults to every result.
      */
     matches: (word: string, limit?: number) => Generator<string>;
     /**

package/dist/collections/Trie.js

@@ -1,11 +1,14 @@
+import { itake } from '../itertools/index.js';
 import { Collection } from './abc.js';
-function* traverse(node, path, total = 20, count = 0) {
-    if (node.isWord) {
-        count++;
-        yield path;
-    }
-    for (const key of Object.keys(node)) {
-        yield* traverse(node[key], path + key, total, count);
+function* traverse(root, prefix) {
+    const stack = [[root, prefix]];
+    while (stack.length) {
+        const [node, path] = stack.pop();
+        if (node.isWord)
+            yield path;
+        for (const key of Object.keys(node).reverse()) {
+            stack.push([node[key], path + key]);
+        }
     }
 }
 /**
@@ -14,7 +17,7 @@ function* traverse(node, path, total = 20, count = 0) {
  * @see {@link https://en.wikipedia.org/wiki/Trie Trie}
  */
 export class Trie extends Collection {
-    root = {};
+    root = Object.create(null);
     count = 0;
     constructor(words) {
         super();
@@ -33,16 +36,17 @@ export class Trie extends Collection {
         for (let i = 0; i < word.length; i++) {
             const c = word[i];
             if (!current[c])
-                current[c] = {};
+                current[c] = Object.create(null);
             current = current[c];
         }
+        if (!current.isWord)
+            this.count++;
         // Set as end of the word
         Object.defineProperty(current, 'isWord', {
             value: true,
             enumerable: false,
             writable: true
         });
-        this.count++;
         return this;
     }
     /**
@@ -51,15 +55,12 @@ export class Trie extends Collection {
      * @returns {boolean} Returns `true` if the string was found and removed.
      */
     remove(word) {
-        for (let i = 0, node = this.root; i < word.length && node; i++) {
-            node = node[word[i]];
-            if (i === word.length - 1 && node.isWord) {
-                node.isWord = false;
-                this.count--;
-                return true;
-            }
-        }
-        return false;
+        const node = this.findNode(word);
+        if (!node?.isWord)
+            return false;
+        node.isWord = false;
+        this.count--;
+        return true;
     }
     findNode(word) {
         let node = this.root;
@@ -72,13 +73,12 @@ export class Trie extends Collection {
     /**
      * Generates all results that start with the given string.
      * @param word A prefix string
-     * @param {number} [limit=20] The number of results to return.
+     * @param {number} [limit] The number of results to return. Defaults to every result.
      */
-    matches = function* (word, limit = 20) {
+    matches = function* (word, limit) {
         const node = this.findNode(word);
-        if (node) {
-            yield* traverse(node, word, limit);
-        }
+        if (node)
+            yield* itake(limit ?? Infinity, traverse(node, word));
     };
     /**
      * Returns `true` if the given string is found in the tree.
@@ -86,13 +86,13 @@ export class Trie extends Collection {
      */
     contains(word) {
         const node = this.findNode(word);
-        return node?.isWord;
+        return !!node?.isWord;
     }
     /**
      * Removes all strings from the tree.
      */
     clear() {
-        this.root = {};
+        this.root = Object.create(null);
         this.count = 0;
     }
     /**

package/dist/collections/deque.d.ts

@@ -1,4 +1,4 @@
-import { Iteratee } from '../types.js';
+import type { Iteratee } from '../types.js';
 import { Sequence } from './abc.js';
 /**
  * Fixed capacity double-ended queue implemented as ring deque.

package/dist/collections/deque.js

@@ -1,7 +1,14 @@
 import { KeyError, ValueError } from '../globals/index.js';
-import { IterableIterator } from '../itertools/index.js';
 import { eq } from '../operators/index.js';
 import { Sequence } from './abc.js';
+function IterableIterator(next) {
+    return {
+        next,
+        [Symbol.iterator]() {
+            return this;
+        }
+    };
+}
 /**
  * Fixed capacity double-ended queue implemented as ring deque.
  * @template T
@@ -23,7 +30,9 @@ export class Deque extends Sequence {
             throw new ValueError(`Deque capacity should be a positive integer.`);
         this.ArrayConstructor = arrType.constructor;
         this.capacity = capacity;
-        this.items = new this.ArrayConstructor(arrType.length || this.capacity);
+        // A typed array cannot grow, so it takes the whole capacity up front
+        const length = ArrayBuffer.isView(arrType) ? capacity : arrType.length || capacity;
+        this.items = new this.ArrayConstructor(length);
         this.clear();
         if (arrType.length) {
             for (const item of arrType) {
@@ -125,14 +134,11 @@ export class Deque extends Sequence {
      * @returns {?T} The element if exists
      */
     get(index) {
-        if (this.count === 0)
-            return;
-        index = this.start + index;
         if (index < 0)
             index += this.count;
-        if (index > this.capacity)
-            index -= this.capacity;
-        return this.items[index];
+        if (index < 0 || index >= this.count)
+            return;
+        return this.items[(this.start + index) % this.capacity];
     }
     /**
      * Update the element at a given `index`.
@@ -141,9 +147,10 @@ export class Deque extends Sequence {
     set(index, value) {
         if (index < 0)
             index += this.count;
-        if (index > this.count)
+        if (index < 0 || index >= this.count) {
             throw new KeyError(`Invalid index: ${index} not in Deque.`);
-        this.items[index] = value;
+        }
+        this.items[(this.start + index) % this.capacity] = value;
     }
     /**
      * Check if a given element is in the deque.

package/dist/collections/frozenset.js

@@ -8,7 +8,10 @@
  */
 export class FrozenSet extends Set {
     constructor(iterable) {
-        super(iterable);
+        super();
+        // The Set constructor would call the no-op add below and drop every item
+        for (const item of iterable ?? [])
+            super.add(item);
         return this.freeze();
     }
     /** @private */