data-structure-typed 1.38.0 → 1.38.2

package/lib/types/utils/index.js

@@ -1,2 +0,0 @@
-export * from './utils';
-export * from './validate-type';

package/lib/types/utils/utils.js

@@ -1 +0,0 @@
-export {};

package/lib/types/utils/validate-type.js

@@ -1 +0,0 @@
-export {};

package/lib/utils/index.js

@@ -1 +0,0 @@
-export * from './utils';

package/lib/utils/utils.js

@@ -1,63 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-export const uuidV4 = function () {
-    return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
-        const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    });
-};
-export const arrayRemove = function (array, predicate) {
-    let i = -1, len = array ? array.length : 0;
-    const result = [];
-    while (++i < len) {
-        const value = array[i];
-        if (predicate(value, i, array)) {
-            result.push(value);
-            Array.prototype.splice.call(array, i--, 1);
-            len--;
-        }
-    }
-    return result;
-};
-export const THUNK_SYMBOL = Symbol('thunk');
-export const isThunk = (fnOrValue) => {
-    return typeof fnOrValue === 'function' && fnOrValue.__THUNK__ === THUNK_SYMBOL;
-};
-export const toThunk = (fn) => {
-    const thunk = () => fn();
-    thunk.__THUNK__ = THUNK_SYMBOL;
-    return thunk;
-};
-export const trampoline = (fn) => {
-    const cont = (...args) => toThunk(() => fn(...args));
-    return Object.assign((...args) => {
-        let result = fn(...args);
-        while (isThunk(result) && typeof result === 'function') {
-            result = result();
-        }
-        return result;
-    }, { cont });
-};
-export const trampolineAsync = (fn) => {
-    const cont = (...args) => toThunk(() => fn(...args));
-    return Object.assign((...args) => __awaiter(void 0, void 0, void 0, function* () {
-        let result = yield fn(...args);
-        while (isThunk(result) && typeof result === 'function') {
-            result = yield result();
-        }
-        return result;
-    }), { cont });
-};
-export const getMSB = (value) => {
-    if (value <= 0) {
-        return 0;
-    }
-    return 1 << (31 - Math.clz32(value));
-};

package/dist/{data-structures → cjs/data-structures}/binary-tree/avl-tree.d.ts

@@ -20,15 +20,6 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> e
      * options.
      */
     constructor(options?: AVLTreeOptions);
-    /**
-     * The function swaps the key, value, and height properties between two nodes in a binary tree.
-     * @param {N} srcNode - The `srcNode` parameter represents the source node that needs to be swapped
-     * with the `destNode`.
-     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
-     * from the source node (`srcNode`) will be swapped to.
-     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
-     */
-    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The function creates a new AVL tree node with the specified key and value.
      * @param {BinaryTreeNodeKey} key - The key parameter is the key value that will be associated with
