data-structure-typed 1.52.5 → 1.52.7

package/eslint.config.mjs

@@ -0,0 +1,69 @@
+import typescriptEslint from "@typescript-eslint/eslint-plugin";
+import _import from "eslint-plugin-import";
+import { fixupPluginRules } from "@eslint/compat";
+import tsParser from "@typescript-eslint/parser";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all
+});
+
+export default [{
+  ignores: ["**/lib/", "**/dist/", "**/umd/", "**/coverage/", "**/docs/"],
+}, ...compat.extends("plugin:@typescript-eslint/recommended", "prettier"), {
+  plugins: {
+    "@typescript-eslint": typescriptEslint,
+    import: fixupPluginRules(_import),
+  },
+
+  languageOptions: {
+    parser: tsParser,
+  },
+
+  settings: {
+    "import/parsers": {
+      "@typescript-eslint/parser": [".ts"],
+    },
+
+    "import/resolver": {
+      typescript: {
+        alwaysTryTypes: true,
+        project: ["./tsconfig.json"],
+      },
+    },
+  },
+
+  rules: {
+    "import/no-anonymous-default-export": "off",
+    "@typescript-eslint/no-unused-vars": "warn",
+    "@typescript-eslint/ban-ts-comment": "off",
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-var-requires": "off",
+    "@typescript-eslint/no-non-null-assertion": "off",
+    "@typescript-eslint/no-require-imports": "off",
+    "lines-around-comment": ["warn", {
+      beforeLineComment: false,
+      beforeBlockComment: true,
+      allowBlockStart: true,
+      allowClassStart: true,
+      allowObjectStart: true,
+      allowArrayStart: true,
+    }],
+
+    "newline-before-return": "off",
+
+    "import/newline-after-import": ["warn", {
+      count: 1,
+    }],
+
+
+    "object-curly-spacing": ["warn", "always"],
+  },
+}];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.52.5",
+  "version": "1.52.7",
   "description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
