data-structure-typed 1.54.0 → 1.54.2

package/dist/{mjs/data-structures/binary-tree/tree-multi-map.d.ts → cjs/data-structures/binary-tree/tree-counter.d.ts}

@@ -5,10 +5,10 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, EntryCallback, IterationType, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, EntryCallback, IterationType, OptNodeOrNull, RBTNColor, TreeCounterOptions } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
-export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
+export declare class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<K, V> {
     /**
      * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
      * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
@@ -22,18 +22,28 @@ export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMa
      * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
      */
     constructor(key: K, value?: V, count?: number, color?: RBTNColor);
+    parent?: TreeCounterNode<K, V>;
+    _left?: OptNodeOrNull<TreeCounterNode<K, V>>;
+    get left(): OptNodeOrNull<TreeCounterNode<K, V>>;
+    set left(v: OptNodeOrNull<TreeCounterNode<K, V>>);
+    _right?: OptNodeOrNull<TreeCounterNode<K, V>>;
+    get right(): OptNodeOrNull<TreeCounterNode<K, V>>;
+    set right(v: OptNodeOrNull<TreeCounterNode<K, V>>);
 }
-export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR = object, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, R, MK, MV, MR, NODE, TREE> = TreeMultiMap<K, V, R, MK, MV, MR, NODE, TreeMultiMapNested<K, V, R, MK, MV, MR, NODE>>> extends RedBlackTree<K, V, R, MK, MV, MR, NODE, TREE> implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE> {
+/**
+ *
+ */
+export declare class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR = object> extends RedBlackTree<K, V, R, MK, MV, MR> implements IBinaryTree<K, V, R, MK, MV, MR> {
     /**
-     * The constructor function initializes a TreeMultiMap object with optional initial data.
+     * The constructor function initializes a TreeCounter object with optional initial data.
      * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
      * iterable that can contain keys, nodes, entries, or raw elements. It is used to initialize the
-     * TreeMultiMap with initial data.
+     * TreeCounter with initial data.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
-     * behavior of the `TreeMultiMap` constructor. It can include properties such as `compareKeys` and
+     * behavior of the `TreeCounter` constructor. It can include properties such as `compareKeys` and
      * `compareValues`, which are functions used to compare keys and values respectively.
      */
-    constructor(keysNodesEntriesOrRaws?: Iterable<BTNRep<K, V, NODE>>, options?: TreeMultiMapOptions<K, V, R>);
+    constructor(keysNodesEntriesOrRaws?: Iterable<BTNRep<K, V, TreeCounterNode<K, V>> | R>, options?: TreeCounterOptions<K, V, R>);
     protected _count: number;
     /**
      * The function calculates the sum of the count property of all nodes in a tree structure.
@@ -50,7 +60,7 @@ export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = a
      */
     getComputedCount(): number;
     /**
-     * The function creates a new TreeMultiMapNode with the specified key, value, color, and count.
+     * The function creates a new TreeCounterNode with the specified key, value, color, and count.
      * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
      * which is a generic type representing the type of keys in the tree.
      * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
@@ -60,47 +70,34 @@ export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = a
      * @param {number} [count] - The `count` parameter represents the number of occurrences of a key in
      * the tree. It is an optional parameter and is used to keep track of the number of values associated
      * with a key in the tree.
-     * @returns A new instance of the TreeMultiMapNode class, casted as NODE.
+     * @returns A new instance of the TreeCounterNode class, casted as TreeCounterNode<K, V>.
      */
-    createNode(key: K, value?: V, color?: RBTNColor, count?: number): NODE;
+    createNode(key: K, value?: V, color?: RBTNColor, count?: number): TreeCounterNode<K, V>;
     /**
-     * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
+     * The function creates a new instance of a TreeCounter with the specified options and returns it.
      * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the `TreeMultiMap`. It is of type `TreeMultiMapOptions<K, V,
+     * configuration options for creating the `TreeCounter`. It is of type `TreeCounterOptions<K, V,
      * R>`.
-     * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
+     * @returns a new instance of the `TreeCounter` class, with the provided options merged with the
      * existing `iterationType` property. The returned value is casted as `TREE`.
      */
-    createTree(options?: TreeMultiMapOptions<K, V, R>): TREE;
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
-     * node based on the input.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @param {V} [value] - The `value` parameter is an optional value that represents the value
-     * associated with the key in the node. It is used when creating a new node or updating the value of
-     * an existing node.
-     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
-     * @returns either a NODE object or undefined.
-     */
-    protected _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): [NODE | undefined, V | undefined];
+    createTree(options?: TreeCounterOptions<K, V, R>): TreeCounter<K, V, R, MK, MV, MR>;
     /**
-     * The function checks if the input is an instance of the TreeMultiMapNode class.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
-     * an instance of the `TreeMultiMapNode` class.
+     * The function checks if the input is an instance of the TreeCounterNode class.
+     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
+     * an instance of the `TreeCounterNode` class.
      */
-    isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE;
+    isNode(keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>): keyNodeOrEntry is TreeCounterNode<K, V>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function overrides the add method of a class and adds a new node to a data structure, updating
      * the count and returning a boolean indicating success.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-     * `keyNodeEntryOrRaw` parameter can accept one of the following types:
+     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The
+     * `keyNodeOrEntry` parameter can accept one of the following types:
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
      * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
@@ -109,23 +106,23 @@ export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = a
      * @returns The method is returning a boolean value. It returns true if the addition of the new node
      * was successful, and false otherwise.
      */
-    add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): boolean;
+    add(keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>, value?: V, count?: number): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
      * structure, handling cases where nodes have children and maintaining balance in the tree.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `predicate`
+     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
      * parameter in the `delete` method is used to specify the condition or key based on which a node
      * should be deleted from the binary tree. It can be a key, a node, or an entry.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
      * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
      * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
      * `ignoreCount` is `false
-     * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<NODE>` objects.
+     * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<TreeCounterNode<K, V>>` objects.
      */
-    delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
+    delete(keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>, ignoreCount?: boolean): BinaryTreeDeleteResult<TreeCounterNode<K, V>>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -155,48 +152,61 @@ export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = a
      * The function overrides the clone method to create a deep copy of a tree object.
      * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
-    clone(): TREE;
+    clone(): TreeCounter<K, V, R, MK, MV, MR>;
+    /**
+     * The `map` function in TypeScript overrides the default behavior to create a new TreeCounter with
+     * modified entries based on a provided callback.
+     * @param callback - The `callback` parameter is a function that will be called for each entry in the
+     * map. It takes four arguments:
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `TreeCounterOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
+     * options when creating a new `TreeCounter` instance within the `map` function. These options could
+     * include things like
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function when it is called within the `map` function. This
+     * @returns A new TreeCounter instance is being returned, which is populated with entries generated
+     * by the provided callback function.
+     */
+    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: TreeCounterOptions<MK, MV, MR>, thisArg?: any): TreeCounter<MK, MV, MR>;
+    /**
+     * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
+     * node based on the input.
+     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+     * @param {V} [value] - The `value` parameter is an optional value that represents the value
+     * associated with the key in the node. It is used when creating a new node or updating the value of
+     * an existing node.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
+     * @returns either a TreeCounterNode<K, V> object or undefined.
+     */
+    protected _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>, value?: V, count?: number): [TreeCounterNode<K, V> | undefined, V | undefined];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `_swapProperties` function swaps the properties (key, value, count, color) between two nodes
      * in a binary search tree.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
+     * @param {R | BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>} srcNode - The `srcNode` parameter represents the source node
      * that will be swapped with the `destNode`. It can be either an instance of the `R` class or an
-     * instance of the `BSTNOptKeyOrNode<K, NODE>` class.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
+     * instance of the `BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>` class.
+     * @param {R | BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>} destNode - The `destNode` parameter represents the destination
      * node where the properties will be swapped with the source node.
      * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      * If either `srcNode` or `destNode` is undefined, it returns undefined.
      */
-    protected _swapProperties(srcNode: R | BSTNOptKeyOrNode<K, NODE>, destNode: R | BSTNOptKeyOrNode<K, NODE>): NODE | undefined;
+    protected _swapProperties(srcNode: BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>, destNode: BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>): TreeCounterNode<K, V> | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function replaces an old node with a new node and updates the count property of the new node.
-     * @param {NODE} oldNode - The `oldNode` parameter is the node that you want to replace in the data
+     * @param {TreeCounterNode<K, V>} oldNode - The `oldNode` parameter is the node that you want to replace in the data
      * structure.
-     * @param {NODE} newNode - The `newNode` parameter is an instance of the `NODE` class.
+     * @param {TreeCounterNode<K, V>} newNode - The `newNode` parameter is an instance of the `TreeCounterNode<K, V>` class.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
-     * superclass, which is of type `NODE`.
-     */
-    protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
-    /**
-     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap with
-     * modified entries based on a provided callback.
-     * @param callback - The `callback` parameter is a function that will be called for each entry in the
-     * map. It takes four arguments:
-     * @param [options] - The `options` parameter in the `override map` function is of type
-     * `TreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
-     * options when creating a new `TreeMultiMap` instance within the `map` function. These options could
-     * include things like
-     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
-     * the value of `this` when executing the `callback` function. It allows you to set the context
-     * (value of `this`) for the callback function when it is called within the `map` function. This
-     * @returns A new TreeMultiMap instance is being returned, which is populated with entries generated
-     * by the provided callback function.
+     * superclass, which is of type `TreeCounterNode<K, V>`.
      */
-    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: TreeMultiMapOptions<MK, MV, MR>, thisArg?: any): TreeMultiMap<MK, MV, MR>;
+    protected _replaceNode(oldNode: TreeCounterNode<K, V>, newNode: TreeCounterNode<K, V>): TreeCounterNode<K, V>;
 }