data-structure-typed 1.51.9 → 1.52.1

package/benchmark/report.json

@@ -1,43 +1,415 @@
 {
+  "heap": {
+    "benchmarks": [
+      {
+        "test name": "100,000 add",
+        "time taken (ms)": "6.09",
+        "executions per sec": "164.12",
+        "sample deviation": "1.35e-4"
+      },
+      {
+        "test name": "100,000 add & poll",
+        "time taken (ms)": "34.55",
+        "executions per sec": "28.94",
+        "sample deviation": "6.43e-4"
+      }
+    ],
+    "testName": "heap"
+  },
   "rb-tree": {
     "benchmarks": [
       {
         "test name": "100,000 add",
-        "time taken (ms)": "71.96",
-        "executions per sec": "13.90",
+        "time taken (ms)": "76.73",
+        "executions per sec": "13.03",
         "sample deviation": "0.00"
       },
       {
         "test name": "100,000 add randomly",
-        "time taken (ms)": "78.32",
-        "executions per sec": "12.77",
+        "time taken (ms)": "80.67",
+        "executions per sec": "12.40",
         "sample deviation": "0.00"
       },
       {
         "test name": "100,000 get",
-        "time taken (ms)": "101.87",
-        "executions per sec": "9.82",
+        "time taken (ms)": "110.86",
+        "executions per sec": "9.02",
         "sample deviation": "0.00"
       },
       {
         "test name": "100,000 iterator",
-        "time taken (ms)": "31.00",
-        "executions per sec": "32.26",
+        "time taken (ms)": "24.99",
+        "executions per sec": "40.02",
         "sample deviation": "0.00"
       },
       {
         "test name": "100,000 add & delete orderly",
-        "time taken (ms)": "138.97",
-        "executions per sec": "7.20",
+        "time taken (ms)": "152.66",
+        "executions per sec": "6.55",
         "sample deviation": "0.00"
       },
       {
         "test name": "100,000 add & delete randomly",
-        "time taken (ms)": "227.00",
-        "executions per sec": "4.41",
-        "sample deviation": "0.02"
+        "time taken (ms)": "230.75",
+        "executions per sec": "4.33",
+        "sample deviation": "0.00"
       }
     ],
     "testName": "rb-tree"
+  },
+  "queue": {
+    "benchmarks": [
+      {
+        "test name": "1,000,000 push",
+        "time taken (ms)": "39.27",
+        "executions per sec": "25.46",
+        "sample deviation": "0.01"
+      },
+      {
+        "test name": "100,000 push & shift",
+        "time taken (ms)": "4.53",
+        "executions per sec": "220.81",
+        "sample deviation": "4.84e-4"
+      },
+      {
+        "test name": "Native JS Array 100,000 push & shift",
+        "time taken (ms)": "1948.05",
+        "executions per sec": "0.51",
+        "sample deviation": "0.02"
+      }
+    ],
+    "testName": "queue"
+  },
+  "deque": {
+    "benchmarks": [
+      {
+        "test name": "1,000,000 push",
+        "time taken (ms)": "23.22",
+        "executions per sec": "43.06",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "1,000,000 push & pop",
+        "time taken (ms)": "29.68",
+        "executions per sec": "33.69",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "1,000,000 push & shift",
+        "time taken (ms)": "29.33",
+        "executions per sec": "34.09",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "100,000 push & shift",
+        "time taken (ms)": "3.10",
+        "executions per sec": "323.01",
+        "sample deviation": "2.47e-4"
+      },
+      {
+        "test name": "Native JS Array 100,000 push & shift",
+        "time taken (ms)": "1942.12",
+        "executions per sec": "0.51",
+        "sample deviation": "0.02"
+      },
+      {
+        "test name": "100,000 unshift & shift",
+        "time taken (ms)": "2.77",
+        "executions per sec": "360.50",
+        "sample deviation": "2.43e-4"
+      },
+      {
+        "test name": "Native JS Array 100,000 unshift & shift",
+        "time taken (ms)": "3835.21",
+        "executions per sec": "0.26",
+        "sample deviation": "0.03"
+      }
+    ],
+    "testName": "deque"
+  },
+  "hash-map": {
+    "benchmarks": [
+      {
+        "test name": "1,000,000 set",
+        "time taken (ms)": "112.38",
+        "executions per sec": "8.90",
+        "sample deviation": "0.02"
+      },
+      {
+        "test name": "Native JS Map 1,000,000 set",
+        "time taken (ms)": "199.97",
+        "executions per sec": "5.00",
+        "sample deviation": "0.01"
+      },
+      {
+        "test name": "Native JS Set 1,000,000 add",
+        "time taken (ms)": "163.34",
+        "executions per sec": "6.12",
+        "sample deviation": "0.01"
+      },
+      {
+        "test name": "1,000,000 set & get",
+        "time taken (ms)": "109.86",
+        "executions per sec": "9.10",
+        "sample deviation": "0.02"
+      },
+      {
+        "test name": "Native JS Map 1,000,000 set & get",
+        "time taken (ms)": "255.33",
+        "executions per sec": "3.92",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "Native JS Set 1,000,000 add & has",
+        "time taken (ms)": "163.91",
+        "executions per sec": "6.10",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "1,000,000 ObjKey set & get",
+        "time taken (ms)": "317.89",
+        "executions per sec": "3.15",
+        "sample deviation": "0.04"
+      },
+      {
+        "test name": "Native JS Map 1,000,000 ObjKey set & get",
+        "time taken (ms)": "282.99",
+        "executions per sec": "3.53",
+        "sample deviation": "0.03"
+      },
+      {
+        "test name": "Native JS Set 1,000,000 ObjKey add & has",
+        "time taken (ms)": "253.93",
+        "executions per sec": "3.94",
+        "sample deviation": "0.03"
+      }
+    ],
+    "testName": "hash-map"
+  },
+  "trie": {
+    "benchmarks": [
+      {
+        "test name": "100,000 push",
+        "time taken (ms)": "43.71",
+        "executions per sec": "22.88",
+        "sample deviation": "7.33e-4"
+      },
+      {
+        "test name": "100,000 getWords",
+        "time taken (ms)": "83.63",
+        "executions per sec": "11.96",
+        "sample deviation": "0.00"
+      }
+    ],
+    "testName": "trie"
+  },
+  "avl-tree": {
+    "benchmarks": [
+      {
+        "test name": "100,000 add",
+        "time taken (ms)": "271.93",
+        "executions per sec": "3.68",
+        "sample deviation": "0.01"
+      },
+      {
+        "test name": "100,000 add randomly",
+        "time taken (ms)": "318.27",
+        "executions per sec": "3.14",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "100,000 get",
+        "time taken (ms)": "128.85",
+        "executions per sec": "7.76",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "100,000 iterator",
+        "time taken (ms)": "29.09",
+        "executions per sec": "34.38",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "100,000 add & delete orderly",
+        "time taken (ms)": "435.48",
+        "executions per sec": "2.30",
+        "sample deviation": "7.44e-4"
+      },
+      {
+        "test name": "100,000 add & delete randomly",
+        "time taken (ms)": "578.70",
+        "executions per sec": "1.73",
+        "sample deviation": "0.00"
+      }
+    ],
+    "testName": "avl-tree"
+  },
+  "binary-tree-overall": {
+    "benchmarks": [
+      {
+        "test name": "10,000 RBTree add randomly",
+        "time taken (ms)": "6.69",
+        "executions per sec": "149.54",
+        "sample deviation": "1.06e-4"
+      },
+      {
+        "test name": "10,000 RBTree get randomly",
+        "time taken (ms)": "9.19",
+        "executions per sec": "108.82",
+        "sample deviation": "1.43e-4"
+      },
+      {
+        "test name": "10,000 RBTree add & delete randomly",
+        "time taken (ms)": "18.54",
+        "executions per sec": "53.94",
+        "sample deviation": "1.73e-4"
+      },
+      {
+        "test name": "10,000 AVLTree add randomly",
+        "time taken (ms)": "23.70",
+        "executions per sec": "42.20",
+        "sample deviation": "1.88e-4"
+      },
+      {
+        "test name": "10,000 AVLTree get randomly",
+        "time taken (ms)": "9.89",
+        "executions per sec": "101.11",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "10,000 AVLTree add & delete randomly",
+        "time taken (ms)": "44.44",
+        "executions per sec": "22.50",
+        "sample deviation": "4.30e-4"
+      }
+    ],
+    "testName": "binary-tree-overall"
+  },
+  "directed-graph": {
+    "benchmarks": [
+      {
+        "test name": "1,000 addVertex",
+        "time taken (ms)": "0.10",
+        "executions per sec": "9766.65",
+        "sample deviation": "9.83e-7"
+      },
+      {
+        "test name": "1,000 addEdge",
+        "time taken (ms)": "6.15",
+        "executions per sec": "162.57",
+        "sample deviation": "7.99e-4"
+      },
+      {
+        "test name": "1,000 getVertex",
+        "time taken (ms)": "0.05",
+        "executions per sec": "2.18e+4",
+        "sample deviation": "4.52e-7"
+      },
+      {
+        "test name": "1,000 getEdge",
+        "time taken (ms)": "22.70",
+        "executions per sec": "44.06",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "tarjan",
+        "time taken (ms)": "203.00",
+        "executions per sec": "4.93",
+        "sample deviation": "0.01"
+      },
+      {
+        "test name": "topologicalSort",
+        "time taken (ms)": "176.40",
+        "executions per sec": "5.67",
+        "sample deviation": "0.00"
+      }
+    ],
+    "testName": "directed-graph"
+  },
+  "doubly-linked-list": {
+    "benchmarks": [
+      {
+        "test name": "1,000,000 push",
+        "time taken (ms)": "222.02",
+        "executions per sec": "4.50",
+        "sample deviation": "0.07"
+      },
+      {
+        "test name": "1,000,000 unshift",
+        "time taken (ms)": "220.41",
+        "executions per sec": "4.54",
+        "sample deviation": "0.05"
+      },
+      {
+        "test name": "1,000,000 unshift & shift",
+        "time taken (ms)": "185.31",
+        "executions per sec": "5.40",
+        "sample deviation": "0.01"
+      },
+      {
+        "test name": "1,000,000 addBefore",
+        "time taken (ms)": "317.20",
+        "executions per sec": "3.15",
+        "sample deviation": "0.07"
+      }
+    ],
+    "testName": "doubly-linked-list"
+  },
+  "singly-linked-list": {
+    "benchmarks": [
+      {
+        "test name": "1,000,000 push & shift",
+        "time taken (ms)": "204.82",
+        "executions per sec": "4.88",
+        "sample deviation": "0.09"
+      },
+      {
+        "test name": "10,000 push & pop",
+        "time taken (ms)": "221.88",
+        "executions per sec": "4.51",
+        "sample deviation": "0.03"
+      },
+      {
+        "test name": "10,000 addBefore",
+        "time taken (ms)": "247.28",
+        "executions per sec": "4.04",
+        "sample deviation": "0.01"
+      }
+    ],
+    "testName": "singly-linked-list"
+  },
+  "priority-queue": {
+    "benchmarks": [
+      {
+        "test name": "100,000 add",
+        "time taken (ms)": "26.97",
+        "executions per sec": "37.08",
+        "sample deviation": "7.97e-4"
+      },
+      {
+        "test name": "100,000 add & poll",
+        "time taken (ms)": "74.55",
+        "executions per sec": "13.41",
+        "sample deviation": "5.19e-4"
+      }
+    ],
+    "testName": "priority-queue"
+  },
+  "stack": {
+    "benchmarks": [
+      {
+        "test name": "1,000,000 push",
+        "time taken (ms)": "35.54",
+        "executions per sec": "28.14",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "1,000,000 push & pop",
+        "time taken (ms)": "44.89",
+        "executions per sec": "22.27",
+        "sample deviation": "0.01"
+      }
+    ],
+    "testName": "stack"
   }
 }

package/dist/cjs/data-structures/base/index.d.ts

@@ -1 +1,2 @@
-export * from './iterable-base';
+export * from './iterable-entry-base';
+export * from './iterable-element-base';

package/dist/cjs/data-structures/base/index.js

@@ -14,5 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./iterable-base"), exports);
+__exportStar(require("./iterable-entry-base"), exports);
+__exportStar(require("./iterable-element-base"), exports);
 //# sourceMappingURL=index.js.map

package/dist/cjs/data-structures/base/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/data-structures/base/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAAgC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/data-structures/base/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wDAAsC;AACtC,0DAAwC"}

package/dist/cjs/data-structures/base/iterable-element-base.d.ts

@@ -0,0 +1,171 @@
+import { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';
+export declare abstract class IterableElementBase<E, R, C> {
+    /**
+     * The protected constructor initializes the options for the IterableElementBase class, including the
+     * toElementFn function.
+     * @param [options] - An optional object that contains the following properties:
+     */
+    protected constructor(options?: IterableElementBaseOptions<E, R>);
+    abstract get size(): number;
+    protected _toElementFn?: (rawElement: R) => E;
+    /**
+     * The function returns the _toElementFn property, which is a function that converts a raw element to
+     * a specific type.
+     * @returns The function `get toElementFn()` is returning either a function that takes a raw element
+     * `rawElement` of type `R` and returns an element `E`, or `undefined` if no function is assigned to
+     * `_toElementFn`.
+     */
+    get toElementFn(): ((rawElement: R) => E) | undefined;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function is an implementation of the Symbol.iterator method that returns an IterableIterator.
+     * @param {any[]} args - The `args` parameter in the code snippet represents a rest parameter. It
+     * allows the function to accept any number of arguments as an array. In this case, the `args`
+     * parameter is used to pass any number of arguments to the `_getIterator` method.
+     */
+    [Symbol.iterator](...args: any[]): IterableIterator<E>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function returns an iterator that yields all the values in the object.
+     */
+    values(): IterableIterator<E>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `every` function checks if every element in the array satisfies a given predicate.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * the current element being processed, its index, and the array it belongs to. It should return a
+     * boolean value indicating whether the element satisfies a certain condition or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `every` method is returning a boolean value. It returns `true` if every element in
+     * the array satisfies the provided predicate function, and `false` otherwise.
+     */
+    every(predicate: ElementCallback<E, R, boolean, C>, thisArg?: any): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The "some" function checks if at least one element in a collection satisfies a given predicate.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * `value`, `index`, and `array`. It should return a boolean value indicating whether the current
+     * element satisfies the condition.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as the `this` value when executing the `predicate` function. If `thisArg` is provided,
+     * it will be passed as the `this` value to the `predicate` function. If `thisArg
+     * @returns a boolean value. It returns true if the predicate function returns true for any element
+     * in the collection, and false otherwise.
+     */
+    some(predicate: ElementCallback<E, R, boolean, C>, thisArg?: any): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `forEach` function iterates over each element in an array-like object and calls a callback
+     * function for each element.
+     * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
+     * the array. It takes three arguments: the current element being processed, the index of the current
+     * element, and the array that forEach was called upon.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+     * be passed as the `this` value to the `callbackfn` function. If `thisArg
+     */
+    forEach(callbackfn: ElementCallback<E, R, void, C>, thisArg?: any): void;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `find` function iterates over the elements of an array-like object and returns the first
+     * element that satisfies the provided callback function.
+     * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
+     * the array. It takes three arguments: the current element being processed, the index of the current
+     * element, and the array itself. The function should return a boolean value indicating whether the
+     * current element matches the desired condition.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+     * be passed as the `this` value to the `callbackfn` function. If `thisArg
+     * @returns The `find` method returns the first element in the array that satisfies the provided
+     * callback function. If no element satisfies the callback function, `undefined` is returned.
+     */
+    find(callbackfn: ElementCallback<E, R, boolean, C>, thisArg?: any): E | undefined;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function checks if a given element exists in a collection.
+     * @param {E} element - The parameter "element" is of type E, which means it can be any type. It
+     * represents the element that we want to check for existence in the collection.
+     * @returns a boolean value. It returns true if the element is found in the collection, and false
+     * otherwise.
+     */
+    has(element: E): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `reduce` function iterates over the elements of an array-like object and applies a callback
+     * function to reduce them into a single value.
+     * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
+     * the array. It takes four arguments:
+     * @param {U} initialValue - The initialValue parameter is the initial value of the accumulator. It
+     * is the value that the accumulator starts with before the reduction operation begins.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
+     * all the elements in the array and applying the callback function to each element.
+     */
+    reduce<U>(callbackfn: ReduceElementCallback<E, R, U, C>, initialValue: U): U;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The print function logs the elements of an array to the console.
+     */
+    print(): void;
+    abstract isEmpty(): boolean;
+    abstract clear(): void;
+    abstract clone(): C;
+    abstract map(...args: any[]): any;
+    abstract filter(...args: any[]): any;
+    protected abstract _getIterator(...args: any[]): IterableIterator<E>;
+}