atomic-fns 1.1.6 → 1.2.0

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.
@@ -44,28 +44,28 @@ export declare class Deque<T = any> extends Sequence<T> {
      * Removes and returns the element at the end of the deque.
      * @returns {?T} Returns the popped item.
      */
-    pop(): T;
+    pop(): T | undefined;
     /**
      * Alias of {@link Deque.pop}
      * @returns {?T} Returns the popped item.
      */
-    remove(): T;
+    remove(): T | undefined;
     /**
      * Removes and returns the element at the beginning of the deque.
      * @returns {?T} Returns the removed deque element.
      */
-    popleft(): T;
+    popleft(): T | undefined;
     /**
      * Returns the element at the beginning of the deque.
      * @returns {?T} The element if exists
      */
-    first(): T;
+    first(): T | undefined;
     /**
      * Returns the element at a specified index position in the deque.
      * @param {number} index The given index
      * @returns {?T} The element if exists
      */
-    get(index: any): T;
+    get(index: any): T | undefined;
     /**
      * Update the element at a given `index`.
      * @param {number} index The given index
@@ -82,7 +82,7 @@ export declare class Deque<T = any> extends Sequence<T> {
      * @param {Iteratee<T>} iteratee A function that will be invoked per element
      * @returns {?T} The element if exists
      */
-    find(iteratee: Iteratee<T>): T;
+    find(iteratee: Iteratee<T>): T | undefined;
     /**
      * Calls `iteratee` function for every element in the deque.
      * @param {Iteratee<T>} iteratee A function that will be invoked per element
@@ -92,12 +92,12 @@ export declare class Deque<T = any> extends Sequence<T> {
      * Returns a new array with all the elements in reverse order.
      * @returns {Array<T>} The elements reversed
      */
-    reversed(): any;
+    reversed(): T[];
     /**
      * Returns a new array with all the elements in the order they were added to the deque.
      * @returns {Array<T>} The elements array
      */
-    toArray(): any;
+    toArray(): T[];
     /**
      * Returns an iterator over the deque's values.
      * @returns {Iterator}
@@ -111,7 +111,7 @@ export declare class Deque<T = any> extends Sequence<T> {
      * Creates an iterator of `[index, value]` pairs for all elements in the deque.
      * @returns {Iterator}
      */
-    entries(): Iterable<[number, T]> & Iterator<[number, T], any, undefined>;
+    entries(): Iterable<[number, T]>;
     [Symbol.iterator](): Iterable<T>;
-    inspect(): any;
+    inspect(): T[];
 }

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 */

package/dist/collections/index.d.ts

@@ -4,7 +4,7 @@
  * @module collections
  */
 import { compare } from '../operators/index.js';
-import { Iteratee } from '../types';
+import type { Iteratee } from '../types.js';
 export * from './abc.js';
 export * from './BTree.js';
 export * from './deque.js';
@@ -38,7 +38,6 @@ export declare function compact<T>(arr: T): Partial<T>;
 count([6.1, 4.2, 6.3], Math.floor);
 // { '4': 1, '6': 2 }
 
-// property iteratee shorthand.
 count(['one', 'two', 'three'], x => x.length);
 // { '3': 2, '5': 1 }
 ```
@@ -86,7 +85,7 @@ let users = [
   { 'user': 'pebbles', 'age': 1,  'active': true }
 ]
 
-find(users, (o) => o.age < 40)
+find(users, o => o.age < 40)
 // object for 'barney'
 
 // The shape iteratee shorthand.
@@ -142,16 +141,18 @@ export declare function matches(shape: any): (obj: any) => boolean;
 forEach([1, 2], (value) => {
   console.log(value)
 })
-// Logs `1` then `2`.
+// 1
+// 2
 
 forEach({ 'a': 1, 'b': 2 }, (value, key) => {
   console.log(key)
 })
-// Logs 'a' then 'b' (iteration order is not guaranteed).
+// 'a'
+// 'b'
 ```
  * @param {Array|Object} collection The collection to iterate over.
  * @param {Iteratee} fn The function invoked per iteration.
- * @returns {*} Returns `collection`.
+ * @returns {void}
  * @see {@link forEachRight}
  * @see {@link filter}
  * @see {@link map}
@@ -162,8 +163,8 @@ export declare function forEach<T>(collection: Object, fn: Iteratee<T>): void;
  * This method is like {@link find} except that it iterates from right to left.
  * @example
 ```js
-findLast([1, 2, 3, 4], (n) => n % 2 === 1)
-//  => 3
+findLast([1, 2, 3, 4], n => n % 2 === 1)
+//  3
 ```
  * @param {Array} arr The collection to iterate over.
  * @param {Function} fn The function invoked per iteration.
