data-structure-typed 1.39.6 → 1.40.0

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

@@ -4,7 +4,7 @@
  * @class
  */
 import { SinglyLinkedList } from '../linked-list';
-export declare class SkipQueue<E = any> extends SinglyLinkedList<E> {
+export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
     /**
      * The enqueue function adds a value to the end of an array.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
@@ -15,6 +15,11 @@ export declare class SkipQueue<E = any> extends SinglyLinkedList<E> {
      * @returns The method is returning the element at the front of the queue, or null if the queue is empty.
      */
     dequeue(): E | undefined;
+    /**
+     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    getFirst(): 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`.
@@ -29,12 +34,10 @@ export declare class Queue<E = any> {
      * initialized as an empty array.
      */
     constructor(elements?: E[]);
-    private _nodes;
+    protected _nodes: E[];
     get nodes(): E[];
-    set nodes(value: E[]);
-    private _offset;
+    protected _offset: number;
     get offset(): number;
-    set offset(value: number);
     /**
      * The size function returns the number of elements in an array.
      * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
@@ -61,6 +64,12 @@ export declare class Queue<E = any> {
      * @returns The function `shift()` returns either the first element in the queue or `null` if the queue is empty.
      */
     shift(): E | undefined;
+    /**
+     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+     * @returns The `getFirst()` 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`.
+     */
+    getFirst(): 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
@@ -73,6 +82,12 @@ export declare class Queue<E = any> {
      * array is empty, it returns `null`.
      */
     getLast(): 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(): 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

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = exports.SkipQueue = void 0;
+exports.Queue = exports.LinkedListQueue = void 0;
 /**
  * @license MIT
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 const linked_list_1 = require("../linked-list");
-class SkipQueue extends linked_list_1.SinglyLinkedList {
+class LinkedListQueue extends linked_list_1.SinglyLinkedList {
     /**
      * The enqueue function adds a value to the end of an array.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
@@ -22,15 +22,22 @@ class SkipQueue extends linked_list_1.SinglyLinkedList {
     dequeue() {
         return this.shift();
     }
+    /**
+     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    getFirst() {
+        return this.head?.value;
+    }
     /**
      * 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() {
-        return this.head?.value;
+        return this.getFirst();
     }
 }
-exports.SkipQueue = SkipQueue;
+exports.LinkedListQueue = LinkedListQueue;
 class Queue {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
@@ -46,16 +53,10 @@ class Queue {
     get nodes() {
         return this._nodes;
     }
-    set nodes(value) {
-        this._nodes = value;
-    }
     _offset;
     get offset() {
         return this._offset;
     }
-    set offset(value) {
-        this._offset = value;
-    }
     /**
      * The size function returns the number of elements in an array.
      * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
@@ -91,23 +92,31 @@ class Queue {
     shift() {
         if (this.size === 0)
             return undefined;
-        const first = this.peek();
-        this.offset += 1;
+        const first = this.getFirst();
+        this._offset += 1;
         if (this.offset * 2 < this.nodes.length)
             return first;
         // only delete dequeued elements when reaching half size
         // to decrease latency of shifting elements.
-        this.nodes = this.nodes.slice(this.offset);
-        this.offset = 0;
+        this._nodes = this.nodes.slice(this.offset);
+        this._offset = 0;
         return first;
     }
+    /**
+     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+     * @returns The `getFirst()` 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`.
+     */
+    getFirst() {
+        return this.size > 0 ? this.nodes[this.offset] : 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() {
-        return this.size > 0 ? this.nodes[this.offset] : undefined;
+        return this.getFirst();
     }
     /**
      * The `getLast` function returns the last element in an array-like data structure, or null if the structure is empty.
@@ -117,6 +126,14 @@ class Queue {
     getLast() {
         return this.size > 0 ? this.nodes[this.nodes.length - 1] : 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() {
+        return this.getLast();
+    }
     /**
      * 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.
@@ -152,8 +169,8 @@ class Queue {
      * The clear function resets the nodes array and offset to their initial values.
      */
     clear() {
-        this.nodes = [];
-        this.offset = 0;
+        this._nodes = [];
+        this._offset = 0;
     }
     /**
      * The `clone()` function returns a new Queue object with the same elements as the original Queue.

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

@@ -4,7 +4,6 @@
  * @class
  */
 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 {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
@@ -12,6 +11,8 @@ export declare class Stack<E = any> {
      * is provided and is an array, it is assigned to the `_elements
      */
     constructor(elements?: E[]);
+    protected _elements: E[];
+    get elements(): E[];
     /**
      * The function "fromArray" creates a new Stack object from an array of elements.
      * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.

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

@@ -7,7 +7,6 @@ exports.Stack = void 0;
  * @class
  */
 class Stack {
-    _elements;
     /**
      * The constructor initializes an array of elements, which can be provided as an optional parameter.
      * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
@@ -17,6 +16,10 @@ class Stack {
     constructor(elements) {
         this._elements = Array.isArray(elements) ? elements : [];
     }
+    _elements;
+    get elements() {
+        return this._elements;
+    }
     /**
      * The function "fromArray" creates a new Stack object from an array of elements.
      * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
@@ -31,14 +34,14 @@ class Stack {
      * @returns A boolean value indicating whether the `_elements` array is empty or not.
      */
     isEmpty() {
-        return this._elements.length === 0;
+        return this.elements.length === 0;
     }
     /**
      * The size() function returns the number of elements in an array.
      * @returns The size of the elements array.
      */
     size() {
-        return this._elements.length;
+        return this.elements.length;
     }
     /**
      * The `peek` function returns the last element of an array, or null if the array is empty.
@@ -47,7 +50,7 @@ class Stack {
     peek() {
         if (this.isEmpty())
             return null;
-        return this._elements[this._elements.length - 1];
+        return this.elements[this.elements.length - 1];
     }
     /**
      * The push function adds an element to the stack and returns the updated stack.
@@ -55,7 +58,7 @@ class Stack {
      * @returns The `push` method is returning the updated `Stack<E>` object.
      */
     push(element) {
-        this._elements.push(element);
+        this.elements.push(element);
         return this;
     }
     /**
@@ -66,14 +69,14 @@ class Stack {
     pop() {
         if (this.isEmpty())
             return null;
-        return this._elements.pop() || null;
+        return this.elements.pop() || null;
     }
     /**
      * The toArray function returns a copy of the elements in an array.
      * @returns An array of type E.
      */
     toArray() {
-        return this._elements.slice();
+        return this.elements.slice();
     }
     /**
      * The clear function clears the elements array.
@@ -86,7 +89,7 @@ class Stack {
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */
     clone() {
-        return new Stack(this._elements.slice());
+        return new Stack(this.elements.slice());
     }
 }
 exports.Stack = Stack;

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

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

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

@@ -2,31 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeNode = void 0;
 class TreeNode {
+    key;
+    value;
+    children;
     constructor(key, value, children) {
-        this._key = key;
-        this._value = value || undefined;
-        this._children = children || [];
-    }
-    _key;
-    get key() {
-        return this._key;
-    }
-    set key(value) {
-        this._key = value;
-    }
-    _value;
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-    }
-    _children;
-    get children() {
-        return this._children;
-    }
-    set children(value) {
-        this._children = value;
+        this.key = key;
+        this.value = value || undefined;
+        this.children = children || [];
     }
     addChildren(children) {
         if (!this.children) {

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

@@ -10,26 +10,20 @@
  * and a flag indicating whether it's the end of a word.
  */
 export declare class TrieNode {
+    key: string;
+    children: Map<string, TrieNode>;
+    isEnd: boolean;
     constructor(key: string);
-    private _key;
-    get key(): string;
-    set key(v: string);
-    protected _children: Map<string, TrieNode>;
-    get children(): Map<string, TrieNode>;
-    set children(v: Map<string, TrieNode>);
-    protected _isEnd: boolean;
-    get isEnd(): boolean;
-    set isEnd(v: boolean);
 }
 /**
  * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
  */
 export declare class Trie {
-    private readonly _caseSensitive;
     constructor(words?: string[], caseSensitive?: boolean);
+    protected _caseSensitive: boolean;
+    get caseSensitive(): boolean;
     protected _root: TrieNode;
     get root(): TrieNode;
-    set root(v: TrieNode);
     /**
      * Add a word to the Trie structure.
      * @param {string} word - The word to add.
@@ -81,5 +75,5 @@ export declare class Trie {
      * @returns {string[]} an array of strings.
      */
     getWords(prefix?: string, max?: number, isAllWhenEmptyPrefix?: boolean): string[];
-    private _caseProcess;
+    protected _caseProcess(str: string): string;
 }

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

@@ -13,31 +13,13 @@ exports.Trie = exports.TrieNode = void 0;
  * and a flag indicating whether it's the end of a word.
  */
 class TrieNode {
+    key;
+    children;
+    isEnd;
     constructor(key) {
-        this._key = key;
-        this._isEnd = false;
-        this._children = new Map();
-    }
-    _key;
-    get key() {
-        return this._key;
-    }
-    set key(v) {
-        this._key = v;
-    }
-    _children;
-    get children() {
-        return this._children;
-    }
-    set children(v) {
-        this._children = v;
-    }
-    _isEnd;
-    get isEnd() {
-        return this._isEnd;
-    }
-    set isEnd(v) {
-        this._isEnd = v;
+        this.key = key;
+        this.isEnd = false;
+        this.children = new Map();
     }
 }
 exports.TrieNode = TrieNode;
@@ -45,7 +27,6 @@ exports.TrieNode = TrieNode;
  * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
  */
 class Trie {
-    _caseSensitive;
     constructor(words, caseSensitive = true) {
         this._root = new TrieNode('');
         this._caseSensitive = caseSensitive;
@@ -55,13 +36,14 @@ class Trie {
             }
         }
     }
+    _caseSensitive;
+    get caseSensitive() {
+        return this._caseSensitive;
+    }
     _root;
     get root() {
         return this._root;
     }
-    set root(v) {
-        this._root = v;
-    }
     /**
      * Add a word to the Trie structure.
      * @param {string} word - The word to add.

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

@@ -1,5 +1,5 @@
 import { BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeletedResult, BTNKey, BinaryTreeNodeNested, BTNCallback } from '../types';
+import { BinaryTreeDeletedResult, BinaryTreeNodeNested, BTNCallback, BTNKey } from '../types';
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
     createNode(key: BTNKey, value?: N['value']): N;
     add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;

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

@@ -1,5 +1,5 @@
 import { BSTNode } from '../../../data-structures';
-import type { BTNKey, BinaryTreeOptions } from './binary-tree';
+import type { BinaryTreeOptions, BTNKey } from './binary-tree';
 export type BSTComparator = (a: BTNKey, b: BTNKey) => number;
 export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTOptions = BinaryTreeOptions & {