data-structure-typed 1.33.0 → 1.33.2

package/lib/data-structures/queue/deque.d.ts

@@ -6,13 +6,13 @@
  * @license MIT License
  */
 import { DoublyLinkedList } from '../linked-list';
-export declare class Deque<T> extends DoublyLinkedList<T> {
+export declare class Deque<E = any> extends DoublyLinkedList<E> {
 }
-export declare class ObjectDeque<T = number> {
+export declare class ObjectDeque<E = number> {
     constructor(capacity?: number);
     private _nodes;
     get nodes(): {
-        [p: number]: T;
+        [p: number]: E;
     };
     private _capacity;
     get capacity(): number;
@@ -27,35 +27,35 @@ export declare class ObjectDeque<T = number> {
     get size(): number;
     /**
      * The "addFirst" function adds a value to the beginning of an array-like data structure.
-     * @param {T} value - The `value` parameter represents the value that you want to add to the beginning of the data
+     * @param {E} value - The `value` parameter represents the value that you want to add to the beginning of the data
      * structure.
      */
-    addFirst(value: T): void;
+    addFirst(value: E): void;
     /**
      * The addLast function adds a value to the end of an array-like data structure.
-     * @param {T} value - The `value` parameter represents the value that you want to add to the end of the data structure.
+     * @param {E} value - The `value` parameter represents the value that you want to add to the end of the data structure.
      */
-    addLast(value: T): void;
+    addLast(value: E): void;
     /**
      * The function `pollFirst()` removes and returns the first element in a data structure.
      * @returns The value of the first element in the data structure.
      */
-    pollFirst(): T | undefined;
+    pollFirst(): E | undefined;
     /**
      * The `peekFirst` function returns the first element in an array-like data structure if it exists.
      * @returns The element at the first position of the `_nodes` array.
      */
-    peekFirst(): T | undefined;
+    peekFirst(): E | undefined;
     /**
      * The `pollLast()` function removes and returns the last element in a data structure.
      * @returns The value that was removed from the data structure.
      */
-    pollLast(): T | undefined;
+    pollLast(): E | undefined;
     /**
      * The `peekLast()` function returns the last element in an array-like data structure.
      * @returns The last element in the array "_nodes" is being returned.
      */
-    peekLast(): T | undefined;
+    peekLast(): E | undefined;
     /**
      * The get function returns the element at the specified index in an array-like data structure.
      * @param {number} index - The index parameter is a number that represents the position of the element you want to
@@ -63,61 +63,61 @@ export declare class ObjectDeque<T = number> {
      * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
      * index, `null` is returned.
      */
-    get(index: number): NonNullable<T> | null;
+    get(index: number): NonNullable<E> | null;
     /**
      * The function checks if the size of a data structure is less than or equal to zero.
      * @returns The method is returning a boolean value indicating whether the size of the object is less than or equal to 0.
      */
     isEmpty(): boolean;
     protected _seNodes(value: {
-        [p: number]: T;
+        [p: number]: E;
     }): void;
     protected _setSize(value: number): void;
 }
-export declare class ArrayDeque<T> {
-    protected _nodes: T[];
+export declare class ArrayDeque<E> {
+    protected _nodes: E[];
     get size(): number;
     /**
      * O(n) time complexity of adding at the beginning and the end
      */
     /**
      * The function "addLast" adds a value to the end of an array.
-     * @param {T} value - The value parameter represents the value that you want to add to the end of the array.
+     * @param {E} value - The value parameter represents the value that you want to add to the end of the array.
      * @returns The return value is the new length of the array after the value has been added.
      */
-    addLast(value: T): number;
+    addLast(value: E): number;
     /**
      * The function "pollLast" returns and removes the last element from an array, or returns null if the array is empty.
      * @returns The method `pollLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
-    pollLast(): T | null;
+    pollLast(): E | null;
     /**
      * The `pollFirst` function removes and returns the first element from an array, or returns null if the array is empty.
      * @returns The `pollFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
      * empty.
      */
-    pollFirst(): T | null;
+    pollFirst(): E | null;
     /**
      * O(n) time complexity of adding at the beginning and the end
      */
     /**
      * The function "addFirst" adds a value to the beginning of an array.
-     * @param {T} value - The value parameter represents the value that you want to add to the beginning of the array.
+     * @param {E} value - The value parameter represents the value that you want to add to the beginning of the array.
      * @returns The return value of the `addFirst` function is the new length of the array `_nodes` after adding the
      * `value` at the beginning.
      */
-    addFirst(value: T): number;
+    addFirst(value: E): number;
     /**
      * The `peekFirst` function returns the first element of an array or null if the array is empty.
-     * @returns The function `peekFirst()` is returning the first element (`T`) of the `_nodes` array. If the array is
+     * @returns The function `peekFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
      * empty, it will return `null`.
      */
-    peekFirst(): T | null;
+    peekFirst(): E | null;
     /**
      * The `peekLast` function returns the last element of an array or null if the array is empty.
      * @returns The method `peekLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
-    peekLast(): T | null;
+    peekLast(): E | null;
     /**
      * O(1) time complexity of obtaining the value
      */
@@ -128,34 +128,34 @@ export declare class ArrayDeque<T> {
      * @returns The method is returning the element at the specified index in the `_nodes` array. If the element exists, it
      * will be returned. If the element does not exist (i.e., the index is out of bounds), `null` will be returned.
      */
-    get(index: number): T | null;
+    get(index: number): E | null;
     /**
      * The set function assigns a value to a specific index in an array.
      * @param {number} index - The index parameter is a number that represents the position of the element in the array
      * that you want to set a new value for.
-     * @param {T} value - The value parameter represents the new value that you want to set at the specified index in the
+     * @param {E} value - The value parameter represents the new value that you want to set at the specified index in the
      * _nodes array.
      * @returns The value that is being set at the specified index in the `_nodes` array.
      */
-    set(index: number, value: T): T;
+    set(index: number, value: E): E;
     /**
      * The insert function adds a value at a specified index in an array.
      * @param {number} index - The index parameter specifies the position at which the value should be inserted in the
      * array. It is a number that represents the index of the array where the value should be inserted. The index starts
      * from 0, so the first element of the array has an index of 0, the second element has
-     * @param {T} value - The value parameter represents the value that you want to insert into the array at the specified
+     * @param {E} value - The value parameter represents the value that you want to insert into the array at the specified
      * index.
      * @returns The splice method returns an array containing the removed elements, if any. In this case, since no elements
      * are being removed, an empty array will be returned.
      */
-    insert(index: number, value: T): T[];
+    insert(index: number, value: E): E[];
     /**
      * The remove function removes an element from an array at a specified index.
      * @param {number} index - The index parameter specifies the position of the element to be removed from the array. It
      * is a number that represents the index of the element to be removed.
      * @returns The method is returning an array containing the removed element.
      */
-    remove(index: number): T[];
+    remove(index: number): E[];
     /**
      * The function checks if an array called "_nodes" is empty.
      * @returns The method `isEmpty()` is returning a boolean value. It returns `true` if the length of the `_nodes` array

package/lib/data-structures/queue/deque.js

@@ -49,7 +49,7 @@ export class ObjectDeque {
     }
     /**
      * The "addFirst" function adds a value to the beginning of an array-like data structure.
-     * @param {T} value - The `value` parameter represents the value that you want to add to the beginning of the data
+     * @param {E} value - The `value` parameter represents the value that you want to add to the beginning of the data
      * structure.
      */
     addFirst(value) {
@@ -66,7 +66,7 @@ export class ObjectDeque {
     }
     /**
      * The addLast function adds a value to the end of an array-like data structure.
-     * @param {T} value - The `value` parameter represents the value that you want to add to the end of the data structure.
+     * @param {E} value - The `value` parameter represents the value that you want to add to the end of the data structure.
      */
     addLast(value) {
         if (this._size === 0) {
@@ -160,7 +160,7 @@ export class ArrayDeque {
      */
     /**
      * The function "addLast" adds a value to the end of an array.
-     * @param {T} value - The value parameter represents the value that you want to add to the end of the array.
+     * @param {E} value - The value parameter represents the value that you want to add to the end of the array.
      * @returns The return value is the new length of the array after the value has been added.
      */
     addLast(value) {
@@ -188,7 +188,7 @@ export class ArrayDeque {
      */
     /**
      * The function "addFirst" adds a value to the beginning of an array.
-     * @param {T} value - The value parameter represents the value that you want to add to the beginning of the array.
+     * @param {E} value - The value parameter represents the value that you want to add to the beginning of the array.
      * @returns The return value of the `addFirst` function is the new length of the array `_nodes` after adding the
      * `value` at the beginning.
      */
@@ -197,7 +197,7 @@ export class ArrayDeque {
     }
     /**
      * The `peekFirst` function returns the first element of an array or null if the array is empty.
-     * @returns The function `peekFirst()` is returning the first element (`T`) of the `_nodes` array. If the array is
+     * @returns The function `peekFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
      * empty, it will return `null`.
      */
     peekFirst() {
@@ -230,7 +230,7 @@ export class ArrayDeque {
      * The set function assigns a value to a specific index in an array.
      * @param {number} index - The index parameter is a number that represents the position of the element in the array
      * that you want to set a new value for.
-     * @param {T} value - The value parameter represents the new value that you want to set at the specified index in the
+     * @param {E} value - The value parameter represents the new value that you want to set at the specified index in the
      * _nodes array.
      * @returns The value that is being set at the specified index in the `_nodes` array.
      */
@@ -242,7 +242,7 @@ export class ArrayDeque {
      * @param {number} index - The index parameter specifies the position at which the value should be inserted in the
      * array. It is a number that represents the index of the array where the value should be inserted. The index starts
      * from 0, so the first element of the array has an index of 0, the second element has
-     * @param {T} value - The value parameter represents the value that you want to insert into the array at the specified
+     * @param {E} value - The value parameter represents the value that you want to insert into the array at the specified
      * index.
      * @returns The splice method returns an array containing the removed elements, if any. In this case, since no elements
      * are being removed, an empty array will be returned.

package/lib/data-structures/queue/queue.d.ts

@@ -4,34 +4,34 @@
  * @class
  */
 import { SinglyLinkedList } from '../linked-list';
-export declare class LinkedListQueue<T = any> extends SinglyLinkedList<T> {
+export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
     /**
      * The enqueue function adds a value to the end of an array.
-     * @param {T} value - The value parameter represents the value that you want to add to the queue.
+     * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
-    enqueue(value: T): void;
+    enqueue(value: E): void;
     /**
      * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
      * @returns The method is returning the element at the front of the queue, or null if the queue is empty.
      */
-    dequeue(): T | undefined;
+    dequeue(): E | undefined;
     /**
      * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
      * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
      */
-    peek(): T | undefined;
+    peek(): E | undefined;
 }
-export declare class Queue<T = any> {
+export declare class Queue<E = any> {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
-     * @param {T[]} [elements] - The `elements` parameter is an optional array of elements of type `T`. If provided, it
+     * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
      * will be used to initialize the `_nodes` property of the class. If not provided, the `_nodes` property will be
      * initialized as an empty array.
      */
-    constructor(elements?: T[]);
+    constructor(elements?: E[]);
     private _nodes;
-    get nodes(): T[];
-    set nodes(value: T[]);
+    get nodes(): E[];
+    set nodes(value: E[]);
     private _offset;
     get offset(): number;
     set offset(value: number);
@@ -44,46 +44,46 @@ export declare class Queue<T = any> {
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
      * @static
-     * @param {T[]} elements - The "elements" parameter is an array of elements of type T.
+     * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
      * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
      * array.
      */
-    static fromArray<T>(elements: T[]): Queue<T>;
+    static fromArray<E>(elements: E[]): Queue<E>;
     /**
      * The push function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
-     * @param {T} element - The `element` parameter represents the element that you want to add to the queue.
-     * @returns The `add` method is returning a `Queue<T>` object.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the queue.
+     * @returns The `add` method is returning a `Queue<E>` object.
      */
-    push(element: T): Queue<T>;
+    push(element: E): Queue<E>;
     /**
      * The `shift` function removes and returns the first element in the queue, and adjusts the internal data structure if
      * necessary to optimize performance.
      * @returns The function `shift()` returns either the first element in the queue or `null` if the queue is empty.
      */
-    shift(): T | undefined;
+    shift(): E | undefined;
     /**
      * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
      * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
      * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
      */
-    peek(): T | undefined;
+    peek(): E | undefined;
     /**
      * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
      * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
      * array is empty, it returns `null`.
      */
-    peekLast(): T | undefined;
+    peekLast(): E | undefined;
     /**
      * The enqueue function adds a value to the end of a queue.
-     * @param {T} value - The value parameter represents the value that you want to add to the queue.
+     * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
-    enqueue(value: T): void;
+    enqueue(value: E): void;
     /**
      * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
-     * @returns The method is returning a value of type T or null.
+     * @returns The method is returning a value of type E or null.
      */
-    dequeue(): T | undefined;
-    getAt(index: number): T | undefined;
+    dequeue(): E | undefined;
+    getAt(index: number): E | undefined;
     /**
      * The function checks if a data structure is empty by comparing its size to zero.
      * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
@@ -91,9 +91,9 @@ export declare class Queue<T = any> {
     isEmpty(): boolean;
     /**
      * The toArray() function returns an array of elements from the current offset to the end of the _nodes array.
-     * @returns An array of type T is being returned.
+     * @returns An array of type E is being returned.
      */
-    toArray(): T[];
+    toArray(): E[];
     /**
      * The clear function resets the nodes array and offset to their initial values.
      */
@@ -102,6 +102,6 @@ export declare class Queue<T = any> {
      * The `clone()` function returns a new Queue object with the same elements as the original Queue.
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
-    clone(): Queue<T>;
-    [Symbol.iterator](): Generator<T, void, unknown>;
+    clone(): Queue<E>;
+    [Symbol.iterator](): Generator<E, void, unknown>;
 }

package/lib/data-structures/queue/queue.js

@@ -7,7 +7,7 @@ import { SinglyLinkedList } from '../linked-list';
 export class LinkedListQueue extends SinglyLinkedList {
     /**
      * The enqueue function adds a value to the end of an array.
-     * @param {T} value - The value parameter represents the value that you want to add to the queue.
+     * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
     enqueue(value) {
         this.push(value);
@@ -31,7 +31,7 @@ export class LinkedListQueue extends SinglyLinkedList {
 export class Queue {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
-     * @param {T[]} [elements] - The `elements` parameter is an optional array of elements of type `T`. If provided, it
+     * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
      * will be used to initialize the `_nodes` property of the class. If not provided, the `_nodes` property will be
      * initialized as an empty array.
      */
@@ -62,7 +62,7 @@ export class Queue {
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
      * @static
-     * @param {T[]} elements - The "elements" parameter is an array of elements of type T.
+     * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
      * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
      * array.
      */
@@ -71,8 +71,8 @@ export class Queue {
     }
     /**
      * The push function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
-     * @param {T} element - The `element` parameter represents the element that you want to add to the queue.
-     * @returns The `add` method is returning a `Queue<T>` object.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the queue.
+     * @returns The `add` method is returning a `Queue<E>` object.
      */
     push(element) {
         this.nodes.push(element);
@@ -114,14 +114,14 @@ export class Queue {
     }
     /**
      * The enqueue function adds a value to the end of a queue.
-     * @param {T} value - The value parameter represents the value that you want to add to the queue.
+     * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
     enqueue(value) {
         this.push(value);
     }
     /**
      * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
-     * @returns The method is returning a value of type T or null.
+     * @returns The method is returning a value of type E or null.
      */
     dequeue() {
         return this.shift();
@@ -138,7 +138,7 @@ export class Queue {
     }
     /**
      * The toArray() function returns an array of elements from the current offset to the end of the _nodes array.
-     * @returns An array of type T is being returned.
+     * @returns An array of type E is being returned.
      */
     toArray() {
         return this.nodes.slice(this.offset);

package/lib/data-structures/stack/stack.d.ts

@@ -3,22 +3,22 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-export declare class Stack<T = number> {
-    protected _elements: T[];
+export declare class Stack<E = any> {
+    protected _elements: E[];
     /**
      * The constructor initializes an array of elements, which can be provided as an optional parameter.
-     * @param {T[]} [elements] - The `elements` parameter is an optional parameter of type `T[]`, which represents an array
-     * of elements of type `T`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
+     * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
+     * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
      * is provided and is an array, it is assigned to the `_elements
      */
-    constructor(elements?: T[]);
+    constructor(elements?: E[]);
     /**
      * The function "fromArray" creates a new Stack object from an array of elements.
-     * @param {T[]} elements - The `elements` parameter is an array of elements of type `T`.
+     * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
      * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
      * array.
      */
-    static fromArray<T>(elements: T[]): Stack<T>;
+    static fromArray<E>(elements: E[]): Stack<E>;
     /**
      * The function checks if an array is empty and returns a boolean value.
      * @returns A boolean value indicating whether the `_elements` array is empty or not.
@@ -33,24 +33,24 @@ export declare class Stack<T = number> {
      * The `peek` function returns the last element of an array, or null if the array is empty.
      * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
      */
-    peek(): T | null;
+    peek(): E | null;
     /**
      * The push function adds an element to the stack and returns the updated stack.
-     * @param {T} element - The parameter "element" is of type T, which means it can be any data type.
-     * @returns The `push` method is returning the updated `Stack<T>` object.
+     * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
+     * @returns The `push` method is returning the updated `Stack<E>` object.
      */
-    push(element: T): Stack<T>;
+    push(element: E): Stack<E>;
     /**
      * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
      * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
      * array is empty, it returns `null`.
      */
-    pop(): T | null;
+    pop(): E | null;
     /**
      * The toArray function returns a copy of the elements in an array.
-     * @returns An array of type T.
+     * @returns An array of type E.
      */
-    toArray(): T[];
+    toArray(): E[];
     /**
      * The clear function clears the elements array.
      */
@@ -59,5 +59,5 @@ export declare class Stack<T = number> {
      * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */
-    clone(): Stack<T>;
+    clone(): Stack<E>;
 }

package/lib/data-structures/stack/stack.js

@@ -6,8 +6,8 @@
 export class Stack {
     /**
      * The constructor initializes an array of elements, which can be provided as an optional parameter.
-     * @param {T[]} [elements] - The `elements` parameter is an optional parameter of type `T[]`, which represents an array
-     * of elements of type `T`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
+     * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
+     * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
      * is provided and is an array, it is assigned to the `_elements
      */
     constructor(elements) {
@@ -15,7 +15,7 @@ export class Stack {
     }
     /**
      * The function "fromArray" creates a new Stack object from an array of elements.
-     * @param {T[]} elements - The `elements` parameter is an array of elements of type `T`.
+     * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
      * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
      * array.
      */
@@ -47,8 +47,8 @@ export class Stack {
     }
     /**
      * The push function adds an element to the stack and returns the updated stack.
-     * @param {T} element - The parameter "element" is of type T, which means it can be any data type.
-     * @returns The `push` method is returning the updated `Stack<T>` object.
+     * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
+     * @returns The `push` method is returning the updated `Stack<E>` object.
      */
     push(element) {
         this._elements.push(element);
@@ -66,7 +66,7 @@ export class Stack {
     }
     /**
      * The toArray function returns a copy of the elements in an array.
-     * @returns An array of type T.
+     * @returns An array of type E.
      */
     toArray() {
         return this._elements.slice();

package/lib/data-structures/tree/tree.d.ts

@@ -1,14 +1,14 @@
-export declare class TreeNode<T = any> {
-    constructor(id: string, value?: T, children?: TreeNode<T>[]);
+export declare class TreeNode<V = any> {
+    constructor(id: string, value?: V, children?: TreeNode<V>[]);
     private _id;
     get id(): string;
     set id(value: string);
     private _value?;
-    get value(): T | undefined;
-    set value(value: T | undefined);
+    get value(): V | undefined;
+    set value(value: V | undefined);
     private _children?;
-    get children(): TreeNode<T>[] | undefined;
-    set children(value: TreeNode<T>[] | undefined);
-    addChildren(children: TreeNode<T> | TreeNode<T>[]): void;
+    get children(): TreeNode<V>[] | undefined;
+    set children(value: TreeNode<V>[] | undefined);
+    addChildren(children: TreeNode<V> | TreeNode<V>[]): void;
     getHeight(): number;
 }

package/lib/interfaces/abstract-binary-tree.d.ts

@@ -21,7 +21,6 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
     get visitedId(): BinaryTreeNodeId[];
     get visitedVal(): Array<N['val']>;
     get visitedNode(): N[];
-    get visitedLeftSum(): number[];
     get root(): N | null;
     get size(): number;
     swapLocation(srcNode: N, destNode: N): N;

package/lib/interfaces/avl-tree.d.ts

@@ -4,5 +4,5 @@ import { BinaryTreeDeletedResult, BinaryTreeNodeId } from '../types';
 export type IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> = IBSTNode<T, NEIGHBOR>;
 export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
     add(id: BinaryTreeNodeId, val?: N['val'] | null): N | null | undefined;
-    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): BinaryTreeDeletedResult<N>[];
+    remove(id: BinaryTreeNodeId): BinaryTreeDeletedResult<N>[];
 }

package/lib/types/data-structures/navigator.d.ts

@@ -2,7 +2,7 @@ export type Direction = 'up' | 'right' | 'down' | 'left';
 export type Turning = {
     [key in Direction]: Direction;
 };
-export type NavigatorParams<T> = {
+export type NavigatorParams<T = any> = {
     matrix: T[][];
     turning: Turning;
     onMove: (cur: [number, number]) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.33.0",
+  "version": "1.33.2",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/index.js",
   "module": "lib/index.js",
@@ -15,13 +15,14 @@
     "build:docs": "typedoc --out docs ./src",
     "lint": "eslint --fix 'src/**/*.{js,ts}'",
     "format": "prettier --write 'src/**/*.{js,ts}'",
+    "fix": "npm run lint && npm run format",
     "update:test-deps": "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-multiset-typed trie-typed undirected-graph-typed queue-typed --save-dev",
     "test": "jest",
     "deps:check": "dependency-cruiser src",
     "changelog": "auto-changelog",
     "coverage:badge": "istanbul-badges-readme",
     "package": "npm run lint && npm run test && npm run build && npm run build:docs && npm run changelog",
-    "deploy": "npm run package && npm publish"
+    "deploy": "npm publish"
   },
   "repository": {
     "type": "git",
@@ -41,7 +42,6 @@
     "in data structure",
     "DataStructure",
     "DataStructures",
-
     "binary",
     "depth",
     "breadth",
@@ -69,13 +69,11 @@
     "ts",
     "javascript",
     "typscript",
-
     "Node.js",
     "CommonJS",
     "ES6",
     "UMD",
     "esmodule",
-
     "java.util",
     "c++ std",
     "Python collections",