data-structure-typed 1.39.0 → 1.39.2

package/dist/mjs/data-structures/linked-list/singly-linked-list.js

@@ -74,16 +74,13 @@ class SinglyLinkedList {
         }
         return singlyLinkedList;
     }
-    getLength() {
-        return this._length;
-    }
     /**
-     * The `push` function adds a new node with the given data to the end of a singly linked list.
-     * @param {E} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
+     * The `push` function adds a new node with the given val to the end of a singly linked list.
+     * @param {E} val - The "val" parameter represents the value that you want to add to the linked list. It can be of
      * any type (E) as specified in the generic type declaration of the class or function.
      */
-    push(data) {
-        const newNode = new SinglyLinkedListNode(data);
+    push(val) {
+        const newNode = new SinglyLinkedListNode(val);
         if (!this.head) {
             this.head = newNode;
             this.tail = newNode;
@@ -94,6 +91,14 @@ class SinglyLinkedList {
         }
         this._length++;
     }
+    /**
+     * The `push` function adds a new node with the given val to the end of a singly linked list.
+     * @param {E} val - The "val" parameter represents the value that you want to add to the linked list. It can be of
+     * any type (E) as specified in the generic type declaration of the class or function.
+     */
+    addLast(val) {
+        this.push(val);
+    }
     /**
      * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
@@ -120,6 +125,15 @@ class SinglyLinkedList {
         this._length--;
         return val;
     }
+    /**
+     * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
+     * pointers accordingly.
+     * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
+     * the linked list is empty, it returns `null`.
+     */
+    popLast() {
+        return this.pop();
+    }
     /**
      * The `shift()` function removes and returns the value of the first node in a linked list.
      * @returns The value of the node that is being removed from the beginning of the linked list.
@@ -132,6 +146,13 @@ class SinglyLinkedList {
         this._length--;
         return removedNode.val;
     }
+    /**
+     * The `popFirst()` function removes and returns the value of the first node in a linked list.
+     * @returns The value of the node that is being removed from the beginning of the linked list.
+     */
+    popFirst() {
+        return this.shift();
+    }
     /**
      * The unshift function adds a new node with the given value to the beginning of a singly linked list.
      * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
@@ -149,6 +170,14 @@ class SinglyLinkedList {
         }
         this._length++;
     }
+    /**
+     * The addFirst function adds a new node with the given value to the beginning of a singly linked list.
+     * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
+     * linked list.
+     */
+    addFirst(val) {
+        this.unshift(val);
+    }
     /**
      * The function `getAt` returns the value at a specified index in a linked list, or null if the index is out of range.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
@@ -355,7 +384,7 @@ class SinglyLinkedList {
      * @returns a `SinglyLinkedListNode<E>` if a node with the specified value is found in the linked list. If no node with
      * the specified value is found, the function returns `null`.
      */
-    findNode(value) {
+    getNode(value) {
         let current = this.head;
         while (current) {
             if (current.val === value) {
@@ -414,7 +443,7 @@ class SinglyLinkedList {
             existingNode = existingValueOrNode;
         }
         else {
-            existingNode = this.findNode(existingValueOrNode);
+            existingNode = this.getNode(existingValueOrNode);
         }
         if (existingNode) {
             const newNode = new SinglyLinkedListNode(newValue);
@@ -444,6 +473,78 @@ class SinglyLinkedList {
         }
         return count;
     }
+    /**
+     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
+     * @param callback - The callback parameter is a function that takes two arguments: val and index. The val argument
+     * represents the value of the current node in the linked list, and the index argument represents the index of the
+     * current node in the linked list.
+     */
+    forEach(callback) {
+        let current = this.head;
+        let index = 0;
+        while (current) {
+            callback(current.val, index);
+            current = current.next;
+            index++;
+        }
+    }
+    /**
+     * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
+     * SinglyLinkedList with the transformed values.
+     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+     * the original SinglyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
+     * SinglyLinkedList).
+     * @returns The `map` function is returning a new instance of `SinglyLinkedList<U>` that contains the mapped values.
+     */
+    map(callback) {
+        const mappedList = new SinglyLinkedList();
+        let current = this.head;
+        while (current) {
+            mappedList.push(callback(current.val));
+            current = current.next;
+        }
+        return mappedList;
+    }
+    /**
+     * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
+     * elements that satisfy the given callback function.
+     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
+     * It is used to determine whether a value should be included in the filtered list or not.
+     * @returns The filtered list, which is an instance of the SinglyLinkedList class.
+     */
+    filter(callback) {
+        const filteredList = new SinglyLinkedList();
+        let current = this.head;
+        while (current) {
+            if (callback(current.val)) {
+                filteredList.push(current.val);
+            }
+            current = current.next;
+        }
+        return filteredList;
+    }
+    /**
+     * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
+     * single value.
+     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `val`. It is
+     * used to perform a specific operation on each element of the linked list.
+     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+     * point for the reduction operation.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
+     * elements in the linked list.
+     */
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let current = this.head;
+        while (current) {
+            accumulator = callback(accumulator, current.val);
+            current = current.next;
+        }
+        return accumulator;
+    }
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
     *[Symbol.iterator]() {
         let current = this.head;
         while (current) {

package/dist/mjs/data-structures/matrix/matrix2d.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import Vector2D from './vector2d';
+import { Vector2D } from './vector2d';
 export declare class Matrix2D {
     private readonly _matrix;
     /**
@@ -105,4 +105,3 @@ export declare class Matrix2D {
      */
     toVector(): Vector2D;
 }
-export default Matrix2D;

package/dist/mjs/data-structures/matrix/matrix2d.js

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Matrix2D = void 0;
 /**
@@ -11,7 +8,7 @@ exports.Matrix2D = void 0;
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-const vector2d_1 = __importDefault(require("./vector2d"));
+const vector2d_1 = require("./vector2d");
 class Matrix2D {
     _matrix;
     /**
@@ -24,7 +21,7 @@ class Matrix2D {
         if (typeof value === 'undefined') {
             this._matrix = Matrix2D.identity;
         }
-        else if (value instanceof vector2d_1.default) {
+        else if (value instanceof vector2d_1.Vector2D) {
             this._matrix = Matrix2D.identity;
             this._matrix[0][0] = value.x;
             this._matrix[1][0] = value.y;
@@ -197,8 +194,7 @@ class Matrix2D {
      * the first column of the matrix.
      */
     toVector() {
-        return new vector2d_1.default(this._matrix[0][0], this._matrix[1][0]);
+        return new vector2d_1.Vector2D(this._matrix[0][0], this._matrix[1][0]);
     }
 }
 exports.Matrix2D = Matrix2D;
-exports.default = Matrix2D;

package/dist/mjs/data-structures/matrix/vector2d.d.ts

@@ -198,4 +198,3 @@ export declare class Vector2D {
      */
     zero(): void;
 }
-export default Vector2D;

package/dist/mjs/data-structures/matrix/vector2d.js

@@ -291,4 +291,3 @@ class Vector2D {
     }
 }
 exports.Vector2D = Vector2D;
-exports.default = Vector2D;

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

@@ -37,25 +37,25 @@ export declare class ObjectDeque<E = number> {
      */
     addLast(value: E): void;
     /**
-     * The function `pollFirst()` removes and returns the first element in a data structure.
+     * The function `popFirst()` removes and returns the first element in a data structure.
      * @returns The value of the first element in the data structure.
      */
-    pollFirst(): E | undefined;
+    popFirst(): E | undefined;
     /**
-     * The `peekFirst` function returns the first element in an array-like data structure if it exists.
+     * The `getFirst` 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(): E | undefined;
+    getFirst(): E | undefined;
     /**
-     * The `pollLast()` function removes and returns the last element in a data structure.
+     * The `popLast()` function removes and returns the last element in a data structure.
      * @returns The value that was removed from the data structure.
      */
-    pollLast(): E | undefined;
+    popLast(): E | undefined;
     /**
-     * The `peekLast()` function returns the last element in an array-like data structure.
+     * The `getLast()` function returns the last element in an array-like data structure.
      * @returns The last element in the array "_nodes" is being returned.
      */
-    peekLast(): E | undefined;
+    getLast(): 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
@@ -87,16 +87,16 @@ export declare class ArrayDeque<E> {
      */
     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.
+     * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty.
+     * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
-    pollLast(): E | null;
+    popLast(): 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
+     * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty.
+     * @returns The `popFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
      * empty.
      */
-    pollFirst(): E | null;
+    popFirst(): E | null;
     /**
      * O(n) time complexity of adding at the beginning and the end
      */
@@ -108,16 +108,16 @@ export declare class ArrayDeque<E> {
      */
     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 (`E`) of the `_nodes` array. If the array is
+     * The `getFirst` function returns the first element of an array or null if the array is empty.
+     * @returns The function `getFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
      * empty, it will return `null`.
      */
-    peekFirst(): E | null;
+    getFirst(): 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.
+     * The `getLast` function returns the last element of an array or null if the array is empty.
+     * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
-    peekLast(): E | null;
+    getLast(): E | null;
     /**
      * O(1) time complexity of obtaining the value
      */

package/dist/mjs/data-structures/queue/deque.js

@@ -85,44 +85,44 @@ class ObjectDeque {
         this._size++;
     }
     /**
-     * The function `pollFirst()` removes and returns the first element in a data structure.
+     * The function `popFirst()` removes and returns the first element in a data structure.
      * @returns The value of the first element in the data structure.
      */
-    pollFirst() {
+    popFirst() {
         if (!this._size)
             return;
-        const value = this.peekFirst();
+        const value = this.getFirst();
         delete this._nodes[this._first];
         this._first++;
         this._size--;
         return value;
     }
     /**
-     * The `peekFirst` function returns the first element in an array-like data structure if it exists.
+     * The `getFirst` 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() {
+    getFirst() {
         if (this._size)
             return this._nodes[this._first];
     }
     /**
-     * The `pollLast()` function removes and returns the last element in a data structure.
+     * The `popLast()` function removes and returns the last element in a data structure.
      * @returns The value that was removed from the data structure.
      */
-    pollLast() {
+    popLast() {
         if (!this._size)
             return;
-        const value = this.peekLast();
+        const value = this.getLast();
         delete this._nodes[this._last];
         this._last--;
         this._size--;
         return value;
     }
     /**
-     * The `peekLast()` function returns the last element in an array-like data structure.
+     * The `getLast()` function returns the last element in an array-like data structure.
      * @returns The last element in the array "_nodes" is being returned.
      */
-    peekLast() {
+    getLast() {
         if (this._size)
             return this._nodes[this._last];
     }
@@ -170,18 +170,18 @@ class ArrayDeque {
         return this._nodes.push(value);
     }
     /**
-     * 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.
+     * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty.
+     * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
-    pollLast() {
+    popLast() {
         return this._nodes.pop() ?? 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
+     * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty.
+     * @returns The `popFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
      * empty.
      */
-    pollFirst() {
+    popFirst() {
         return this._nodes.shift() ?? null;
     }
     /**
@@ -197,18 +197,18 @@ class ArrayDeque {
         return this._nodes.unshift(value);
     }
     /**
-     * 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 (`E`) of the `_nodes` array. If the array is
+     * The `getFirst` function returns the first element of an array or null if the array is empty.
+     * @returns The function `getFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
      * empty, it will return `null`.
      */
-    peekFirst() {
+    getFirst() {
         return this._nodes[0] ?? 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.
+     * The `getLast` function returns the last element of an array or null if the array is empty.
+     * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
-    peekLast() {
+    getLast() {
         return this._nodes[this._nodes.length - 1] ?? null;
     }
     /**

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

@@ -68,11 +68,11 @@ export declare class Queue<E = any> {
      */
     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
+     * The `getLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+     * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
      * array is empty, it returns `null`.
      */
-    peekLast(): E | undefined;
+    getLast(): E | undefined;
     /**
      * The enqueue function adds a value to the end of a queue.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.

package/dist/mjs/data-structures/queue/queue.js

@@ -110,11 +110,11 @@ class Queue {
         return this.size > 0 ? this.nodes[this.offset] : 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
+     * The `getLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+     * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
      * array is empty, it returns `null`.
      */
-    peekLast() {
+    getLast() {
         return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
     }
     /**

package/dist/mjs/interfaces/binary-tree.d.ts

@@ -1,7 +1,7 @@
 import { BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodeNested, MapCallback } from '../types';
+import { BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodeNested, OneParamCallback } from '../types';
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
     createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
-    delete<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): BinaryTreeDeletedResult<N>[];
+    delete<C extends OneParamCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeletedResult<N>[];
 }

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

@@ -19,8 +19,6 @@ export declare enum FamilyPosition {
     MAL_NODE = "MAL_NODE"
 }
 export type BinaryTreeNodeKey = number;
-export type BFSCallback<N, D = any> = (node: N, level?: number) => D;
-export type BFSCallbackReturn<N> = ReturnType<BFSCallback<N>>;
 export type BinaryTreeDeletedResult<N> = {
     deleted: N | null | undefined;
     needBalanced: N | null;

package/dist/mjs/types/helpers.d.ts

@@ -1,9 +1,6 @@
-import { BinaryTreeNodeKey } from './data-structures';
 export type Comparator<T> = (a: T, b: T) => number;
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
-export type MapCallback<N, D = any> = (node: N) => D;
-export type DefaultMapCallback<N, D = BinaryTreeNodeKey> = (node: N) => D;
-export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;
+export type OneParamCallback<N, D = any> = (node: N) => D;
 export declare enum CP {
     lt = "lt",
     eq = "eq",