data-structure-typed 2.2.7 → 2.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "2.2.7",
+  "version": "2.2.8",
   "description": "Standard data structure",
   "browser": "dist/umd/data-structure-typed.min.js",
   "umd:main": "dist/umd/data-structure-typed.min.js",
@@ -38,21 +38,21 @@
     "npm": ">=6.14.0"
   },
   "scripts": {
-    "build": "npm run build:ecu && npm run build:docs-class",
-    "build:node": "tsup --config tsup.node.config.js",
-    "build:leetcode": "tsup --config tsup.leetcode.config.js",
+    "build": "npm run build:ecut && npm run build:docs-class",
+    "build:node": "tsup",
+    "build:umd": "tsup --config tsup.umd.config.js",
     "build:types": "rm -rf dist/types && tsc -p tsconfig.types.json",
-    "build:umd": "tsup",
-    "build:ecu": "npm run build:node && npm run build:types && npm run build:umd",
+    "build:ecut": "npm run build:node && npm run build:types && npm run build:umd",
+    "build:leetcode": "tsup --config tsup.leetcode.config.js",
     "build:docs": "npm run gen:examples && typedoc --out docs ./src",
     "build:docs-class": "npm run gen:examples && typedoc --out docs ./src/data-structures",
     "gen:examples": "ts-node scripts/test-to-example.ts",
     "test:in-band": "jest --runInBand",
     "test": "npm run test:in-band",
     "test:integration": "npm run update:subs && jest --config jest.integration.config.js && tsc test/integration/compile.test.ts && node test/integration/compile.mjs",
-    "test:perf": "npm run build:ecu && ts-node test/performance/benchmark-runner.ts --isolate --gc --cooldown-ms=80",
+    "test:perf": "npm run build:ecut && ts-node test/performance/benchmark-runner.ts --isolate --gc --cooldown-ms=80",
     "check": "npm run check:src && npm run check:test",
-    "check:src": "tsc -p tsconfig.test.json --noEmit",
+    "check:src": "tsc --noEmit",
     "check:test": "tsc -p tsconfig.test.json --noEmit",
     "check:circular-refs": "dependency-cruiser src",
     "lint:src": "eslint --fix 'src/**/*.{js,ts}'",
@@ -102,7 +102,7 @@
     "benchmark": "^2.1.4",
     "binary-tree-typed": "^1.54.3",
     "bst-typed": "^1.54.3",
-    "data-structure-typed": "^2.2.6",
+    "data-structure-typed": "^2.2.7",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",
@@ -124,178 +124,55 @@
     "typescript": "^5.6.3"
   },
   "keywords": [
-    "data",
-    "structure",
-    "structures",
-    "data structure",
-    "datastructure",
-    "data-structure",
-    "data structures",
-    "datastructures",
-    "data-structures",
-    "in data structures",
-    "in data structure",
-    "binary",
-    "depth",
-    "breadth",
-    "first",
-    "search",
-    "index",
-    "avl",
-    "red",
-    "black",
-    "redblack",
-    "RB",
-    "segment",
-    "prefix",
-    "tree",
-    "multi",
-    "map",
-    "set",
-    "multiset",
-    "multimap",
-    "directed",
-    "undirected",
-    "graph",
-    "min",
-    "max",
-    "heap",
-    "priority",
-    "queue",
-    "singly",
-    "doubly",
-    "linked",
-    "list",
-    "js",
-    "ts",
-    "javascript",
-    "typscript",
-    "Node.js",
-    "NodeJS",
-    "c++",
-    "std",
-    "C++ STL",
-    "c++stl",
-    "C++ std",
-    "stl",
-    "std::",
-    "Python",
-    "collections",
-    "Python Collections",
-    "pythoncollections",
-    "python-collections",
-    "C#",
-    "System.Collections.Generic",
-    "collection",
-    "java.util",
-    "Java",
-    "util",
+    "data structures typescript",
+    "data structures javascript",
+    "typescript data structures",
+    "javascript data structures",
+    "data-structure library",
+    "algorithm library",
     "binary search tree",
-    "binarysearchtree",
-    "binary-search-tree",
-    "BST",
-    "binary tree",
-    "binarytree",
-    "binary-tree",
+    "AVL tree",
     "red black tree",
-    "redblacktree",
-    "redblack tree",
-    "red-black-tree",
-    "redblack-tree",
-    "trie",
-    "prefix tree",
-    "prefixtree",
-    "prefix-tree",
-    "avl tree",
-    "avltree",
-    "avl-tree",
-    "tree set",
-    "treeset",
-    "tree-set",
-    "tree multiset",
-    "treemultiset",
-    "tree-multiset",
-    "tree map",
-    "treemap",
-    "tree-map",
-    "tree multimap",
-    "treemultimap",
-    "tree-multimap",
-    "binary indexed tree",
-    "binaryindexedtree",
-    "binary-indexed-tree",
-    "segment tree",
-    "segmenttree",
-    "segment-tree",
-    "sort",
-    "sorted",
-    "order",
-    "ordered",
-    "algorithm",
-    "morris",
-    "Morris",
-    "bellman ford",
-    "bellmanford",
-    "bellman-ford",
-    "dijkstra",
-    "Dijkstra",
-    "floyd warshall",
-    "floydwarshall",
-    "floyd-warshall",
-    "tarjan",
-    "tarjan's",
-    "dfs",
-    "depth first Search",
-    "depthfirstSearch",
-    "depth-first-Search",
-    "bfs",
-    "breadth first search",
-    "breadthfirstsearch",
-    "dfs iterative",
-    "recursive",
-    "iterative",
+    "balanced tree",
+    "binary tree",
+    "BST",
+    "graph algorithm",
     "directed graph",
-    "directedgraph",
-    "directed-graph",
     "undirected graph",
-    "undirectedgraph",
-    "undirected-graph",
+    "heap",
+    "priority queue",
     "min heap",
-    "minheap",
-    "min-heap",
     "max heap",
-    "maxheap",
-    "max-heap",
-    "priority queue",
-    "priorityqueue",
-    "priority-queue",
-    "max priority queue",
-    "maxpriorityqueue",
-    "max-priority-queue",
-    "min priority queue",
-    "minpriorityqueue",
-    "min-priority-queue",
-    "hash",
-    "map",
-    "hash map",
-    "hashmap",
-    "hash-map",
+    "queue",
     "deque",
+    "stack",
     "linked list",
-    "linkedlist",
-    "linked-list",
     "singly linked list",
-    "singlylinkedlist",
-    "singly-linked-list",
     "doubly linked list",
-    "doublylinkedlist",
-    "doubly-linked-list",
-    "stack",
+    "trie",
+    "hash map",
+    "hash table",
+    "tree multimap",
+    "tree multiset",
+    "tree map",
+    "tree set",
+    "ordered set",
+    "ordered map",
+    "depth first search",
+    "breadth first search",
+    "DFS",
+    "BFS",
+    "dijkstra algorithm",
+    "bellman ford",
+    "floyd warshall",
+    "tarjan algorithm",
+    "topological sort",
+    "leetcode",
+    "coding interview",
+    "algorithm practice",
+    "collection",
+    "ES6 modules",
     "CommonJS",
-    "ES6",
-    "UMD",
-    "ES Modules",
-    "ESModules",
-    "ESModule"
+    "type-safe"
   ]
 }