@@ -9,8 +9,7 @@
   "exports": {
     ".": {
       "import": "./dist/mjs/index.js",
-      "require": "./dist/cjs/index.js",
-      "types": "./dist/mjs/index.d.ts"
+      "require": "./dist/cjs/index.js"
     }
   },
   "scripts": {
@@ -59,37 +58,40 @@
     "@zrwusa:registry": "https://npm.pkg.github.com"
   },
   "devDependencies": {
-    "@swc/core": "^1.3.96",
-    "@types/benchmark": "^2.1.3",
-    "@types/jest": "^29.5.5",
-    "@types/node": "^20.8.2",
-    "@typescript-eslint/eslint-plugin": "^6.7.4",
-    "@typescript-eslint/parser": "^6.7.4",
-    "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.52.4",
+    "@eslint/compat": "^1.2.2",
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.13.0",
+    "@swc/core": "^1.7.40",
+    "@types/benchmark": "^2.1.5",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.8.2",
+    "@typescript-eslint/eslint-plugin": "^8.12.1",
+    "@typescript-eslint/parser": "^8.12.1",
+    "auto-changelog": "^2.5.0",
+    "avl-tree-typed": "^1.52.6",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.52.4",
-    "bst-typed": "^1.52.4",
-    "data-structure-typed": "^1.52.4",
-    "dependency-cruiser": "^14.1.0",
+    "binary-tree-typed": "^1.52.6",
+    "bst-typed": "^1.52.6",
+    "data-structure-typed": "^1.52.6",
+    "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
-    "eslint": "^8.50.0",
-    "eslint-config-prettier": "^9.0.0",
+    "eslint": "^9.13.0",
+    "eslint-config-prettier": "^9.1.0",
     "eslint-import-resolver-alias": "^1.1.2",
-    "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.28.1",
-    "fast-glob": "^3.3.1",
-    "heap-typed": "^1.52.4",
-    "istanbul-badges-readme": "^1.8.5",
+    "eslint-import-resolver-typescript": "^3.6.3",
+    "eslint-plugin-import": "^2.31.0",
+    "fast-glob": "^3.3.2",
+    "heap-typed": "^1.52.6",
+    "istanbul-badges-readme": "^1.9.0",
     "jest": "^29.7.0",
     "js-sdsl": "^4.4.2",
     "prettier": "^3.3.3",
-    "ts-jest": "^29.1.1",
-    "ts-loader": "^9.4.4",
-    "ts-node": "^10.9.1",
-    "tsup": "^7.2.0",
-    "typedoc": "^0.26.5",
-    "typescript": "^5.3.2"
+    "ts-jest": "^29.2.5",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.3.5",
+    "typedoc": "^0.26.10",
+    "typescript": "^5.6.3"
   },
   "keywords": [
     "data",

package/src/constants/index.ts

@@ -0,0 +1,4 @@
+export enum DFSOperation {
+  VISIT = 0,
+  PROCESS = 1
+}

package/src/data-structures/base/iterable-element-base.ts

@@ -192,10 +192,20 @@ export abstract class IterableElementBase<E, R, C> {
    *
    * The print function logs the elements of an array to the console.
    */
-  print(): E[] {
+  toVisual(): E[] {
     return [...this];
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The print function logs the elements of an array to the console.
+   */
+  print(): void {
+    console.log(this.toVisual());
+  }
+
   abstract isEmpty(): boolean;
 
   abstract clear(): void;

package/src/data-structures/base/iterable-entry-base.ts

@@ -1,26 +1,8 @@
 import { EntryCallback, ReduceEntryCallback } from '../../types';
 
 export abstract class IterableEntryBase<K = any, V = any> {
-  // protected constructor(options?: IterableEntryBaseOptions<K, V, R>) {
-  //   if (options) {
-  //     const { toEntryFn } = options;
-  //     if (typeof toEntryFn === 'function') this._toEntryFn = toEntryFn
-  //     else throw new TypeError('toEntryFn must be a function type');
-  //   }
-  // }
-
   abstract get size(): number;
 
-  // protected _toEntryFn?: (rawElement: R) => BTNEntry<K, V>;
-  //
-  // /**
-  //  * The function returns the value of the _toEntryFn property.
-  //  * @returns The function being returned is `this._toEntryFn`.
-  //  */
-  // get toEntryFn() {
-  //   return this._toEntryFn;
-  // }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -251,10 +233,20 @@ export abstract class IterableEntryBase<K = any, V = any> {
    *
    * The print function logs the elements of an array to the console.
    */
-  print(): [K, V][] | string {
+  toVisual(): [K, V][] | string {
     return [...this];
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The print function logs the elements of an array to the console.
+   */
+  print(): void {
+    console.log(this.toVisual());
+  }
+
   abstract isEmpty(): boolean;
 
   abstract clear(): void;

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

@@ -1,8 +1,8 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 import type {
@@ -11,11 +11,11 @@ import type {
   AVLTreeMultiMapOptions,
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
-  BTNCallback,
   BTNKeyOrNodeOrEntry,
-  IterationType
+  BTNPredicate,
+  IterationType,
+  BTNEntry
 } from '../../types';
-import { BTNEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 
@@ -80,18 +80,18 @@ export class AVLTreeMultiMap<
 {
   /**
    * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
-   * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
+   * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
    * iterable object that can contain either keys, nodes, entries, or raw elements.
    * @param [options] - The `options` parameter is an optional object that can be used to customize the
    * behavior of the AVLTreeMultiMap. It can include properties such as `compareKeys` and
    * `compareValues` functions to define custom comparison logic for keys and values, respectively.
    */
   constructor(
-    keysOrNodesOrEntriesOrRawElements: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>> = [],
+    keysOrNodesOrEntriesOrRaws: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>> = [],
     options?: AVLTreeMultiMapOptions<K, V, R>
   ) {
     super([], options);
-    if (keysOrNodesOrEntriesOrRawElements) this.addMany(keysOrNodesOrEntriesOrRawElements);
+    if (keysOrNodesOrEntriesOrRaws) this.addMany(keysOrNodesOrEntriesOrRaws);
   }
 
   protected _count = 0;
@@ -144,29 +144,28 @@ export class AVLTreeMultiMap<
   override createTree(options?: AVLTreeMultiMapOptions<K, V, R>): TREE {
     return new AVLTreeMultiMap<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
-      comparator: this.comparator,
+      comparator: this._comparator,
+      toEntryFn: this._toEntryFn,
       ...options
     }) as TREE;
   }
 
   /**
    * The function checks if the input is an instance of AVLTreeMultiMapNode.
-   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-   * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-   * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+   * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+   * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+   * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
    * an instance of the `AVLTreeMultiMapNode` class.
    */
-  override isNode(
-    keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>
-  ): keyOrNodeOrEntryOrRawElement is NODE {
-    return keyOrNodeOrEntryOrRawElement instanceof AVLTreeMultiMapNode;
+  override isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE {
+    return keyOrNodeOrEntryOrRaw instanceof AVLTreeMultiMapNode;
   }
 
   /**
    * The function `keyValueOrEntryOrRawElementToNode` converts a key, value, entry, or raw element into
    * a node object.
-   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
-   * `keyOrNodeOrEntryOrRawElement` parameter can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+   * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
+   * `keyOrNodeOrEntryOrRaw` parameter can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
    * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
    * `override` function. It represents the value associated with the key in the data structure. If no
    * value is provided, it will default to `undefined`.
@@ -175,25 +174,25 @@ export class AVLTreeMultiMap<
    * @returns either a NODE object or undefined.
    */
   override keyValueOrEntryOrRawElementToNode(
-    keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>,
+    keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R,
     value?: V,
     count = 1
   ): NODE | undefined {
-    if (keyOrNodeOrEntryOrRawElement === undefined || keyOrNodeOrEntryOrRawElement === null) return;
-    if (this.isNode(keyOrNodeOrEntryOrRawElement)) return keyOrNodeOrEntryOrRawElement;
+    if (keyOrNodeOrEntryOrRaw === undefined || keyOrNodeOrEntryOrRaw === null) return;
+    if (this.isNode(keyOrNodeOrEntryOrRaw)) return keyOrNodeOrEntryOrRaw;
 
-    if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
-      const [key, entryValue] = keyOrNodeOrEntryOrRawElement;
+    if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
+      const [key, entryValue] = keyOrNodeOrEntryOrRaw;
       if (key === undefined || key === null) return;
       if (this.isKey(key)) return this.createNode(key, value ?? entryValue, count);
     }
 
-    if (this.toEntryFn) {
-      const [key, entryValue] = this.toEntryFn(keyOrNodeOrEntryOrRawElement as R);
+    if (this._toEntryFn) {
+      const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw as R);
       if (this.isKey(key)) return this.createNode(key, value ?? entryValue, count);
     }
 
-    if (this.isKey(keyOrNodeOrEntryOrRawElement)) return this.createNode(keyOrNodeOrEntryOrRawElement, value, count);
+    if (this.isKey(keyOrNodeOrEntryOrRaw)) return this.createNode(keyOrNodeOrEntryOrRaw, value, count);
 
     return;
   }
@@ -204,8 +203,8 @@ export class AVLTreeMultiMap<
    *
    * The function overrides the add method of a TypeScript class to add a new node to a data structure
    * and update the count.
-   * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
-   * `keyOrNodeOrEntryOrRawElement` parameter can accept a value of type `R`, which can be any type. It
+   * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
+   * `keyOrNodeOrEntryOrRaw` parameter can accept a value of type `R`, which can be any type. It
    * can also accept a value of type `BTNKeyOrNodeOrEntry<K, V, NODE>`, which represents a key, node,
    * entry, or raw element
    * @param {V} [value] - The `value` parameter represents the value associated with the key in the
@@ -215,8 +214,8 @@ export class AVLTreeMultiMap<
    * be added once. However, you can specify a different value for `count` if you want to add
    * @returns a boolean value.
    */
-  override add(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count = 1): boolean {
-    const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value, count);
+  override add(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V, count = 1): boolean {
+    const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value, count);
     if (newNode === undefined) return false;
 
     const orgNodeCount = newNode?.count || 0;
@@ -231,31 +230,29 @@ export class AVLTreeMultiMap<
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
    *
-   * The `delete` function in a binary tree data structure deletes a node based on its identifier and
-   * returns the deleted node along with the parent node that needs to be balanced.
-   * @param identifier - The identifier parameter is the value used to identify the node that needs to
-   * be deleted from the binary tree. It can be of any type and is the return type of the callback
-   * function.
-   * @param {C} callback - The `callback` parameter is a function that is used to determine the
-   * equality of nodes in the binary tree. It is optional and has a default value of
-   * `this._DEFAULT_CALLBACK`. The `callback` function takes a single argument, which is the identifier
-   * of a node, and returns a value that
-   * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
-   * being deleted. If set to true, the count of the node will not be considered and the node will be
-   * deleted regardless of its count. If set to false (default), the count of the node will be taken
-   * into account and the node
-   * @returns an array of `BinaryTreeDeleteResult<NODE>`.
+   * The function overrides the delete method in a binary tree data structure, handling deletion of
+   * nodes and maintaining balance in the tree.
+   * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+   * parameter in the `delete` method is used to specify the condition for deleting a node from the
+   * binary tree. It can be a key, node, entry, or a custom predicate function that determines which
+   * node(s) should be deleted.
+   * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
+   * boolean flag that determines whether to ignore the count of the node being deleted. If
+   * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
+   * `ignoreCount` is set to
+   * @returns The `delete` method overrides the default delete behavior in a binary tree data
+   * structure. It takes a predicate or node to be deleted and an optional flag to ignore count. The
+   * method returns an array of `BinaryTreeDeleteResult` objects, each containing information about the
+   * deleted node and whether balancing is needed in the tree.
    */
-  override delete<C extends BTNCallback<NODE>>(
-    identifier: ReturnType<C>,
-    callback: C = this._DEFAULT_CALLBACK as C,
+  override delete(
+    predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>,
     ignoreCount = false
   ): BinaryTreeDeleteResult<NODE>[] {
     const deletedResult: BinaryTreeDeleteResult<NODE>[] = [];
     if (!this.root) return deletedResult;
-    callback = this._ensureCallback(identifier, callback);
 
-    const curr: NODE | undefined = this.getNode(identifier, callback) ?? undefined;
+    const curr: NODE | undefined = this.getNode(predicate) ?? undefined;
     if (!curr) return deletedResult;
 
     const parent: NODE | undefined = curr?.parent ? curr.parent : undefined;
@@ -293,7 +290,7 @@ export class AVLTreeMultiMap<
           }
         }
       }
-      this._size = this.size - 1;
+      this._size = this._size - 1;
       // TODO How to handle when the count of target node is lesser than current node's count
       if (orgCurrent) this._count -= orgCurrent.count;
     }