data-structure-typed 1.34.6 → 1.34.8

package/lib/data-structures/binary-tree/avl-tree.d.ts

@@ -6,10 +6,10 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeId } from '../../types';
+import type { AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeKey } from '../../types';
 import { IAVLTree, IAVLTreeNode } from '../../interfaces';
 export declare class AVLTreeNode<V = any, NEIGHBOR extends AVLTreeNode<V, NEIGHBOR> = AVLTreeNodeNested<V>> extends BSTNode<V, NEIGHBOR> implements IAVLTreeNode<V, NEIGHBOR> {
-    constructor(id: BinaryTreeNodeId, val?: V);
+    constructor(key: BinaryTreeNodeKey, val?: V);
 }
 export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends BST<N> implements IAVLTree<N> {
     /**
@@ -20,30 +20,30 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> e
      */
     constructor(options?: AVLTreeOptions);
     /**
-     * The function creates a new AVL tree node with the given id and value.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * The function creates a new AVL tree node with the given key and value.
+     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is used to uniquely
      * identify each node in the tree.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
      * that will be stored in the node.
-     * @returns a new AVLTreeNode object with the specified id and value.
+     * @returns a new AVLTreeNode object with the specified key and value.
      */
-    createNode(id: BinaryTreeNodeId, val?: N['val']): N;
+    createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     /**
      * The function overrides the add method of a binary tree node and balances the tree after inserting a new node.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add.
+     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier of the binary tree node that we want to add.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. It is of type
      * `N['val']`, which means it should be of the same type as the `val` property of the nodes in the binary tree.
      * @returns The method is returning the inserted node, or null or undefined if the insertion was not successful.
      */
-    add(id: BinaryTreeNodeId, val?: N['val']): N | null | undefined;
+    add(key: BinaryTreeNodeKey, val?: N['val']): N | null | undefined;
     /**
      * The function overrides the remove method of a binary tree and performs additional operations to balance the tree after
      * deletion.
-     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
+     * @param {BinaryTreeNodeKey} key - The `key` parameter represents the identifier of the binary tree node that needs to be
      * removed.
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(id: BinaryTreeNodeId): BinaryTreeDeletedResult<N>[];
+    remove(key: BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
     /**
      * The balance factor of a given AVL tree node is calculated by subtracting the height of its left subtree from the
      * height of its right subtree.

package/lib/data-structures/binary-tree/avl-tree.js

@@ -7,8 +7,8 @@
  */
 import { BST, BSTNode } from './bst';
 export class AVLTreeNode extends BSTNode {
-    constructor(id, val) {
-        super(id, val);
+    constructor(key, val) {
+        super(key, val);
     }
 }
 export class AVLTree extends BST {
@@ -22,26 +22,26 @@ export class AVLTree extends BST {
         super(options);
     }
     /**
-     * The function creates a new AVL tree node with the given id and value.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * The function creates a new AVL tree node with the given key and value.
+     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is used to uniquely
      * identify each node in the tree.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
      * that will be stored in the node.
-     * @returns a new AVLTreeNode object with the specified id and value.
+     * @returns a new AVLTreeNode object with the specified key and value.
      */
-    createNode(id, val) {
-        return new AVLTreeNode(id, val);
+    createNode(key, val) {
+        return new AVLTreeNode(key, val);
     }
     /**
      * The function overrides the add method of a binary tree node and balances the tree after inserting a new node.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add.
+     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier of the binary tree node that we want to add.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. It is of type
      * `N['val']`, which means it should be of the same type as the `val` property of the nodes in the binary tree.
      * @returns The method is returning the inserted node, or null or undefined if the insertion was not successful.
      */
-    add(id, val) {
+    add(key, val) {
         // TODO support node as a param
-        const inserted = super.add(id, val);
+        const inserted = super.add(key, val);
         if (inserted)
             this._balancePath(inserted);
         return inserted;
@@ -49,12 +49,12 @@ export class AVLTree extends BST {
     /**
      * The function overrides the remove method of a binary tree and performs additional operations to balance the tree after
      * deletion.
-     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
+     * @param {BinaryTreeNodeKey} key - The `key` parameter represents the identifier of the binary tree node that needs to be
      * removed.
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(id) {
-        const deletedResults = super.remove(id);
+    remove(key) {
+        const deletedResults = super.remove(key);
         for (const { needBalanced } of deletedResults) {
             if (needBalanced) {
                 this._balancePath(needBalanced);

package/lib/data-structures/binary-tree/binary-tree.d.ts

@@ -5,11 +5,11 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeId, BinaryTreeNodeNested, BinaryTreeOptions } from '../../types';
+import type { BinaryTreeNodeKey, BinaryTreeNodeNested, BinaryTreeOptions } from '../../types';
 import { AbstractBinaryTree, AbstractBinaryTreeNode } from './abstract-binary-tree';
 import { IBinaryTree, IBinaryTreeNode } from '../../interfaces';
 export declare class BinaryTreeNode<V = any, NEIGHBOR extends BinaryTreeNode<V, NEIGHBOR> = BinaryTreeNodeNested<V>> extends AbstractBinaryTreeNode<V, NEIGHBOR> implements IBinaryTreeNode<V, NEIGHBOR> {
-    constructor(id: BinaryTreeNodeId, val?: V);
+    constructor(key: BinaryTreeNodeKey, val?: V);
 }
 export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode> extends AbstractBinaryTree<N> implements IBinaryTree<N> {
     /**
@@ -21,11 +21,11 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
     constructor(options?: BinaryTreeOptions);
     /**
      * The function creates a new binary tree node with an optional value.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
-     * `BinaryTreeNodeId`, which represents the unique identifier for each node in the binary tree.
+     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is of type
+     * `BinaryTreeNodeKey`, which represents the unique identifier for each node in the binary tree.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
      * stored in the node.
-     * @returns a new instance of a BinaryTreeNode with the specified id and value.
+     * @returns a new instance of a BinaryTreeNode with the specified key and value.
      */
-    createNode(id: BinaryTreeNodeId, val?: N['val']): N;
+    createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
 }

package/lib/data-structures/binary-tree/binary-tree.js

@@ -7,8 +7,8 @@
  */
 import { AbstractBinaryTree, AbstractBinaryTreeNode } from './abstract-binary-tree';
 export class BinaryTreeNode extends AbstractBinaryTreeNode {
-    constructor(id, val) {
-        super(id, val);
+    constructor(key, val) {
+        super(key, val);
     }
 }
 export class BinaryTree extends AbstractBinaryTree {
@@ -23,13 +23,13 @@ export class BinaryTree extends AbstractBinaryTree {
     }
     /**
      * The function creates a new binary tree node with an optional value.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
-     * `BinaryTreeNodeId`, which represents the unique identifier for each node in the binary tree.
+     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is of type
+     * `BinaryTreeNodeKey`, which represents the unique identifier for each node in the binary tree.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
      * stored in the node.
-     * @returns a new instance of a BinaryTreeNode with the specified id and value.
+     * @returns a new instance of a BinaryTreeNode with the specified key and value.
      */
-    createNode(id, val) {
-        return new BinaryTreeNode(id, val);
+    createNode(key, val) {
+        return new BinaryTreeNode(key, val);
     }
 }

package/lib/data-structures/binary-tree/bst.d.ts

@@ -5,12 +5,12 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTNodeNested, BSTOptions } from '../../types';
+import type { BinaryTreeNodeKey, BinaryTreeNodePropertyName, BSTComparator, BSTNodeNested, BSTOptions } from '../../types';
 import { CP } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBST, IBSTNode } from '../../interfaces';
 export declare class BSTNode<V = any, NEIGHBOR extends BSTNode<V, NEIGHBOR> = BSTNodeNested<V>> extends BinaryTreeNode<V, NEIGHBOR> implements IBSTNode<V, NEIGHBOR> {
-    constructor(id: BinaryTreeNodeId, val?: V);
+    constructor(key: BinaryTreeNodeKey, val?: V);
 }
 export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBST<N> {
     /**
@@ -19,87 +19,87 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      */
     constructor(options?: BSTOptions);
     /**
-     * The function creates a new binary search tree node with the given id and value.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * The function creates a new binary search tree node with the given key and value.
+     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is used to uniquely
      * identify each node in the binary tree.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
      * that will be stored in the node.
-     * @returns a new instance of the BSTNode class with the specified id and value.
+     * @returns a new instance of the BSTNode class with the specified key and value.
      */
-    createNode(id: BinaryTreeNodeId, val?: N['val']): N;
+    createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     /**
      * The `add` function adds a new node to a binary search tree, either by creating a new node or by updating an existing
      * node with the same ID.
-     * @param {BinaryTreeNodeId | N | null} idOrNode - The `idOrNode` parameter can be either a `BinaryTreeNodeId` or a `N`
+     * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a `BinaryTreeNodeKey` or a `N`
      * (which represents a binary tree node) or `null`.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the new node
      * being added to the binary search tree.
      * @returns The function `add` returns the inserted node (`inserted`) which can be of type `N`, `null`, or `undefined`.
      */
-    add(idOrNode: BinaryTreeNodeId | N | null, val?: N['val']): N | null | undefined;
+    add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
     /**
      * The `addMany` function overrides the base class method to add multiple nodes to a binary search tree in a balanced
      * manner.
-     * @param {[BinaryTreeNodeId | N , N['val']][]} idsOrNodes - The `idsOrNodes` parameter in the `addMany` function is an array of
-     * `BinaryTreeNodeId` or `N` (node) objects, or `null` values. It represents the nodes or node IDs that need to be added
+     * @param {[BinaryTreeNodeKey | N , N['val']][]} idsOrNodes - The `idsOrNodes` parameter in the `addMany` function is an array of
+     * `BinaryTreeNodeKey` or `N` (node) objects, or `null` values. It represents the nodes or node IDs that need to be added
      * to the binary search tree.
      * @param {N['val'][]} data - The values of tree nodes
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(idsOrNodes: (BinaryTreeNodeId | null)[] | (N | null)[], data?: N['val'][], isBalanceAdd?: boolean): (N | null | undefined)[];
+    addMany(idsOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: N['val'][], isBalanceAdd?: boolean): (N | null | undefined)[];
     /**
      * The function returns the first node in a binary tree that matches the given property name and value.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
      * generic type `N`. It represents the property of the binary tree node that you want to search for.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'id'`.
-     * @returns The method is returning either a BinaryTreeNodeId or N (generic type) or null.
+     * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'key'`.
+     * @returns The method is returning either a BinaryTreeNodeKey or N (generic type) or null.
      */
-    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+    get(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): N | null;
     /**
-     * The function returns the id of the rightmost node if the comparison between two values is less than, the id of the
-     * leftmost node if the comparison is greater than, and the id of the rightmost node otherwise.
-     * @returns The method `lastKey()` returns the id of the rightmost node in the binary tree if the comparison between
-     * the values at index 0 and 1 is less than, otherwise it returns the id of the leftmost node. If the comparison is
-     * equal, it returns the id of the rightmost node. If there are no nodes in the tree, it returns 0.
+     * The function returns the key of the rightmost node if the comparison between two values is less than, the key of the
+     * leftmost node if the comparison is greater than, and the key of the rightmost node otherwise.
+     * @returns The method `lastKey()` returns the key of the rightmost node in the binary tree if the comparison between
+     * the values at index 0 and 1 is less than, otherwise it returns the key of the leftmost node. If the comparison is
+     * equal, it returns the key of the rightmost node. If there are no nodes in the tree, it returns 0.
      */
-    lastKey(): BinaryTreeNodeId;
+    lastKey(): BinaryTreeNodeKey;
     /**
      * The function `getNodes` returns an array of nodes in a binary tree that match a given property value.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or an
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or an
      * `N` type. It represents the property of the binary tree node that you want to compare with.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to use for comparison. If not provided, it defaults to `'id'`.
+     * specifies the property name to use for comparison. If not provided, it defaults to `'key'`.
      * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
      * return only one node that matches the given `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne`
      * is set to `true`, the function will return an array with only one node (if
      * @returns an array of nodes (type N).
      */
-    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+    getNodes(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
     /**
      * The `lesserSum` function calculates the sum of property values in a binary tree for nodes that have a property value
      * less than a given node.
-     * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
+     * @param {N | BinaryTreeNodeKey | null} beginNode - The `beginNode` parameter can be one of the following:
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to use for calculating the sum. If not provided, it defaults to `'id'`.
+     * specifies the property name to use for calculating the sum. If not provided, it defaults to `'key'`.
      * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
      * binary tree that have a lesser value than the specified `beginNode` based on the `propertyName`.
      */
-    lesserSum(beginNode: N | BinaryTreeNodeId | null, propertyName?: BinaryTreeNodePropertyName): number;
+    lesserSum(beginNode: N | BinaryTreeNodeKey | null, propertyName?: BinaryTreeNodePropertyName): number;
     /**
      * The `allGreaterNodesAdd` function adds a delta value to the specified property of all nodes in a binary tree that
      * have a greater value than a given node.
-     * @param {N | BinaryTreeNodeId | null} node - The `node` parameter can be either of type `N` (a generic type),
-     * `BinaryTreeNodeId`, or `null`. It represents the node in the binary tree to which the delta value will be added.
+     * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be either of type `N` (a generic type),
+     * `BinaryTreeNodeKey`, or `null`. It represents the node in the binary tree to which the delta value will be added.
      * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
      * each greater node should be increased.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property name of the nodes in the binary tree that you want to update. If not provided, it defaults to
-     * 'id'.
+     * 'key'.
      * @returns a boolean value.
      */
-    allGreaterNodesAdd(node: N | BinaryTreeNodeId | null, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    allGreaterNodesAdd(node: N | BinaryTreeNodeKey | null, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
     /**
      * Balancing Adjustment:
      * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
@@ -124,10 +124,10 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
     /**
      * The function compares two binary tree node IDs using a comparator function and returns whether the first ID is
      * greater than, less than, or equal to the second ID.
-     * @param {BinaryTreeNodeId} a - a is a BinaryTreeNodeId, which represents the identifier of a binary tree node.
-     * @param {BinaryTreeNodeId} b - The parameter "b" in the above code refers to a BinaryTreeNodeId.
+     * @param {BinaryTreeNodeKey} a - a is a BinaryTreeNodeKey, which represents the identifier of a binary tree node.
+     * @param {BinaryTreeNodeKey} b - The parameter "b" in the above code refers to a BinaryTreeNodeKey.
      * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater than), CP.lt (less
      * than), or CP.eq (equal).
      */
-    protected _compare(a: BinaryTreeNodeId, b: BinaryTreeNodeId): CP;
+    protected _compare(a: BinaryTreeNodeKey, b: BinaryTreeNodeKey): CP;
 }