package/src/data-structures/binary-tree/avl-tree-counter.ts

@@ -200,7 +200,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
     options?: AVLTreeCounterOptions<K, V, R>
   ) {
     super([], options);
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
 
   protected _count = 0;
@@ -243,7 +243,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
    * @param [count] - How much to increase the node's count (default 1).
    * @returns True if inserted/updated; false if ignored.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V,
     count = 1
@@ -252,7 +252,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
     if (newNode === undefined) return false;
 
     const orgNodeCount = newNode?.count || 0;
-    const inserted = super.add(newNode, newValue);
+    const inserted = super.set(newNode, newValue);
     if (inserted) {
       this._count += orgNodeCount;
     }
@@ -380,9 +380,9 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
     const out = this._createInstance();
 
     if (this._isMapMode) {
-      this.bfs(node => out.add(node.key, undefined, node.count));
+      this.bfs(node => out.set(node.key, undefined, node.count));
     } else {
-      this.bfs(node => out.add(node.key, node.value, node.count));
+      this.bfs(node => out.set(node.key, node.value, node.count));
     }
 
     if (this._isMapMode) out._store = this._store;
@@ -410,7 +410,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
 
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, value, key, index++, this));
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }

package/src/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -199,7 +199,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
   ) {
     super([], { ...options, isMapMode: true });
     if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
+      this.setMany(keysNodesEntriesOrRaws);
     }
   }
 
@@ -220,29 +220,29 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
     return keyNodeOrEntry instanceof AVLTreeMultiMapNode;
   }
 