@@ -179,14 +180,13 @@ export declare function findLast<T>(arr: Object, fn: Object): T | undefined;
 
  * @example
 ```js
-forEachRight([1, 2], (value) => {
-  console.log(value)
-})
-// Logs `2` then `1`.
+forEachRight([1, 2], console.log)
+// 2
+// 1
 ```
  * @param {Array|Object} collection The collection to iterate over.
  * @param {Iteratee} fn The function invoked per iteration.
- * @returns {*} Returns `collection`.
+ * @returns {void}
  * @see {@link forEach}
  * @see {@link filter}
  * @see {@link map}
@@ -276,7 +276,7 @@ let object = { a: 1, b: '2', c: 3 }
 pick(object, ['a', 'c'])
 // { a: 1, c: 3 }
 
-pick(object, (x) => isNumber(x))
+pick(object, x => isNumber(x))
 // { a: 1, c: 3 }
 ```
  *
@@ -285,7 +285,7 @@ pick(object, (x) => isNumber(x))
 export declare function pick<T>(obj: T, paths: Iteratee): Partial<T>;
 export declare function pick<T>(obj: T, paths: PropertyKey[]): Partial<T>;
 /**
- * The opposite of {@link pick} - this method creates an object composed of the own and inherited enumerable property paths of `object` that are not omitted.
+ * The opposite of {@link pick} - this method creates an object composed of the own enumerable properties of `object` that are not omitted.
  * @example
 ```js
 let object = { 'a': 1, 'b': '2', 'c': 3 }
@@ -293,7 +293,7 @@ let object = { 'a': 1, 'b': '2', 'c': 3 }
 omit(object, ['a', 'c'])
 // { 'b': '2' }
 
-omit(object, (x) => isNumber(x))
+omit(object, x => isNumber(x))
 // { 'b': '2' }
 ```
  * @param {Object} obj The source object.
@@ -317,7 +317,7 @@ let users = [
   { 'user': 'pebbles', 'active': true }
 ]
 
-findIndex(users, (o) => o.user == 'barney')
+findIndex(users, o => o.user == 'barney')
 // 0
 
 // The `shape` iteratee shorthand.
@@ -368,7 +368,7 @@ let users = [
   { 'user': 'pebbles', 'active': false }
 ]
 
-findLastIndex(users, (o) => o.user == 'pebbles')
+findLastIndex(users, o => o.user == 'pebbles')
 // 2
 
 // The `shape` iteratee shorthand.
@@ -409,27 +409,9 @@ export declare function lastIndexOf<T>(obj: T[], value: T, start?: number): numb
  * @param {*} value
  * @param {boolean} [deep=false]
  * @return The clone value
- * @see {@link cloneArray}
- * @see {@link cloneTypedArray}
  */
 export declare function clone<T>(value: T, deep?: boolean): T;
 export declare function clone<T>(value: T[], deep?: boolean): T[];
-/**
- * Clones an array. If `deep` is `false` (default) the clone will be shallow. Otherwise {@link https://developer.mozilla.org/en-US/docs/Web/API/structuredClone structuredClone} is used.
- * @param arr The array to clone
- * @param [deep=false] Creates a deep clone using `structuredClone` if true.
- * @returns The new array
- * @see {@link clone}
- */
-export declare function cloneArray<T>(arr: T[], deep?: boolean): T[];
-/**
- * Clones a typed array. If `deep` is `false` (default) the clone will be shallow. Otherwise {@link https://developer.mozilla.org/en-US/docs/Web/API/structuredClone structuredClone} is used.
- * @param arr The array to clone
- * @param [deep=false] Creates a deep clone using `structuredClone` if true.
- * @returns The new array
- * @see {@link clone}
- */
-export declare function cloneTypedArray(typedArray: any, isDeep?: boolean): any;
 /**
  * Creates a duplicate-free version of an array, using a `Set` for equality comparisons, in which only the first occurrence of each element is kept. The order of result values is not guaranteed.
  * @param arr The array containing duplicated elements
@@ -455,7 +437,7 @@ export declare function uniq<T>(arr: Iterable<T>, fn?: PropertyKey): T[];
  * @returns Returns the new duplicate free array
  * @example
 ```js
-uniq([2, 1, 2])
+sortedUniq([2, 1, 2])
 // [1, 2]
 ```
  * @see {@link uniq}
@@ -463,7 +445,7 @@ uniq([2, 1, 2])
 export declare function sortedUniq<T>(arr: Iterable<T>, fn?: Iteratee<T>): T[];
 export declare function sortedUniq<T>(arr: Iterable<T>, fn?: PropertyKey): T[];
 /**
- * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. Source properties that resolve to `undefined` are skipped if a destination value exists. Array and plain object properties are merged recursively. Other objects and value types are overridden by assignment. Source objects are applied from left to right. Subsequent sources overwrite property assignments of previous sources.
+ * Recursively merges own enumerable string keyed properties of source objects into the destination object. Source properties that resolve to `undefined` are skipped if a destination value exists. Array and plain object properties are merged recursively. Other objects and value types are overridden by assignment. Source objects are applied from left to right. Subsequent sources overwrite property assignments of previous sources.
  *
  * Note: this method mutates `object`
  *
@@ -512,7 +494,7 @@ export declare function defaults(object: Object, ...sources: Object[]): Object;
  * @see {@link union}
  * @see {@link intersection}
  */
-export declare function difference<T>(...args: Array<Iterable<T>>): Generator<T, void, unknown>;
+export declare function difference<T>(...args: Array<Iterable<T>>): Generator<T>;
 /**
  * Creates a generator of unique values that are included in all given arrays.
  * @param args The arrays to inspect
@@ -524,7 +506,7 @@ export declare function difference<T>(...args: Array<Iterable<T>>): Generator<T,
 * @see {@link difference}
  * @see {@link union}
  */
-export declare function intersection<T>(...args: Array<Iterable<T>>): Generator<T, void, unknown>;
+export declare function intersection<T>(...args: Array<Iterable<T>>): Generator<T>;
 /**
  * Creates a generator of unique values from all given arrays using `Set` for equality comparisons.
  * @param args The arrays to perform union on.
@@ -536,12 +518,12 @@ export declare function intersection<T>(...args: Array<Iterable<T>>): Generator<
  * @see {@link difference}
  * @see {@link intersection}
  */
-export declare function union<T>(...args: Array<Iterable<T>>): Generator<T, void, unknown>;
+export declare function union<T>(...args: Array<Iterable<T>>): Generator<T>;
 /**
  * Creates an object composed of keys generated from the results of running each element of `arr` thru `func`. The order of grouped values is determined by the order they occur in `arr`. The corresponding value of each key is an array of elements responsible for generating the key.
  *
  * @param arr The collection to iterate over.
- * @param [func=id] The iteratee to transform keys.
+ * @param [func=identity] The iteratee to transform keys.
  * @returns Returns the aggregated object.
  *
  * @example
@@ -562,14 +544,14 @@ export declare function groupBy<T>(arr: Object, fn: PropertyKey): Record<Propert
  * Similar to {@link groupBy} but it returns a {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map Map} object with the results.
  *
  * @param arr The collection to iterate over.
- * @param {Function | PropertyKey} [func=id] The iteratee to transform keys.
+ * @param {Function | PropertyKey} [func=identity] The iteratee to transform keys.
  * @returns {Map} Returns the aggregated map object.
  * @template K, V
  *
  * @example
 ```js
 groupByMap([6.1, 4.2, 6.3], Math.floor)
-// Map { 4: [4.2], 6: [6.1, 6.3] }
+// Map { 6: [6.1, 6.3], 4: [4.2] }
 
 // The `property` iteratee shorthand.
 groupByMap(['one', 'two', 'three'], 'length')
@@ -591,8 +573,8 @@ export declare function remove<T>(arr: T[], func: T[]): T[];
 export declare function remove<T>(arr: T[], func: Iteratee<T>): T[];
 /**
  * Returns the index of `x` in a **sorted** array if found, in `O(log n)` using binary search.
- * If the element is not found, returns a negative integer.
- * @param arr The array to sort
+ * If the element is not found, returns `-n - 1`, where `n` is the index to insert `x` at.
+ * @param arr The sorted array
  * @param x The element to find
  * @param lo The starting index
  * @param hi The end index to search within
@@ -602,7 +584,7 @@ export declare function remove<T>(arr: T[], func: Iteratee<T>): T[];
 export declare function binarySearch(arr: any[], x: any, lo?: number, hi?: any, comp?: typeof compare): number;
 /**
  * Returns an insertion index which comes after any existing entries of `x` in a **sorted** array, using binary search.
- * @param arr The array to sort
+ * @param arr The sorted array
  * @param x The element to find
  * @param lo The starting index
  * @param hi The end index to search within
@@ -612,7 +594,7 @@ export declare function binarySearch(arr: any[], x: any, lo?: number, hi?: any,
 export declare function bisect(arr: any[], x: any, lo?: number, hi?: any, comp?: typeof compare): number;
 /**
  * Returns an insertion index which comes before any existing entries of `x` in a **sorted** array, using binary search.
- * @param arr The array to sort
+ * @param arr The sorted array
  * @param x The element to find
  * @param lo The starting index
  * @param hi The end index to search within