atomic-fns 0.4.3 → 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
 

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.

package/dist/collections/index.d.ts

@@ -3,8 +3,8 @@
  *
  * @module Collections
  */
-import { Iteratee } from '../globals/index.js';
 import { compare } from '../operators/index.js';
+import { Iteratee } from '../types';
 export * from './abc.js';
 export * from './BTree.js';
 export * from './deque.js';

package/dist/decimal/index.d.ts

@@ -0,0 +1,147 @@
+/**
+ * `Decimal` provides support for correct rounded floating point arithmetic.
+ *
+ * @module decimal
+ */
+/**
+ * Casts the given value as a {@link Decimal}.
+ */
+export declare function decimal(x: any): Decimal;
+/**
+ * `Decimal` provides support for correct rounded floating point arithmetic, unlike the standard Number type. It also supports user-defined precision (default is 20 decimal places) which can be as large as needed.
+ */
+export declare class Decimal {
+    static PRECISION: number;
+    private i;
+    private e;
+    /**
+     * Returns a new `Decimal` instance from the value or `0`.
+     * @param {*} value
+     * @returns {Decimal}
+     */
+    constructor(value?: any);
+    /**
+     * Returns a new `Decimal` that has the opposite sign of this `Decimal`.
+     * @example
+  ```js
+  let a = decimal('5')
+  a.minus()  // -5
+  ```
+     * @returns {Decimal}
+     */
+    negated(): Decimal;
+    /**
+     * Returns a new `Decimal` that is the sum of this and `x`.
+     * @param x
+     * @example
+  ```js
+  let a = decimal('50000000000')
+  let b = decimal('0.000000005')
+  a.add(b)  // 50000000000.000000005
+  ```
+     * @returns {Decimal}
+     */
+    add(x: any): Decimal;
+    /**
+     * Returns a new `Decimal` that is the difference between this and `x`.
+     * @param x
+     * @example
+  ```js
+  let a = decimal('1')
+  let b = decimal('0.0000000000000000001')
+  a.sub(b)  // 0.9999999999999999999
+  ```
+     * @returns {Decimal}
+     */
+    sub(x: any): Decimal;
+    /**
+     * Returns a new `Decimal` that is the product of this and `x`.
+     * @param x
+     * @example
+  ```js
+  let a = decimal('0.0000000000000000000025')
+  let b = decimal('400000000000000000000')
+  a.mul(b)  // 1
+  ```
+     * @returns {Decimal}
+     */
+    mul(x: any): Decimal;
+    /**
+     * Returns a new `Decimal` that is the quotient of this and `x`
+     * @param x
+     * @example
+  ```js
+  let a = decimal('1')
+  let b = decimal('3')
+  a.div(b)  // 0.333333333333333333333333333333
+  ```
+     * @returns {Decimal}
+     */
+    div(x: any): Decimal;
+    /**
+     * Returns the square root of this `Decimal`.
+     * @returns {TDecimal}
+     */
+    sqrt(): Decimal;
+    /** Returns a new copy of this Decimal value. */
+    clone(): Decimal;
+    /**
+     * Remove zeroes in the least-significant digit of this `Decimal`
+     */
+    private _normalize;
+    /**
+     * Truncate this `Decimal` to the configured precision
+     */
+    private _truncate;
+    /**
+     * Returns a string representation of this decimal.
+     * @returns {Decimal}
+     */
+    toString(): string;
+    /**
+     * Converts this decimal to the `Number` value
+     * @returns {number}
+     */
+    toNumber(): number;
+    static get precision(): number;
+    static set precision(value: number);
+    /**
+     * Returns `true` if this value is equal to the value of `x`, otherwise `false`.
+     * @param {*} x other
+     * @returns {boolean}
+     */
+    eq(x: any): boolean;
+    /**
+     * Returns `true` if this value is less than the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    lt(x: any): boolean;
+    /**
+     * Returns a comparison value representing the ordering of this value in respect to `x`.
+     *   * `-1` if this < x
+     *   * `1` if this > x
+     *   * `0` if this == x
+     * @param {*} x
+     * @returns {number}
+     */
+    compare(x: any): 1 | -1 | 0;
+    /**
+     * Returns `true` if this value is greater than the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    gt(x: any): boolean;
+    /**
+     * Returns `true` if this value is less than or equal to the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    lte(x: any): boolean;
+    /**
+     * Returns `true` if this value is greater than or equal to the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    gte(x: any): boolean;
+}