-  override add(
+  override set(
     keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
   ): boolean;
 
-  override add(key: K, value: V): boolean;
+  override set(key: K, value: V): boolean;
 
   /**
    * Insert a value or a list of values into the multimap. If the key exists, values are appended.
    * @remarks Time O(log N + M), Space O(1)
    * @param keyNodeOrEntry - Key, node, or [key, values] entry.
-   * @param [value] - Single value to add when a bare key is provided.
+   * @param [value] - Single value to set when a bare key is provided.
    * @returns True if inserted or appended; false if ignored.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined,
     value?: V
   ): boolean {
-    if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
+    if (this.isRealNode(keyNodeOrEntry)) return super.set(keyNodeOrEntry);
 
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
       if (key === undefined || key === null) return false;
 
-      const _addToValues = () => {
+      const _setToValues = () => {
         const existingValues = this.get(key);
         if (existingValues !== undefined && values !== undefined) {
           for (const value of values) existingValues.push(value);
@@ -251,12 +251,12 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
         return false;
       };
 
-      const _addByNode = () => {
+      const _setByNode = () => {
         const existingNode = this.getNode(key);
         if (this.isRealNode(existingNode)) {
           const existingValues = this.get(existingNode);
           if (existingValues === undefined) {
-            super.add(key, values);
+            super.set(key, values);
             return true;
           }
           if (values !== undefined) {
@@ -266,14 +266,14 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
             return false;
           }
         } else {
-          return super.add(key, values);
+          return super.set(key, values);
         }
       };
 
       if (this._isMapMode) {
-        return _addByNode() || _addToValues();
+        return _setByNode() || _setToValues();
       }
-      return _addToValues() || _addByNode();
+      return _setToValues() || _setByNode();
     };
 
     if (this.isEntry(keyNodeOrEntry)) {
@@ -392,7 +392,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
   ): AVLTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(callback.call(thisArg, v, k, i++, this));
+    for (const [k, v] of this) out.set(callback.call(thisArg, v, k, i++, this));
     return out;
   }
 

package/src/data-structures/binary-tree/avl-tree.ts

@@ -182,7 +182,7 @@ export class AVLTreeNode<K = any, V = any> {
 
 /**
  * Represents a self-balancing AVL (Adelson-Velsky and Landis) Tree.
- * This tree extends BST and performs rotations on add/delete to maintain balance.
+ * This tree extends BST and performs rotations on set/delete to maintain balance.
  *
  * @template K - The type of the key.
  * @template V - The type of the value.
@@ -215,7 +215,7 @@ export class AVLTreeNode<K = any, V = any> {
  *     console.log(tree.size); // 5;
  *
  *     // Add a new element
- *     tree.add(3);
+ *     tree.set(3);
  *     console.log(tree.size); // 6;
  *     console.log([...tree.keys()]); // [1, 2, 3, 5, 8, 9];
  * @example
@@ -278,7 +278,7 @@ export class AVLTreeNode<K = any, V = any> {
  *     console.log(universityTree.isAVLBalanced()); // true;
  *
  *     // Add more universities
- *     universityTree.add(6, { name: 'Oxford', rank: 6, students: 2000 });
+ *     universityTree.set(6, { name: 'Oxford', rank: 6, students: 2000 });
  *     console.log(universityTree.isAVLBalanced()); // true;
  *
  *     // Delete and verify balance is maintained
@@ -358,9 +358,9 @@ export class AVLTreeNode<K = any, V = any> {
 export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements IBinaryTree<K, V, R> {
   /**
    * Creates an instance of AVLTree.
-   * @remarks Time O(N log N) (from `addMany` with balanced add). Space O(N).
+   * @remarks Time O(N log N) (from `setMany` with balanced set). Space O(N).
    *
-   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
+   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to set.
    * @param [options] - Configuration options for the AVL tree.
    */
   constructor(
@@ -370,8 +370,8 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     options?: AVLTreeOptions<K, V, R>
   ) {
     super([], options);
-    // Note: super.addMany is called, which in BST defaults to balanced add.
-    if (keysNodesEntriesOrRaws) super.addMany(keysNodesEntriesOrRaws);
+    // Note: super.setMany is called, which in BST defaults to balanced set.
+    if (keysNodesEntriesOrRaws) super.setMany(keysNodesEntriesOrRaws);
   }
 
   /**
@@ -400,19 +400,19 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
   }
 
   /**
-   * Adds a new node to the AVL tree and balances the tree path.
-   * @remarks Time O(log N) (O(H) for BST add + O(H) for `_balancePath`). Space O(H) for path/recursion.
+   * Sets a new node to the AVL tree and balances the tree path.
+   * @remarks Time O(log N) (O(H) for BST set + O(H) for `_balancePath`). Space O(H) for path/recursion.
    *
-   * @param keyNodeOrEntry - The key, node, or entry to add.
+   * @param keyNodeOrEntry - The key, node, or entry to set.
    * @param [value] - The value, if providing just a key.
    * @returns True if the addition was successful, false otherwise.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V
   ): boolean {
     if (keyNodeOrEntry === null) return false;
-    const inserted = super.add(keyNodeOrEntry, value);
+    const inserted = super.set(keyNodeOrEntry, value);
     // If insertion was successful, balance the path from the new node up to the root.
     if (inserted) this._balancePath(keyNodeOrEntry);
     return inserted;
@@ -477,7 +477,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
 
   /**
    * Creates a new AVLTree by mapping each [key, value] pair.
-   * @remarks Time O(N log N) (O(N) iteration + O(log M) `add` for each item into the new tree). Space O(N) for the new tree.
+   * @remarks Time O(N log N) (O(N) iteration + O(log M) `set` for each item into the new tree). Space O(N) for the new tree.
    *
    * @template MK - New key type.
    * @template MV - New value type.
@@ -497,8 +497,8 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     let index = 0;
     // Iterates in-order
     for (const [key, value] of this) {
-      // `add` on the new tree will be O(log N) and will self-balance.
-      out.add(callback.call(thisArg, value, key, index++, this));
+      // `set` on the new tree will be O(log N) and will self-balance.
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }