graph-typed 1.54.2 → 2.0.0

package/dist/types/data-structures/binary-tree/binary-tree.d.ts

@@ -5,6 +5,7 @@ export type BinaryTreeOptions<K, V, R> = {
     iterationType?: IterationType;
     toEntryFn?: ToEntryFn<K, V, R>;
     isMapMode?: boolean;
+    isDuplicate?: boolean;
 };
 export type BinaryTreePrintOptions = {
     isShowUndefined?: boolean;

package/dist/types/data-structures/binary-tree/bst.d.ts

@@ -1,7 +1,7 @@
 import type { BinaryTreeOptions } from './binary-tree';
 import { Comparable } from '../../utils';
 import { OptValue } from '../../common';
-export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
+export type BSTOptions<K, V, R> = Omit<BinaryTreeOptions<K, V, R>, 'isDuplicate'> & {
     specifyComparable?: (key: K) => Comparable;
     isReverse?: boolean;
 };

package/dist/types/data-structures/binary-tree/tree-multi-map.d.ts

@@ -1,2 +1,2 @@
 import type { RedBlackTreeOptions } from './red-black-tree';
-export type TreeMultiMapOptions<K, V, R> = Omit<RedBlackTreeOptions<K, V, R>, 'isMapMode'> & {};
+export type TreeMultiMapOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {};

package/dist/types/data-structures/linked-list/doubly-linked-list.d.ts

@@ -1,2 +1,2 @@
-import { IterableElementBaseOptions } from '../base';
-export type DoublyLinkedListOptions<E, R> = IterableElementBaseOptions<E, R> & {};
+import { LinearBaseOptions } from '../base';
+export type DoublyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};

package/dist/types/data-structures/linked-list/singly-linked-list.d.ts

@@ -1,2 +1,2 @@
-import { IterableElementBaseOptions } from '../base';
-export type SinglyLinkedListOptions<E, R> = IterableElementBaseOptions<E, R> & {};
+import { LinearBaseOptions } from '../base';
+export type SinglyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};

package/dist/types/data-structures/queue/deque.d.ts

@@ -1,5 +1,4 @@
-import { IterableElementBaseOptions } from '../base';
+import { LinearBaseOptions } from '../base';
 export type DequeOptions<E, R> = {
     bucketSize?: number;
-    maxLen?: number;
-} & IterableElementBaseOptions<E, R>;
+} & LinearBaseOptions<E, R>;

package/dist/types/data-structures/queue/queue.d.ts

@@ -1,4 +1,4 @@
-import { IterableElementBaseOptions } from '../base';
-export type QueueOptions<E, R> = IterableElementBaseOptions<E, R> & {
+import { LinearBaseOptions } from '../base';
+export type QueueOptions<E, R> = LinearBaseOptions<E, R> & {
     autoCompactRatio?: number;
 };

package/dist/utils/utils.d.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 { Comparable, Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from '../types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graph-typed",
-  "version": "1.54.2",
+  "version": "2.0.0",
   "description": "Graph. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -136,6 +136,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.54.2"
+    "data-structure-typed": "^2.0.0"
   }
 }

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

@@ -1,6 +1,6 @@
 import { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';
 
-export abstract class IterableElementBase<E, R, C> {
+export abstract class IterableElementBase<E, R> {
   /**
    * The protected constructor initializes the options for the IterableElementBase class, including the
    * toElementFn function.
@@ -14,17 +14,8 @@ export abstract class IterableElementBase<E, R, C> {
     }
   }
 
-  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 {
     return this._toElementFn;
   }
@@ -68,7 +59,7 @@ export abstract class IterableElementBase<E, R, C> {
    * @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 {
+  every(predicate: ElementCallback<E, R, boolean>, thisArg?: any): boolean {
     let index = 0;
     for (const item of this) {
       if (!predicate.call(thisArg, item, index++, this)) {
@@ -92,7 +83,7 @@ export abstract class IterableElementBase<E, R, C> {
    * @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 {
+  some(predicate: ElementCallback<E, R, boolean>, thisArg?: any): boolean {
     let index = 0;
     for (const item of this) {
       if (predicate.call(thisArg, item, index++, this)) {
@@ -115,20 +106,23 @@ export abstract class IterableElementBase<E, R, C> {
    * 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 {
+  forEach(callbackfn: ElementCallback<E, R, void>, thisArg?: any): void {
     let index = 0;
     for (const item of this) {
       callbackfn.call(thisArg, item, index++, this);
     }
   }
 
+  find<S extends E>(predicate: ElementCallback<E, R, S>, thisArg?: any): S | undefined;
+  find(predicate: ElementCallback<E, R, unknown>, thisArg?: any): E | undefined;
+
   /**
    * 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
+   * @param predicate - The predicate 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.
@@ -138,10 +132,10 @@ export abstract class IterableElementBase<E, R, C> {
    * @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 {
+  find(predicate: ElementCallback<E, R, boolean>, thisArg?: any): E | undefined {
     let index = 0;
     for (const item of this) {
-      if (callbackfn.call(thisArg, item, index++, this)) return item;
+      if (predicate.call(thisArg, item, index++, this)) return item;
     }
 
     return;
@@ -164,6 +158,10 @@ export abstract class IterableElementBase<E, R, C> {
     return false;
   }
 
+  reduce(callbackfn: ReduceElementCallback<E, R>): E;
+  reduce(callbackfn: ReduceElementCallback<E, R>, initialValue: E): E;
+  reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue: U): U;
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -177,15 +175,26 @@ export abstract class IterableElementBase<E, R, C> {
    * @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 {
-    let accumulator = initialValue;
+  reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue?: U): U {
+    let accumulator = initialValue ?? (0 as U);
     let index = 0;
     for (const item of this) {
-      accumulator = callbackfn(accumulator, item as E, index++, this);
+      accumulator = callbackfn(accumulator, item, index++, this);
     }
     return accumulator;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `toArray` function converts a linked list into an array.
+   * @returns The `toArray()` method is returning an array of type `E[]`.
+   */
+  toArray(): E[] {
+    return [...this];
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -210,7 +219,7 @@ export abstract class IterableElementBase<E, R, C> {
 
   abstract clear(): void;
 
-  abstract clone(): C;
+  abstract clone(): IterableElementBase<E, R>;
 
   abstract map(...args: any[]): any;