data-structure-typed 2.2.8 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "2.2.8",
+  "version": "2.3.0",
   "description": "Standard data structure",
   "browser": "dist/umd/data-structure-typed.min.js",
   "umd:main": "dist/umd/data-structure-typed.min.js",
@@ -51,6 +51,7 @@
     "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:ecut && ts-node test/performance/benchmark-runner.ts --isolate --gc --cooldown-ms=80",
+    "test:coverage": "jest --runInBand --coverage",
     "check": "npm run check:src && npm run check:test",
     "check:src": "tsc --noEmit",
     "check:test": "tsc -p tsconfig.test.json --noEmit",
@@ -63,7 +64,7 @@
     "format:test": "prettier --write 'test/**/*.{js,ts}'",
     "format": "npm run format:src && npm run format:test",
     "check:exist-latest": "sh scripts/check_exist_remotely.sh",
-    "ci": "env && git fetch --tags && npm run update:subs && npm run inspect && npm run lint && npm run test && npm run changelog",
+    "ci": "env && git fetch --tags && npm run update:subs && npm run inspect && npm run lint && npm run test:coverage && npm run changelog",
     "update:subs": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed data-structure-typed --save-dev",
     "install:all-subs": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multimap-typed trie-typed undirected-graph-typed queue-typed --save-dev",
     "changelog": "auto-changelog",
@@ -102,7 +103,7 @@
     "benchmark": "^2.1.4",
     "binary-tree-typed": "^1.54.3",
     "bst-typed": "^1.54.3",
-    "data-structure-typed": "^2.2.7",
+    "data-structure-typed": "^2.2.8",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",

package/src/data-structures/base/linear-base.ts

@@ -75,7 +75,7 @@ export abstract class LinearBase<
    * @param options - `{ maxLen?, ... }` bounds/behavior options.
    * @remarks Time O(1), Space O(1)
    */
