atomic-fns 0.4.2 → 1.1.1

package/README.md

@@ -2,18 +2,18 @@
 
 [Read the Docs](https://atomic-fns.dev)
 
-## Like Lodash, but for ESNext and with types.
+## Like Lodash, but in TypeScript and for ESnext.
 
-Stop shipping code built for browsers from *2015*. Really though, look at all the [issues](https://github.com/lodash/lodash/issues/2930).
+Stop shipping code built for browsers from 2015. Really though, look at all the [issues](https://github.com/lodash/lodash/issues/2930).
 
 You may prefer this because it's:
 
+* **TypeScript & docs**: Includes type declaration files and js with JSDocs for best in class experience.
+* **Zero deps**: Built from scratch with no runtime dependencies or polyfills.
+* **ESnext**: Uses modern idiomatic syntax, data structures, and control flow techniques.
 * **Modular**: Pick what you need. Supports tree-shaking, no side effects and works with all bundlers.
-* **ESNext**: Uses modern idiomatic syntax, data structures, and control flow techniques.
 * **Lazy**: Leverage generators, iterators, and functional composition.
-* **Zero deps**: Built from scratch with no runtime dependencies or polyfills.
-* **Well tested**: All modules have comprehensive test suites aiming for 100% coverage.
-* **TypeScript & docs**: Includes type declaration files and js with JSDocs for best in class experience.
+* **Well tested**: All modules have comprehensive test suites and public apis are 100% coverage.
 
 ## Docs
 
@@ -47,17 +47,6 @@ uniqueId('user_')
 ...
 ```
 
-You could also import any individual module directly from an html page like this:
-
-```html
-<script type="module">
-  import {
-    namedtuple, FrozenSet, SortedSet, SortedMap
-  } from 'https://unpkg.com/atomic-fns/collections';
-  // your code goes here...
-</script>
-```
-
 See the full list of [modules](https://atomic-fns.dev/modules.html).
 
 ## Data model

package/dist/collections/BTree.d.ts

@@ -1,6 +1,6 @@
-import { Iteratee } from '../globals/index.js';
 import { Comparer } from '../operators/index.js';
 import { Mapping } from './abc.js';
+import { Iteratee } from '../types';
 export declare class BTree<K = any, V = any> extends Mapping<K, V> {
     private root;
     count: number;

package/dist/collections/Trie.d.ts

@@ -0,0 +1,42 @@
+import { Collection } from './abc.js';
+/**
+ * A Trie is a tree for efficient storing and retrieval of strings such as words in a dictionary. They are useful for checking all the strings that have a common prefix.
+ * Insertions, lookups and removals in `O(s)` where `s` is the search term.
+ * @see {@link https://en.wikipedia.org/wiki/Trie Trie}
+ */
+export declare class Trie extends Collection {
+    private root;
+    private count;
+    constructor(words?: string[]);
+    /**
+     * Adds the given string to the tree.
+     * @param word A string
+     */
+    add(word: string): this;
+    /**
+     * Removes the given string from the tree.
+     * @param word The string to remove
+     * @returns {boolean} Returns `true` if the string was found and removed.
+     */
+    remove(word: string): boolean;
+    private findNode;
+    /**
+     * Generates all results that start with the given string.
+     * @param word A prefix string
+     * @param {number} [limit=20] The number of results to return.
+     */
+    matches: (word: string, limit?: number) => Generator<any, void, any>;
+    /**
+     * Returns `true` if the given string is found in the tree.
+     * @param {string} word
+     */
+    contains(word: string): boolean;
+    /**
+     * Removes all strings from the tree.
+     */
+    clear(): void;
+    /**
+     * Returns the total number of strings in the tree.
+     */
+    get size(): number;
+}

package/dist/collections/Trie.js

@@ -0,0 +1,104 @@
+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);
+    }
+}
+/**
+ * A Trie is a tree for efficient storing and retrieval of strings such as words in a dictionary. They are useful for checking all the strings that have a common prefix.
+ * Insertions, lookups and removals in `O(s)` where `s` is the search term.
+ * @see {@link https://en.wikipedia.org/wiki/Trie Trie}
+ */
+export class Trie extends Collection {
+    root = {};
+    count = 0;
+    constructor(words) {
+        super();
+        if (words) {
+            for (const word of words) {
+                this.add(word);
+            }
+        }
+    }
+    /**
+     * Adds the given string to the tree.
+     * @param word A string
+     */
+    add(word) {
+        let current = this.root;
+        for (let i = 0; i < word.length; i++) {
+            const c = word[i];
+            if (!current[c])
+                current[c] = {};
+            current = current[c];
+        }
+        // Set as end of the word
+        Object.defineProperty(current, 'isWord', {
+            value: true,
+            enumerable: false,
+            writable: true
+        });
+        this.count++;
+        return this;
+    }
+    /**
+     * Removes the given string from the tree.
+     * @param word The string to remove
+     * @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;
+    }
+    findNode(word) {
+        let node = this.root;
+        for (let i = 0; i < word.length && node; i++) {
+            const letter = word[i];
+            node = node[letter];
+        }
+        return node;
+    }
+    /**
+     * Generates all results that start with the given string.
+     * @param word A prefix string
+     * @param {number} [limit=20] The number of results to return.
+     */
+    matches = function* (word, limit = 20) {
+        const node = this.findNode(word);
+        if (node) {
+            yield* traverse(node, word, limit);
+        }
+    };
+    /**
+     * Returns `true` if the given string is found in the tree.
+     * @param {string} word
+     */
+    contains(word) {
+        const node = this.findNode(word);
+        return node?.isWord;
+    }
+    /**
+     * Removes all strings from the tree.
+     */
+    clear() {
+        this.root = {};
+        this.count = 0;
+    }
+    /**
+     * Returns the total number of strings in the tree.
+     */
+    get size() {
+        return this.count;
+    }
+}

package/dist/collections/deque.d.ts

@@ -1,4 +1,4 @@
-import { Iteratee } from '../globals/index.js';
+import { Iteratee } from '../types.js';
 import { Sequence } from './abc.js';
 /**
  * Fixed capacity double-ended queue implemented as ring deque.
@@ -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(): Iterator<[number, T], any, undefined> & Iterable<[number, T]>;
+    entries(): Iterable<[number, T]> & Iterator<[number, T], any, undefined>;
     [Symbol.iterator](): Iterable<T>;
     inspect(): any;
 }

package/dist/collections/deque.js

@@ -228,17 +228,15 @@ export class Deque extends Sequence {
         return IterableIterator(() => {
             if (j >= l)
                 return {
-                    done: true
+                    done: true,
+                    value: undefined
                 };
             const value = items[i];
             i++;
             j++;
             if (i === c)
                 i = 0;
-            return {
-                value,
-                done: false
-            };
+            return { value };
         });
     }
     /**
@@ -260,15 +258,15 @@ export class Deque extends Sequence {
         return IterableIterator(() => {
             if (j >= l)
                 return {
-                    done: true
+                    done: true,
+                    value: undefined
                 };
             const value = items[i];
             i++;
             if (i === c)
                 i = 0;
             return {
-                value: [j++, value],
-                done: false
+                value: [j++, value]
             };
         });
     }