min-heap-typed 1.39.6 → 1.40.0

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

@@ -33,21 +33,12 @@ class ObjectDeque {
     get capacity() {
         return this._capacity;
     }
-    set capacity(value) {
-        this._capacity = value;
-    }
     get first() {
         return this._first;
     }
-    set first(value) {
-        this._first = value;
-    }
     get last() {
         return this._last;
     }
-    set last(value) {
-        this._last = value;
-    }
     get size() {
         return this._size;
     }
@@ -57,15 +48,15 @@ class ObjectDeque {
      * structure.
      */
     addFirst(value) {
-        if (this._size === 0) {
-            const mid = Math.floor(this._capacity / 2);
+        if (this.size === 0) {
+            const mid = Math.floor(this.capacity / 2);
             this._first = mid;
             this._last = mid;
         }
         else {
             this._first--;
         }
-        this._nodes[this._first] = value;
+        this.nodes[this.first] = value;
         this._size++;
     }
     /**
@@ -73,15 +64,15 @@ class ObjectDeque {
      * @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) {
-            const mid = Math.floor(this._capacity / 2);
+        if (this.size === 0) {
+            const mid = Math.floor(this.capacity / 2);
             this._first = mid;
             this._last = mid;
         }
         else {
             this._last++;
         }
-        this._nodes[this._last] = value;
+        this.nodes[this.last] = value;
         this._size++;
     }
     /**
@@ -89,10 +80,10 @@ class ObjectDeque {
      * @returns The value of the first element in the data structure.
      */
     popFirst() {
-        if (!this._size)
+        if (!this.size)
             return;
         const value = this.getFirst();
-        delete this._nodes[this._first];
+        delete this.nodes[this.first];
         this._first++;
         this._size--;
         return value;
@@ -102,18 +93,18 @@ class ObjectDeque {
      * @returns The element at the first position of the `_nodes` array.
      */
     getFirst() {
-        if (this._size)
-            return this._nodes[this._first];
+        if (this.size)
+            return this.nodes[this.first];
     }
     /**
      * The `popLast()` function removes and returns the last element in a data structure.
      * @returns The value that was removed from the data structure.
      */
     popLast() {
-        if (!this._size)
+        if (!this.size)
             return;
         const value = this.getLast();
-        delete this._nodes[this._last];
+        delete this.nodes[this.last];
         this._last--;
         this._size--;
         return value;
@@ -123,8 +114,8 @@ class ObjectDeque {
      * @returns The last element in the array "_nodes" is being returned.
      */
     getLast() {
-        if (this._size)
-            return this._nodes[this._last];
+        if (this.size)
+            return this.nodes[this.last];
     }
     /**
      * The get function returns the element at the specified index in an array-like data structure.
@@ -134,20 +125,14 @@ class ObjectDeque {
      * index, `null` is returned.
      */
     get(index) {
-        return this._nodes[this._first + index] || null;
+        return this.nodes[this.first + index] || 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() {
-        return this._size <= 0;
-    }
-    _seNodes(value) {
-        this._nodes = value;
-    }
-    _setSize(value) {
-        this._size = value;
+        return this.size <= 0;
     }
 }
 exports.ObjectDeque = ObjectDeque;
@@ -157,8 +142,11 @@ class ArrayDeque {
     constructor() {
         this._nodes = [];
     }
+    get nodes() {
+        return this._nodes;
+    }
     get size() {
-        return this._nodes.length;
+        return this.nodes.length;
     }
     /**
      * O(n) time complexity of adding at the beginning and the end
@@ -169,7 +157,7 @@ class ArrayDeque {
      * @returns The return value is the new length of the array after the value has been added.
      */
     addLast(value) {
-        return this._nodes.push(value);
+        return this.nodes.push(value);
     }
     /**
      * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty.
@@ -177,7 +165,7 @@ class ArrayDeque {
      */
     popLast() {
         var _a;
-        return (_a = this._nodes.pop()) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.nodes.pop()) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty.
@@ -186,7 +174,7 @@ class ArrayDeque {
      */
     popFirst() {
         var _a;
-        return (_a = this._nodes.shift()) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.nodes.shift()) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * O(n) time complexity of adding at the beginning and the end
@@ -198,7 +186,7 @@ class ArrayDeque {
      * `value` at the beginning.
      */
     addFirst(value) {
-        return this._nodes.unshift(value);
+        return this.nodes.unshift(value);
     }
     /**
      * The `getFirst` function returns the first element of an array or null if the array is empty.
@@ -207,7 +195,7 @@ class ArrayDeque {
      */
     getFirst() {
         var _a;
-        return (_a = this._nodes[0]) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.nodes[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * The `getLast` function returns the last element of an array or null if the array is empty.
@@ -215,7 +203,7 @@ class ArrayDeque {
      */
     getLast() {
         var _a;
-        return (_a = this._nodes[this._nodes.length - 1]) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.nodes[this.nodes.length - 1]) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * O(1) time complexity of obtaining the value
@@ -229,7 +217,7 @@ class ArrayDeque {
      */
     get(index) {
         var _a;
-        return (_a = this._nodes[index]) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.nodes[index]) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * The set function assigns a value to a specific index in an array.
@@ -240,7 +228,7 @@ class ArrayDeque {
      * @returns The value that is being set at the specified index in the `_nodes` array.
      */
     set(index, value) {
-        return (this._nodes[index] = value);
+        return (this.nodes[index] = value);
     }
     /**
      * The insert function adds a value at a specified index in an array.
@@ -253,7 +241,7 @@ class ArrayDeque {
      * are being removed, an empty array will be returned.
      */
     insert(index, value) {
-        return this._nodes.splice(index, 0, value);
+        return this.nodes.splice(index, 0, value);
     }
     /**
      * The delete function removes an element from an array at a specified index.
@@ -262,7 +250,7 @@ class ArrayDeque {
      * @returns The method is returning an array containing the removed element.
      */
     delete(index) {
-        return this._nodes.splice(index, 1);
+        return this.nodes.splice(index, 1);
     }
     /**
      * The function checks if an array called "_nodes" is empty.
@@ -270,7 +258,7 @@ class ArrayDeque {
      * is 0, indicating that the array is empty. Otherwise, it returns `false`.
      */
     isEmpty() {
-        return this._nodes.length === 0;
+        return this.nodes.length === 0;
     }
 }
 exports.ArrayDeque = ArrayDeque;

package/dist/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/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,16 +22,23 @@ 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() {
+        var _a;
+        return (_a = this.head) === null || _a === void 0 ? void 0 : _a.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() {
-        var _a;
-        return (_a = this.head) === null || _a === void 0 ? void 0 : _a.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,15 +53,9 @@ class Queue {
     get nodes() {
         return this._nodes;
     }
-    set nodes(value) {
-        this._nodes = value;
-    }
     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.
@@ -90,23 +91,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.
@@ -116,6 +125,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.
@@ -151,8 +168,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/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/data-structures/stack/stack.js

@@ -16,6 +16,9 @@ class Stack {
     constructor(elements) {
         this._elements = Array.isArray(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`.
@@ -30,14 +33,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.
@@ -46,7 +49,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.
@@ -54,7 +57,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;
     }
     /**
@@ -65,14 +68,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.
@@ -85,7 +88,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/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/data-structures/tree/tree.js

@@ -3,27 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeNode = void 0;
 class TreeNode {
     constructor(key, value, children) {
-        this._key = key;
-        this._value = value || undefined;
-        this._children = children || [];
-    }
-    get key() {
-        return this._key;
-    }
-    set key(value) {
-        this._key = value;
-    }
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-    }
-    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/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/data-structures/trie/trie.js

@@ -14,27 +14,9 @@ exports.Trie = exports.TrieNode = void 0;
  */
 class TrieNode {
     constructor(key) {
-        this._key = key;
-        this._isEnd = false;
-        this._children = new Map();
-    }
-    get key() {
-        return this._key;
-    }
-    set key(v) {
-        this._key = v;
-    }
-    get children() {
-        return this._children;
-    }
-    set children(v) {
-        this._children = v;
-    }
-    get isEnd() {
-        return this._isEnd;
-    }
-    set isEnd(v) {
-        this._isEnd = v;
+        this.key = key;
+        this.isEnd = false;
+        this.children = new Map();
     }
 }
 exports.TrieNode = TrieNode;
@@ -51,12 +33,12 @@ class Trie {
             }
         }
     }
+    get caseSensitive() {
+        return this._caseSensitive;
+    }
     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/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/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 & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.39.6",
+  "version": "1.40.0",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -131,6 +131,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.39.6"
+    "data-structure-typed": "^1.40.0"
   }
 }