-  protected constructor(options?: LinearBaseOptions<E, R>) {
+   constructor(options?: LinearBaseOptions<E, R>) {
     super(options);
     if (options) {
       const { maxLen } = options;
@@ -156,14 +156,6 @@ export abstract class LinearBase<
     return -1;
   }
 
-  /**
-   * Concatenate multiple containers of the same species.
-   * @param items - Other lists to append.
-   * @returns New container with combined elements (`this` type).
-   * @remarks Time O(sum(length)), Space O(sum(length))
-   */
-  concat(...items: this[]): this;
-
   /**
    * Concatenate elements and/or containers.
    * @param items - Elements or other containers.
@@ -412,7 +404,7 @@ export abstract class LinearLinkedBase<
   R = any,
   NODE extends LinkedListNode<E> = LinkedListNode<E>
 > extends LinearBase<E, R, NODE> {
-  protected constructor(options?: LinearBaseOptions<E, R>) {
+   constructor(options?: LinearBaseOptions<E, R>) {
     super(options);
     if (options) {
       const { maxLen } = options;
@@ -478,8 +470,6 @@ export abstract class LinearLinkedBase<
    * @returns New list with combined elements (`this` type).
    * @remarks Time O(sum(length)), Space O(sum(length))
    */
-  override concat(...items: LinearBase<E, R>[]): this;
-
   override concat(...items: (E | LinearBase<E, R>)[]): this {
     const newList = this.clone();
 

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

@@ -10,7 +10,7 @@ import type {
   BinaryTreeDeleteResult,
   BinaryTreeOptions,
   BinaryTreePrintOptions,
-  BTNEntry,
+  BTNEntry, BTNRep,
   DFSOrderPattern,
   DFSStackItem,
   EntryCallback,
@@ -717,7 +717,6 @@ export class BinaryTree<K = any, V = any, R = any>
    * @remarks Time O(N * M), where N is the number of items to set and M is the size of the tree at insertion (due to O(M) `set` operation). Space O(M) (from `set`) + O(N) (for the `inserted` array).
    *
    * @param keysNodesEntriesOrRaws - An iterable of items to set.
-   * @param [values] - An optional parallel iterable of values.
    * @returns An array of booleans indicating the success of each individual `set` operation.
    */
   addMany(
@@ -796,16 +795,16 @@ export class BinaryTree<K = any, V = any, R = any>
    * Deletes a node from the tree.
    * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation finds the node, and if it has two children, swaps it with the rightmost node of its left subtree (in-order predecessor) before deleting. Time O(N) in the worst case. O(N) to find the node (`getNode`) and O(H) (which is O(N) worst-case) to find the rightmost node. Space O(1) (if `getNode` is iterative, which it is).
    *
-   * @param keyNodeOrEntry - The node to delete.
+   * @param keyNodeEntryRawOrPredicate - The node to delete.
    * @returns An array containing deletion results (for compatibility with self-balancing trees).
    */
   delete(
-    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+    keyNodeEntryRawOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V> | null>
   ): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[] {
     const deletedResult: BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[] = [];
     if (!this._root) return deletedResult;
 
-    const curr = this.getNode(keyNodeOrEntry);
+    const curr = this.getNode(keyNodeEntryRawOrPredicate);
     if (!curr) return deletedResult;
 
     const parent: BinaryTreeNode<K, V> | undefined = curr?.parent;
@@ -1140,7 +1139,7 @@ export class BinaryTree<K = any, V = any, R = any>
         }
         return true;
       };
-      const isStandardBST = checkBST(false);
+      const isStandardBST = checkBST();
       const isInverseBST = checkBST(true);
       return isStandardBST || isInverseBST;
     }

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

@@ -204,7 +204,8 @@ export class BSTNode<K = any, V = any> {
  *  // Create a simple BST with numeric keys
  *     const bst = new BST<number>([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
  *
- *     bst.print();
+ *     // Keep the example output in source comments but avoid noisy test logs.
+ *     await withMutedConsole(() => bst.print());
  *     //         _______8__________
  *     //        /                  \
  *     //     ___4___          ____12_____
@@ -556,9 +557,55 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     startNode: BSTNOptKeyOrNode<K, BSTNode<K, V>> = this._root,
     iterationType: IterationType = this.iterationType
   ): OptNode<BSTNode<K, V>> {
-    return this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0] ?? undefined;
+    // Fast-path: key lookup should not allocate arrays or build predicate closures.
+    // (This is a hot path for get/has in Node Mode.)
+    if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === undefined) return undefined;
+
+    // If a predicate is provided, defer to the full search logic.
+    if (this._isPredicate(keyNodeEntryOrPredicate)) {
+      return this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0] ?? undefined;
+    }
+
+    // NOTE: Range<K> is not part of this overload, but callers may still pass it at runtime.
+    // Let search handle it.
+    if (keyNodeEntryOrPredicate instanceof Range) {
+      return (
+        this.getNodes(
+          keyNodeEntryOrPredicate,
+          true,
+          startNode as K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+          iterationType
+        )[0] ?? undefined
+      );
+    }
+
+    let targetKey: K | undefined;
+    if (this.isNode(keyNodeEntryOrPredicate)) {
+      targetKey = keyNodeEntryOrPredicate.key;
+    } else if (this.isEntry(keyNodeEntryOrPredicate)) {
+      const k = keyNodeEntryOrPredicate[0];
+      if (k === null || k === undefined) return undefined;
+      targetKey = k;
+    } else {
+      targetKey = keyNodeEntryOrPredicate;
+    }
+
+    const start = this.ensureNode(startNode);
+    if (!start) return undefined;
+
+    const NIL = this._NIL as unknown as BSTNode<K, V> | null | undefined;
+    let cur: BSTNode<K, V> | null | undefined = start;
+    const cmpFn = this._comparator;
+    while (cur && cur !== NIL) {
+      const c = cmpFn(targetKey, cur.key);
+      if (c === 0) return cur;
+      cur = c < 0 ? cur._left : cur._right;
+    }
+
+    return undefined;
   }
 
+
   override search(
     keyNodeEntryOrPredicate:
       | K
@@ -619,9 +666,37 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     startNode = this.ensureNode(startNode);
     if (!startNode) return [];
 
-    let predicate: NodePredicate<BSTNode<K, V>>;
+    // Fast-path: key lookup (unique keys) using a tight BST walk (no allocations).
+    // This is the hot path for get/has/search by key.
     const isRange = this.isRange(keyNodeEntryOrPredicate);
+    const isPred = !isRange && this._isPredicate(keyNodeEntryOrPredicate);
+
+    if (!isRange && !isPred) {
+      let targetKey: K | undefined;
+      if (this.isNode(keyNodeEntryOrPredicate)) {
+        targetKey = keyNodeEntryOrPredicate.key;
+      } else if (this.isEntry(keyNodeEntryOrPredicate)) {
+        const k = keyNodeEntryOrPredicate[0];
+        if (k !== null && k !== undefined) targetKey = k;
+      } else {
+        targetKey = keyNodeEntryOrPredicate;
+      }
+      if (targetKey === undefined) return [];
+
+      const NIL = this._NIL as unknown as BSTNode<K, V> | null | undefined;
+      const cmpFn = this._comparator;
+      let cur: BSTNode<K, V> | null | undefined = startNode;
+
+      // Loop intentionally avoids getters and extra type checks.
+      while (cur && cur !== NIL) {
+        const c = cmpFn(targetKey, cur.key);
+        if (c === 0) return [callback(cur)];
+        cur = c < 0 ? cur._left : cur._right;
+      }
+      return [];
+    }
 
+    let predicate: NodePredicate<BSTNode<K, V>>;
     if (isRange) {
       predicate = node => {
         if (!node) return false;
@@ -2018,7 +2093,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       if (succ.left) (succ.left as BSTNode<K, V>).parent = succ;
     }
 
-    this._size = Math.max(0, ((this as any)._size ?? 0) - 1);
+    this._size = Math.max(0, this._size - 1);
     return true;
   }
 }