data-structure-typed 1.34.7 → 1.34.8

package/lib/data-structures/graph/undirected-graph.js

@@ -10,21 +10,21 @@ import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 export class UndirectedVertex extends AbstractVertex {
     /**
      * The constructor function initializes a vertex with an optional value.
-     * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex. It is
+     * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex within a graph or network.
      * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
-    constructor(id, val) {
-        super(id, val);
+    constructor(key, val) {
+        super(key, val);
     }
 }
 export class UndirectedEdge extends AbstractEdge {
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
-     * @param {VertexId} v1 - The first vertex ID of the edge.
-     * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
+     * @param {VertexKey} v1 - The first vertex ID of the edge.
+     * @param {VertexKey} v2 - The parameter `v2` is a `VertexKey`, which represents the identifier of the second vertex in a
      * graph edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
      * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store a value associated
@@ -54,20 +54,20 @@ export class UndirectedGraph extends AbstractGraph {
     }
     /**
      * The function creates a new vertex with an optional value and returns it.
-     * @param {VertexId} id - The `id` parameter is the unique identifier for the vertex. It is used to distinguish one
+     * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is used to distinguish one
      * vertex from another in the graph.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the vertex. If a value is provided,
-     * it will be used as the value of the vertex. If no value is provided, the `id` parameter will be used as the value of
+     * it will be used as the value of the vertex. If no value is provided, the `key` parameter will be used as the value of
      * the vertex.
      * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `V`.
      */
-    createVertex(id, val) {
-        return new UndirectedVertex(id, val !== null && val !== void 0 ? val : id);
+    createVertex(key, val) {
+        return new UndirectedVertex(key, val !== null && val !== void 0 ? val : key);
     }
     /**
      * The function creates an undirected edge between two vertices with an optional weight and value.
-     * @param {VertexId} v1 - The parameter `v1` represents the first vertex of the edge.
-     * @param {VertexId} v2 - The parameter `v2` represents the second vertex of the edge.
+     * @param {VertexKey} v1 - The parameter `v1` represents the first vertex of the edge.
+     * @param {VertexKey} v2 - The parameter `v2` represents the second vertex of the edge.
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
      * no weight is provided, it defaults to 1.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type and
@@ -79,10 +79,10 @@ export class UndirectedGraph extends AbstractGraph {
     }
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
-     * @param {V | null | VertexId} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `V` (vertex
-     * object), `null`, or `VertexId` (a string or number representing the ID of a vertex).
-     * @param {V | null | VertexId} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
-     * object), `null`, or `VertexId` (vertex ID).
+     * @param {V | null | VertexKey} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
+     * @param {V | null | VertexKey} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * object), `null`, or `VertexKey` (vertex ID).
      * @returns an edge (E) or null.
      */
     getEdge(v1, v2) {
@@ -92,16 +92,16 @@ export class UndirectedGraph extends AbstractGraph {
             const vertex1 = this._getVertex(v1);
             const vertex2 = this._getVertex(v2);
             if (vertex1 && vertex2) {
-                edges = (_a = this._edges.get(vertex1)) === null || _a === void 0 ? void 0 : _a.filter(e => e.vertices.includes(vertex2.id));
+                edges = (_a = this._edges.get(vertex1)) === null || _a === void 0 ? void 0 : _a.filter(e => e.vertices.includes(vertex2.key));
             }
         }
         return edges ? edges[0] || null : null;
     }
     /**
      * The function removes an edge between two vertices in a graph and returns the removed edge.
-     * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
-     * @param {V | VertexId} v2 - V | VertexId - This parameter can be either a vertex object (V) or a vertex ID
-     * (VertexId). It represents the second vertex of the edge that needs to be removed.
+     * @param {V | VertexKey} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexKey`).
+     * @param {V | VertexKey} v2 - V | VertexKey - This parameter can be either a vertex object (V) or a vertex ID
+     * (VertexKey). It represents the second vertex of the edge that needs to be removed.
      * @returns the removed edge (E) if it exists, or null if either of the vertices (V) does not exist.
      */
     removeEdgeBetween(v1, v2) {
@@ -113,11 +113,11 @@ export class UndirectedGraph extends AbstractGraph {
         const v1Edges = this._edges.get(vertex1);
         let removed = null;
         if (v1Edges) {
-            removed = arrayRemove(v1Edges, (e) => e.vertices.includes(vertex2.id))[0] || null;
+            removed = arrayRemove(v1Edges, (e) => e.vertices.includes(vertex2.key))[0] || null;
         }
         const v2Edges = this._edges.get(vertex2);
         if (v2Edges) {
-            arrayRemove(v2Edges, (e) => e.vertices.includes(vertex1.id));
+            arrayRemove(v2Edges, (e) => e.vertices.includes(vertex1.key));
         }
         return removed;
     }
@@ -132,13 +132,13 @@ export class UndirectedGraph extends AbstractGraph {
     /**
      * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
      * vertex.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
      * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
      * edges connected to that vertex.
      */
-    degreeOf(vertexOrId) {
+    degreeOf(vertexOrKey) {
         var _a;
-        const vertex = this._getVertex(vertexOrId);
+        const vertex = this._getVertex(vertexOrKey);
         if (vertex) {
             return ((_a = this._edges.get(vertex)) === null || _a === void 0 ? void 0 : _a.length) || 0;
         }
@@ -148,12 +148,12 @@ export class UndirectedGraph extends AbstractGraph {
     }
     /**
      * The function returns the edges of a given vertex or vertex ID.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`. A `VertexId` is a
+     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`. A `VertexKey` is a
      * unique identifier for a vertex in a graph, while `V` represents the type of the vertex.
      * @returns an array of edges.
      */
-    edgesOf(vertexOrId) {
-        const vertex = this._getVertex(vertexOrId);
+    edgesOf(vertexOrKey) {
+        const vertex = this._getVertex(vertexOrKey);
         if (vertex) {
             return this._edges.get(vertex) || [];
         }
@@ -176,17 +176,17 @@ export class UndirectedGraph extends AbstractGraph {
     }
     /**
      * The function "getNeighbors" returns an array of neighboring vertices for a given vertex or vertex ID.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
-     * (`VertexId`).
+     * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexKey`).
      * @returns an array of vertices (V[]).
      */
-    getNeighbors(vertexOrId) {
+    getNeighbors(vertexOrKey) {
         const neighbors = [];
-        const vertex = this._getVertex(vertexOrId);
+        const vertex = this._getVertex(vertexOrKey);
         if (vertex) {
             const neighborEdges = this.edgesOf(vertex);
             for (const edge of neighborEdges) {
-                const neighbor = this._getVertex(edge.vertices.filter(e => e !== vertex.id)[0]);
+                const neighbor = this._getVertex(edge.vertices.filter(e => e !== vertex.key)[0]);
                 if (neighbor) {
                     neighbors.push(neighbor);
                 }

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

@@ -1,8 +1,8 @@
 export declare class TreeNode<V = any> {
-    constructor(id: string, value?: V, children?: TreeNode<V>[]);
-    private _id;
-    get id(): string;
-    set id(value: string);
+    constructor(key: string, value?: V, children?: TreeNode<V>[]);
+    private _key;
+    get key(): string;
+    set key(value: string);
     private _value?;
     get value(): V | undefined;
     set value(value: V | undefined);

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

@@ -1,14 +1,14 @@
 export class TreeNode {
-    constructor(id, value, children) {
-        this._id = id;
+    constructor(key, value, children) {
+        this._key = key;
         this._value = value || undefined;
         this._children = children || [];
     }
-    get id() {
-        return this._id;
+    get key() {
+        return this._key;
     }
-    set id(value) {
-        this._id = value;
+    set key(value) {
+        this._key = value;
     }
     get value() {
         return this._value;

package/lib/interfaces/abstract-binary-tree.d.ts

@@ -1,8 +1,8 @@
-import { AbstractBinaryTreeNodeProperties, AbstractBinaryTreeNodeProperty, BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, FamilyPosition, LoopType, NodeOrPropertyName } from '../types';
+import { AbstractBinaryTreeNodeProperties, AbstractBinaryTreeNodeProperty, BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodePropertyName, DFSOrderPattern, FamilyPosition, LoopType, NodeOrPropertyName } from '../types';
 import { AbstractBinaryTreeNode } from '../data-structures';
 export interface IAbstractBinaryTreeNode<T, NEIGHBOR extends IAbstractBinaryTreeNode<T, NEIGHBOR>> {
-    get id(): BinaryTreeNodeId;
-    set id(v: BinaryTreeNodeId);
+    get key(): BinaryTreeNodeKey;
+    set key(v: BinaryTreeNodeKey);
     get val(): T | undefined;
     set val(v: T | undefined);
     get left(): NEIGHBOR | null | undefined;
@@ -16,9 +16,9 @@ export interface IAbstractBinaryTreeNode<T, NEIGHBOR extends IAbstractBinaryTree
     set height(v: number);
 }
 export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N>> {
-    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null;
+    createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N | null;
     get loopType(): LoopType;
-    get visitedId(): BinaryTreeNodeId[];
+    get visitedKey(): BinaryTreeNodeKey[];
     get visitedVal(): Array<N['val']>;
     get visitedNode(): N[];
     get root(): N | null;
@@ -26,17 +26,17 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
     swapLocation(srcNode: N, destNode: N): N;
     clear(): void;
     isEmpty(): boolean;
-    add(id: BinaryTreeNodeId | N, val?: N['val']): N | null | undefined;
-    addMany(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N['val'][]): (N | null | undefined)[];
-    fill(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N[] | Array<N['val']>): boolean;
-    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    add(key: BinaryTreeNodeKey | N, val?: N['val']): N | null | undefined;
+    addMany(idsOrNodes: (BinaryTreeNodeKey | N | null)[], data?: N['val'][]): (N | null | undefined)[];
+    fill(idsOrNodes: (BinaryTreeNodeKey | N | null)[], data?: N[] | Array<N['val']>): boolean;
+    remove(key: BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     getDepth(node: N): number;
     getHeight(beginRoot?: N | null): number;
     getMinHeight(beginRoot?: N | null): number;
     isPerfectlyBalanced(beginRoot?: N | null): boolean;
-    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
-    has(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): boolean;
-    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+    getNodes(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+    has(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): boolean;
+    get(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): N | null;
     getPathToRoot(node: N): N[];
     getLeftMost(): N | null;
     getLeftMost(node: N): N;
@@ -49,39 +49,39 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
     getSubTreeSize(subTreeRoot: N | null | undefined): number;
     subTreeSum(subTreeRoot: N, propertyName?: BinaryTreeNodePropertyName): number;
     subTreeAdd(subTreeRoot: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
-    BFS(): BinaryTreeNodeId[];
-    BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
+    BFS(): BinaryTreeNodeKey[];
+    BFS(nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
     BFS(nodeOrPropertyName: 'val'): N['val'][];
     BFS(nodeOrPropertyName: 'node'): N[];
     BFS(nodeOrPropertyName: 'count'): number[];
     BFS(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
-    DFS(): BinaryTreeNodeId[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    DFS(): BinaryTreeNodeKey[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
     DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
     DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
     DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
     DFS(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
-    DFSIterative(): BinaryTreeNodeId[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    DFSIterative(): BinaryTreeNodeKey[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
     DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
     DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
     DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
     DFSIterative(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
-    levelIterative(node: N | null): BinaryTreeNodeId[];
-    levelIterative(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    levelIterative(node: N | null): BinaryTreeNodeKey[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
     levelIterative(node: N | null, nodeOrPropertyName?: 'val'): N['val'][];
     levelIterative(node: N | null, nodeOrPropertyName?: 'node'): N[];
     levelIterative(node: N | null, nodeOrPropertyName?: 'count'): number[];
     levelIterative(node: N | null, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
-    listLevels(node: N | null): BinaryTreeNodeId[][];
-    listLevels(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
+    listLevels(node: N | null): BinaryTreeNodeKey[][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[][];
     listLevels(node: N | null, nodeOrPropertyName?: 'val'): N['val'][][];
     listLevels(node: N | null, nodeOrPropertyName?: 'node'): N[][];
     listLevels(node: N | null, nodeOrPropertyName?: 'count'): number[][];
     listLevels(node: N | null, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperty<N>[][];
     getPredecessor(node: N): N;
-    morris(): BinaryTreeNodeId[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    morris(): BinaryTreeNodeKey[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];

package/lib/interfaces/abstract-graph.d.ts

@@ -1,17 +1,17 @@
-import { VertexId } from '../types';
+import { VertexKey } from '../types';
 export interface IAbstractGraph<V, E> {
-    hasVertex(vertexOrId: V | VertexId): boolean;
-    addVertex(id: VertexId, val?: V): boolean;
-    removeVertex(vertexOrId: V | VertexId): boolean;
-    removeAllVertices(vertices: V[] | VertexId[]): boolean;
-    degreeOf(vertexOrId: V | VertexId): number;
-    edgesOf(vertexOrId: V | VertexId): E[];
-    hasEdge(src: V | VertexId, dest: V | VertexId): boolean;
-    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    hasVertex(vertexOrKey: V | VertexKey): boolean;
+    addVertex(key: VertexKey, val?: V): boolean;
+    removeVertex(vertexOrKey: V | VertexKey): boolean;
+    removeAllVertices(vertices: V[] | VertexKey[]): boolean;
+    degreeOf(vertexOrKey: V | VertexKey): number;
+    edgesOf(vertexOrKey: V | VertexKey): E[];
+    hasEdge(src: V | VertexKey, dest: V | VertexKey): boolean;
+    getEdge(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null;
     edgeSet(): E[];
-    addEdge(src: V | VertexId, dest: V | VertexId, weight: number, val: E): boolean;
+    addEdge(src: V | VertexKey, dest: V | VertexKey, weight: number, val: E): boolean;
     removeEdge(edge: E): E | null;
-    setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
-    getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
-    getNeighbors(vertexOrId: V | VertexId): V[];
+    setEdgeWeight(srcOrKey: V | VertexKey, destOrKey: V | VertexKey, weight: number): boolean;
+    getMinPathBetween(v1: V | VertexKey, v2: V | VertexKey, isWeight?: boolean): V[] | null;
+    getNeighbors(vertexOrKey: V | VertexKey): V[];
 }

package/lib/interfaces/avl-tree.d.ts

@@ -1,8 +1,8 @@
 import { AVLTreeNode } from '../data-structures';
 import { IBST, IBSTNode } from './bst';
-import { BinaryTreeDeletedResult, BinaryTreeNodeId } from '../types';
+import { BinaryTreeDeletedResult, BinaryTreeNodeKey } from '../types';
 export type IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> = IBSTNode<T, NEIGHBOR>;
 export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
-    add(id: BinaryTreeNodeId, val?: N['val'] | null): N | null | undefined;
-    remove(id: BinaryTreeNodeId): BinaryTreeDeletedResult<N>[];
+    add(key: BinaryTreeNodeKey, val?: N['val'] | null): N | null | undefined;
+    remove(key: BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
 }

package/lib/interfaces/bst.d.ts

@@ -1,15 +1,15 @@
 import { BSTNode } from '../data-structures';
 import { IBinaryTree, IBinaryTreeNode } from './binary-tree';
-import { BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName } from '../types';
+import { BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodePropertyName } from '../types';
 export type IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> = IBinaryTreeNode<T, NEIGHBOR>;
 export interface IBST<N extends BSTNode<N['val'], N>> extends IBinaryTree<N> {
-    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
-    add(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N | null | undefined;
-    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
-    lastKey(): BinaryTreeNodeId;
-    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
-    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
-    lesserSum(id: BinaryTreeNodeId, propertyName?: BinaryTreeNodePropertyName): number;
+    createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N;
+    add(key: BinaryTreeNodeKey, val?: N['val'] | null, count?: number): N | null | undefined;
+    get(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+    lastKey(): BinaryTreeNodeKey;
+    remove(key: BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    getNodes(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+    lesserSum(key: BinaryTreeNodeKey, propertyName?: BinaryTreeNodePropertyName): number;
     allGreaterNodesAdd(node: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
     perfectlyBalance(): boolean;
     isAVLBalanced(): boolean;

package/lib/interfaces/directed-graph.d.ts

@@ -1,12 +1,12 @@
-import { VertexId } from '../types';
+import { VertexKey } from '../types';
 import { IAbstractGraph } from './abstract-graph';
 export interface IDirectedGraph<V, E> extends IAbstractGraph<V, E> {
     incomingEdgesOf(vertex: V): E[];
     outgoingEdgesOf(vertex: V): E[];
-    inDegreeOf(vertexOrId: V | VertexId): number;
-    outDegreeOf(vertexOrId: V | VertexId): number;
+    inDegreeOf(vertexOrKey: V | VertexKey): number;
+    outDegreeOf(vertexOrKey: V | VertexKey): number;
     getEdgeSrc(e: E): V | null;
     getEdgeDest(e: E): V | null;
-    removeEdgeSrcToDest(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-    removeEdgesBetween(v1: V | VertexId, v2: V | VertexId): E[];
+    removeEdgeSrcToDest(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null;
+    removeEdgesBetween(v1: V | VertexKey, v2: V | VertexKey): E[];
 }

package/lib/interfaces/rb-tree.d.ts

@@ -1,7 +1,7 @@
 import { RBTreeNode } from '../data-structures';
 import { IBST, IBSTNode } from './bst';
-import { BinaryTreeNodeId } from '../types';
+import { BinaryTreeNodeKey } from '../types';
 export type IRBTreeNode<T, NEIGHBOR extends IRBTreeNode<T, NEIGHBOR>> = IBSTNode<T, NEIGHBOR>;
 export interface IRBTree<N extends RBTreeNode<N['val'], N>> extends IBST<N> {
-    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+    createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N;
 }

package/lib/interfaces/undirected-graph.d.ts

@@ -1,5 +1,5 @@
-import { VertexId } from '../types';
+import { VertexKey } from '../types';
 import { IAbstractGraph } from './abstract-graph';
 export interface IUNDirectedGraph<V, E> extends IAbstractGraph<V, E> {
-    removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null;
+    removeEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null;
 }

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

@@ -18,15 +18,15 @@ export declare enum FamilyPosition {
     ISOLATED = "ISOLATED",
     MAL_NODE = "MAL_NODE"
 }
-export type BinaryTreeNodePropertyName = 'id' | 'val';
+export type BinaryTreeNodePropertyName = 'key' | 'val';
 export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
 export type DFSOrderPattern = 'in' | 'pre' | 'post';
-export type BinaryTreeNodeId = number;
+export type BinaryTreeNodeKey = number;
 export type BinaryTreeDeletedResult<N> = {
     deleted: N | null | undefined;
     needBalanced: N | null;
 };
-export type AbstractBinaryTreeNodeProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeId;
+export type AbstractBinaryTreeNodeProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeKey;
 export type AbstractBinaryTreeNodeProperties<N extends AbstractBinaryTreeNode<N['val'], N>> = AbstractBinaryTreeNodeProperty<N>[];
 export type AbstractBinaryTreeNodeNested<T> = AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type AbstractBinaryTreeOptions = {

package/lib/types/data-structures/abstract-graph.d.ts

@@ -1,5 +1,5 @@
-export type VertexId = string | number;
-export type EdgeId = string;
+export type VertexKey = string | number;
+export type EdgeKey = string;
 export type DijkstraResult<V> = {
     distMap: Map<V, number>;
     distPaths?: Map<V, V[]>;

package/lib/types/data-structures/bst.d.ts

@@ -1,7 +1,7 @@
 import { BSTNode } from '../../data-structures/binary-tree';
 import type { BinaryTreeOptions } from './binary-tree';
-import { BinaryTreeNodeId } from './abstract-binary-tree';
-export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
+import { BinaryTreeNodeKey } from './abstract-binary-tree';
+export type BSTComparator = (a: BinaryTreeNodeKey, b: BinaryTreeNodeKey) => number;
 export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTOptions = BinaryTreeOptions & {
     comparator?: BSTComparator;

package/lib/types/data-structures/tree-multiset.d.ts

@@ -1,4 +1,4 @@
 import { TreeMultisetNode } from '../../data-structures/binary-tree';
 import { AVLTreeOptions } from './avl-tree';
 export type TreeMultisetNodeNested<T> = TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type TreeMultisetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeById'> & {};
+export type TreeMultisetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeByKey'> & {};

package/lib/types/utils/validate-type.d.ts

@@ -1,19 +1,19 @@
 export type KeyValueObject = {
     [key: string]: any;
 };
-export type KeyValueObjectWithId = {
+export type KeyValueObjectWithKey = {
     [key: string]: any;
-    id: string | number | symbol;
+    key: string | number | symbol;
 };
 export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
-export type ObjectWithoutId = Omit<KeyValueObject, 'id'>;
-export type ObjectWithNonNumberId = {
+export type ObjectWithoutKey = Omit<KeyValueObject, 'key'>;
+export type ObjectWithNonNumberKey = {
     [key: string]: any;
-    id: string | boolean | symbol | null | object | undefined;
+    key: string | boolean | symbol | null | object | undefined;
 };
-export type ObjectWithNumberId = {
+export type ObjectWithNumberKey = {
     [key: string]: any;
-    id: number;
+    key: number;
 };
-export type RestrictValById = NonNumberNonObjectButDefined | ObjectWithoutId | ObjectWithNonNumberId | ObjectWithNumberId;
+export type RestrictValByKey = NonNumberNonObjectButDefined | ObjectWithoutKey | ObjectWithNonNumberKey | ObjectWithNumberKey;
 export type DummyAny = string | number | boolean | null | undefined | object | symbol | void | ((...args: []) => any) | never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.34.7",
+  "version": "1.34.8",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/index.js",
   "module": "lib/index.js",

package/scripts/rename_clear_files.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# iterate the directory to rename and clear content of files
+rename_and_clear_files() {
+  local directory="$1"
+  local extension="$2"
+  local new_prefix="$3"
+
+  for file in "$directory"/*; do
+    if [ -d "$file" ]; then
+      rename_and_clear_files "$file" "$extension" "$new_prefix"
+    elif [ -f "$file" ] && [[ "$file" == *"$extension" ]]; then
+      filename=$(basename "$file" "$extension")
+      new_name="$directory/${filename}${new_prefix}${extension}"
+      mv "$file" "$new_name"
+      echo "Renamed $file to $new_name"
+      > "$new_name"  # clear content of file
+    fi
+  done
+}
+
+# check if directory, extension and prefix were provided
+if [ -z "$1" ] || [ -z "$2" ] || [ -z "$3" ]; then
+  echo "Usage: $0 <directory> <extension> <new_prefix>"
+  exit 1
+fi
+
+# evoke the recursive function to rename and clear files
+rename_and_clear_files "$1" "$2" "$3"