@@ -57,6 +48,15 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> e
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
     delete(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
+    /**
+     * The function swaps the key, value, and height properties between two nodes in a binary tree.
+     * @param {N} srcNode - The `srcNode` parameter represents the source node that needs to be swapped
+     * with the `destNode`.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from the source node (`srcNode`) will be swapped to.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     */
+    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The function calculates the balance factor of a node in a binary tree.
      * @param {N} node - The parameter "node" represents a node in a binary tree data structure.

package/dist/{data-structures → cjs/data-structures}/binary-tree/binary-tree.d.ts

@@ -14,12 +14,6 @@ import { IBinaryTree } from '../../interfaces';
  * @template FAMILY - The type of the family relationship in the binary tree.
  */
 export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FAMILY> = BinaryTreeNodeNested<V>> {
-    /**
-     * Creates a new instance of BinaryTreeNode.
-     * @param {BinaryTreeNodeKey} key - The key associated with the node.
-     * @param {V} val - The value stored in the node.
-     */
-    constructor(key: BinaryTreeNodeKey, val?: V);
     /**
      * The key associated with the node.
      */
@@ -28,6 +22,16 @@ export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FA
      * The value stored in the node.
      */
     val: V | undefined;
+    /**
+     * The parent node of the current node.
+     */
+    parent: FAMILY | null | undefined;
+    /**
+     * Creates a new instance of BinaryTreeNode.
+     * @param {BinaryTreeNodeKey} key - The key associated with the node.
+     * @param {V} val - The value stored in the node.
+     */
+    constructor(key: BinaryTreeNodeKey, val?: V);
     private _left;
     /**
      * Get the left child node.
@@ -48,10 +52,6 @@ export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FA
      * @param {FAMILY | null | undefined} v - The right child node.
      */
     set right(v: FAMILY | null | undefined);
-    /**
-     * The parent node of the current node.
-     */
-    parent: FAMILY | null | undefined;
     /**
      * Get the position of the node within its family.
      * @returns {FamilyPosition} - The family position of the node.
@@ -63,18 +63,12 @@ export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FA
  * @template N - The type of the binary tree's nodes.
  */
 export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode> implements IBinaryTree<N> {
+    private _loopType;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options?: BinaryTreeOptions);
-    /**
-     * Creates a new instance of BinaryTreeNode with the given key and value.
-     * @param {BinaryTreeNodeKey} key - The key for the new node.
-     * @param {N['val']} val - The value for the new node.
-     * @returns {N} - The newly created BinaryTreeNode.
-     */
-    createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     private _root;
     /**
      * Get the root node of the binary tree.
@@ -85,7 +79,6 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * Get the number of nodes in the binary tree.
      */
     get size(): number;
-    private _loopType;
     /**
      * Get the iteration type used in the binary tree.
      */
@@ -96,12 +89,12 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      */
     set iterationType(v: IterationType);
     /**
-     * Swap the data of two nodes in the binary tree.
-     * @param {N} srcNode - The source node to swap.
-     * @param {N} destNode - The destination node to swap.
-     * @returns {N} - The destination node after the swap.
+     * Creates a new instance of BinaryTreeNode with the given key and value.
+     * @param {BinaryTreeNodeKey} key - The key for the new node.
+     * @param {N['val']} val - The value for the new node.
+     * @returns {N} - The newly created BinaryTreeNode.
      */
-    protected _swap(srcNode: N, destNode: N): N;
+    createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     /**
      * Clear the binary tree, removing all nodes.
      */
@@ -174,7 +167,6 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * @returns the height of the binary tree.
      */
     getHeight(beginRoot?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): number;
-    protected _defaultCallbackByKey: MapCallback<N>;
     /**
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
@@ -359,13 +351,6 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * @returns The function `getPredecessor` returns the predecessor node of the given node `node`.
      */
     getPredecessor(node: N): N;
-    /**
-     * Time complexity is O(n)
-     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
-     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
-     * the tree's structure should be restored to its original state to maintain the tree's integrity.
-     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
-     */
     /**
      * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
      * algorithm and returns an array of values obtained by applying a callback function to each node.
@@ -381,6 +366,21 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * @returns The `morris` function returns an array of `MapCallbackReturn<N>` values.
      */
     morris(callback?: MapCallback<N>, pattern?: DFSOrderPattern, beginRoot?: N | null): MapCallbackReturn<N>[];
+    /**
+     * Swap the data of two nodes in the binary tree.
+     * @param {N} srcNode - The source node to swap.
+     * @param {N} destNode - The destination node to swap.
+     * @returns {N} - The destination node after the swap.
+     */
+    protected _swap(srcNode: N, destNode: N): N;
+    /**
+     * Time complexity is O(n)
+     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
+     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
+     * the tree's structure should be restored to its original state to maintain the tree's integrity.
+     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
+     */
+    protected _defaultCallbackByKey: MapCallback<N>;
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
      * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to

package/dist/{data-structures → cjs/data-structures}/binary-tree/rb-tree.d.ts

@@ -2,8 +2,8 @@ import { BinaryTreeNodeKey, RBColor, RBTreeNodeNested, RBTreeOptions } from '../
 import { IBinaryTree } from '../../interfaces';
 import { BST, BSTNode } from './bst';
 export declare class RBTreeNode<V = any, FAMILY extends RBTreeNode<V, FAMILY> = RBTreeNodeNested<V>> extends BSTNode<V, FAMILY> {
-    private _color;
     constructor(key: BinaryTreeNodeKey, val?: V);
+    private _color;
     get color(): RBColor;
     set color(value: RBColor);
 }

package/dist/{data-structures → cjs/data-structures}/binary-tree/tree-multiset.d.ts

@@ -10,6 +10,7 @@ import { BinaryTreeDeletedResult, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, FAMILY> {
+    count: number;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
@@ -21,7 +22,6 @@ export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V
      * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
     constructor(key: BinaryTreeNodeKey, val?: V, count?: number);
-    count: number;
 }
 /**
  * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
@@ -46,14 +46,6 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
     createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N;
-    /**
-     * The function swaps the values of two nodes in a binary tree.
-     * @param {N} srcNode - The source node that needs to be swapped with the destination node.
-     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
-     * from `srcNode` will be swapped into.
-     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
-     */
-    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The `add` function adds a new node to a binary search tree, updating the count if the key already
      * exists, and balancing the tree if necessary.
@@ -114,6 +106,14 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear(): void;
+    /**
+     * The function swaps the values of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that needs to be swapped with the destination node.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from `srcNode` will be swapped into.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     */
+    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The function sets the value of the "_count" property.
      * @param {number} v - number

package/{lib → dist/cjs}/data-structures/hash/hash-map.d.ts

@@ -7,24 +7,6 @@ import { HashFunction } from '../../types';
  * @license MIT License
  */
 export declare class HashMap<K, V> {
-    get hashFn(): HashFunction<K>;
-    set hashFn(value: HashFunction<K>);
-    get table(): Array<Array<[K, V]>>;
-    set table(value: Array<Array<[K, V]>>);
-    get capacityMultiplier(): number;
-    set capacityMultiplier(value: number);
-    get loadFactor(): number;
-    set loadFactor(value: number);
-    get initialCapacity(): number;
-    set initialCapacity(value: number);
-    get size(): number;
-    set size(value: number);
-    private _initialCapacity;
-    private _loadFactor;
-    private _capacityMultiplier;
-    private _size;
-    private _table;
-    private _hashFn;
     /**
      * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
      * multiplier, size, table array, and hash function.
@@ -38,6 +20,31 @@ export declare class HashMap<K, V> {
      * default hash function converts the key to a string, calculates the sum of the
      */
     constructor(initialCapacity?: number, loadFactor?: number, hashFn?: HashFunction<K>);
+    private _initialCapacity;
+    get initialCapacity(): number;
+    set initialCapacity(value: number);
+    private _loadFactor;
+    get loadFactor(): number;
+    set loadFactor(value: number);
+    private _capacityMultiplier;
+    get capacityMultiplier(): number;
+    set capacityMultiplier(value: number);
+    private _size;
+    get size(): number;
+    set size(value: number);
+    private _table;
+    get table(): Array<Array<[K, V]>>;
+    set table(value: Array<Array<[K, V]>>);
+    private _hashFn;
+    get hashFn(): HashFunction<K>;
+    set hashFn(value: HashFunction<K>);
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    delete(key: K): void;
+    entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    clear(): void;
+    isEmpty(): boolean;
     private _hash;
     /**
      * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
@@ -46,11 +53,4 @@ export declare class HashMap<K, V> {
      * the number of buckets that the new table should have.
      */
     private resizeTable;
-    set(key: K, value: V): void;
-    get(key: K): V | undefined;
-    delete(key: K): void;
-    entries(): IterableIterator<[K, V]>;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-    clear(): void;
-    isEmpty(): boolean;
 }

package/{lib → dist/cjs}/data-structures/hash/hash-table.d.ts

@@ -13,19 +13,46 @@ export declare class HashTableNode<K, V> {
 }
 import { HashFunction } from '../../types';
 export declare class HashTable<K, V> {
-    get hashFn(): HashFunction<K>;
-    set hashFn(value: HashFunction<K>);
-    get buckets(): Array<HashTableNode<K, V> | null>;
-    set buckets(value: Array<HashTableNode<K, V> | null>);
-    get capacity(): number;
-    set capacity(value: number);
     private static readonly DEFAULT_CAPACITY;
     private static readonly LOAD_FACTOR;
+    constructor(capacity?: number, hashFn?: HashFunction<K>);
     private _capacity;
+    get capacity(): number;
+    set capacity(value: number);
     private _size;
+    get size(): number;
     private _buckets;
+    get buckets(): Array<HashTableNode<K, V> | null>;
+    set buckets(value: Array<HashTableNode<K, V> | null>);
     private _hashFn;
-    constructor(capacity?: number, hashFn?: HashFunction<K>);
+    get hashFn(): HashFunction<K>;
+    set hashFn(value: HashFunction<K>);
+    /**
+     * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
+     * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
+     * table. It is of type K, which is a generic type representing the key's data type.
+     * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
+     * table.
+     * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
+     * value.
+     */
+    set(key: K, val: V): void;
+    /**
+     * The `get` function retrieves the value associated with a given key from a hash table.
+     * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data
+     * structure.
+     * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
+     * not found, it returns `undefined`.
+     */
+    get(key: K): V | undefined;
+    /**
+     * The delete function removes a key-value pair from a hash table.
+     * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
+     * table.
+     * @returns Nothing is being returned. The `delete` method has a return type of `void`, which means it does not return
+     * any value.
+     */
+    delete(key: K): void;
     /**
      * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
      * capacity of the data structure.
@@ -71,36 +98,9 @@ export declare class HashTable<K, V> {
      * @returns a number, which is the hash value of the key.
      */
     protected _objectHash(key: K): number;
-    /**
-     * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
-     * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
-     * table. It is of type K, which is a generic type representing the key's data type.
-     * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
-     * table.
-     * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
-     * value.
-     */
-    set(key: K, val: V): void;
-    /**
-     * The `get` function retrieves the value associated with a given key from a hash table.
-     * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data
-     * structure.
-     * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
-     * not found, it returns `undefined`.
-     */
-    get(key: K): V | undefined;
-    /**
-     * The delete function removes a key-value pair from a hash table.
-     * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
-     * table.
-     * @returns Nothing is being returned. The `delete` method has a return type of `void`, which means it does not return
-     * any value.
-     */
-    delete(key: K): void;
     /**
      * The `expand` function increases the capacity of a hash table by creating a new array of buckets with double the
      * capacity and rehashing all the existing key-value pairs into the new buckets.
      */
     protected _expand(): void;
-    get size(): number;
 }