directed-graph-typed 1.39.5 → 1.40.0

package/src/data-structures/queue/deque.ts

@@ -9,7 +9,8 @@ import {DoublyLinkedList} from '../linked-list';
 
 // O(n) time complexity of obtaining the value
 // O(1) time complexity of adding at the beginning and the end
-export class Deque<E = any> extends DoublyLinkedList<E> {}
+export class Deque<E = any> extends DoublyLinkedList<E> {
+}
 
 // O(1) time complexity of obtaining the value
 // O(n) time complexity of adding at the beginning and the end
@@ -19,43 +20,31 @@ export class ObjectDeque<E = number> {
     if (capacity !== undefined) this._capacity = capacity;
   }
 
-  private _nodes: {[key: number]: E} = {};
+  protected _nodes: { [key: number]: E } = {};
 
-  get nodes(): {[p: number]: E} {
+  get nodes(): { [p: number]: E } {
     return this._nodes;
   }
 
-  private _capacity = Number.MAX_SAFE_INTEGER;
+  protected _capacity = Number.MAX_SAFE_INTEGER;
 
   get capacity(): number {
     return this._capacity;
   }
 
-  set capacity(value: number) {
-    this._capacity = value;
-  }
-
-  private _first = -1;
+  protected _first = -1;
 
   get first(): number {
     return this._first;
   }
 
-  set first(value: number) {
-    this._first = value;
-  }
-
-  private _last = -1;
+  protected _last = -1;
 
   get last(): number {
     return this._last;
   }
 
-  set last(value: number) {
-    this._last = value;
-  }
-
-  private _size = 0;
+  protected _size = 0;
 
   get size(): number {
     return this._size;
@@ -67,14 +56,14 @@ export class ObjectDeque<E = number> {
    * structure.
    */
   addFirst(value: E) {
-    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++;
   }
 
@@ -83,14 +72,14 @@ export class ObjectDeque<E = number> {
    * @param {E} value - The `value` parameter represents the value that you want to add to the end of the data structure.
    */
   addLast(value: E) {
-    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++;
   }
 
@@ -99,9 +88,9 @@ export class ObjectDeque<E = number> {
    * @returns The value of the first element in the data structure.
    */
   popFirst() {
-    if (!this._size) return;
+    if (!this.size) return;
     const value = this.getFirst();
-    delete this._nodes[this._first];
+    delete this.nodes[this.first];
     this._first++;
     this._size--;
     return value;
@@ -112,7 +101,7 @@ export class ObjectDeque<E = number> {
    * @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];
   }
 
   /**
@@ -120,9 +109,9 @@ export class ObjectDeque<E = number> {
    * @returns The value that was removed from the data structure.
    */
   popLast() {
-    if (!this._size) return;
+    if (!this.size) return;
     const value = this.getLast();
-    delete this._nodes[this._last];
+    delete this.nodes[this.last];
     this._last--;
     this._size--;
 
@@ -134,7 +123,7 @@ export class ObjectDeque<E = number> {
    * @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];
   }
 
   /**
@@ -145,7 +134,7 @@ export class ObjectDeque<E = number> {
    * index, `null` is returned.
    */
   get(index: number) {
-    return this._nodes[this._first + index] || null;
+    return this.nodes[this.first + index] || null;
   }
 
   /**
@@ -153,15 +142,7 @@ export class ObjectDeque<E = number> {
    * @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;
-  }
-
-  protected _seNodes(value: {[p: number]: E}) {
-    this._nodes = value;
-  }
-
-  protected _setSize(value: number) {
-    this._size = value;
+    return this.size <= 0;
   }
 }
 
@@ -170,8 +151,12 @@ export class ObjectDeque<E = number> {
 export class ArrayDeque<E> {
   protected _nodes: E[] = [];
 
+  get nodes(): E[] {
+    return this._nodes;
+  }
+
   get size() {
-    return this._nodes.length;
+    return this.nodes.length;
   }
 
   /**
@@ -184,7 +169,7 @@ export class ArrayDeque<E> {
    * @returns The return value is the new length of the array after the value has been added.
    */
   addLast(value: E) {
-    return this._nodes.push(value);
+    return this.nodes.push(value);
   }
 
   /**
@@ -192,7 +177,7 @@ export class ArrayDeque<E> {
    * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
    */
   popLast(): E | null {
-    return this._nodes.pop() ?? null;
+    return this.nodes.pop() ?? null;
   }
 
   /**
@@ -201,7 +186,7 @@ export class ArrayDeque<E> {
    * empty.
    */
   popFirst(): E | null {
-    return this._nodes.shift() ?? null;
+    return this.nodes.shift() ?? null;
   }
 
   /**
@@ -215,7 +200,7 @@ export class ArrayDeque<E> {
    * `value` at the beginning.
    */
   addFirst(value: E) {
-    return this._nodes.unshift(value);
+    return this.nodes.unshift(value);
   }
 
   /**
@@ -224,7 +209,7 @@ export class ArrayDeque<E> {
    * empty, it will return `null`.
    */
   getFirst(): E | null {
-    return this._nodes[0] ?? null;
+    return this.nodes[0] ?? null;
   }
 
   /**
@@ -232,7 +217,7 @@ export class ArrayDeque<E> {
    * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
    */
   getLast(): E | null {
-    return this._nodes[this._nodes.length - 1] ?? null;
+    return this.nodes[this.nodes.length - 1] ?? null;
   }
 
   /**
@@ -247,7 +232,7 @@ export class ArrayDeque<E> {
    * will be returned. If the element does not exist (i.e., the index is out of bounds), `null` will be returned.
    */
   get(index: number): E | null {
-    return this._nodes[index] ?? null;
+    return this.nodes[index] ?? null;
   }
 
   /**
@@ -259,7 +244,7 @@ export class ArrayDeque<E> {
    * @returns The value that is being set at the specified index in the `_nodes` array.
    */
   set(index: number, value: E) {
-    return (this._nodes[index] = value);
+    return (this.nodes[index] = value);
   }
 
   /**
@@ -273,7 +258,7 @@ export class ArrayDeque<E> {
    * are being removed, an empty array will be returned.
    */
   insert(index: number, value: E) {
-    return this._nodes.splice(index, 0, value);
+    return this.nodes.splice(index, 0, value);
   }
 
   /**
@@ -283,7 +268,7 @@ export class ArrayDeque<E> {
    * @returns The method is returning an array containing the removed element.
    */
   delete(index: number) {
-    return this._nodes.splice(index, 1);
+    return this.nodes.splice(index, 1);
   }
 
   /**
@@ -292,6 +277,6 @@ export class ArrayDeque<E> {
    * is 0, indicating that the array is empty. Otherwise, it returns `false`.
    */
   isEmpty() {
-    return this._nodes.length === 0;
+    return this.nodes.length === 0;
   }
 }

package/src/data-structures/queue/queue.ts

@@ -5,7 +5,7 @@
  */
 import {SinglyLinkedList} from '../linked-list';
 
-export class SkipQueue<E = any> extends SinglyLinkedList<E> {
+export 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.
@@ -22,12 +22,20 @@ export class SkipQueue<E = any> extends SinglyLinkedList<E> {
     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(): E | undefined {
+    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(): E | undefined {
-    return this.head?.val;
+    return this.getFirst();
   }
 }
 
@@ -43,26 +51,18 @@ export class Queue<E = any> {
     this._offset = 0;
   }
 
-  private _nodes: E[];
+  protected _nodes: E[];
 
   get nodes(): E[] {
     return this._nodes;
   }
 
-  set nodes(value: E[]) {
-    this._nodes = value;
-  }
-
-  private _offset: number;
+  protected _offset: number;
 
   get offset(): number {
     return this._offset;
   }
 
-  set offset(value: number) {
-    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.
@@ -101,25 +101,34 @@ export class Queue<E = any> {
   shift(): E | undefined {
     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(): E | undefined {
+    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(): E | undefined {
-    return this.size > 0 ? this.nodes[this.offset] : undefined;
+    return this.getFirst();
   }
 
   /**
@@ -131,6 +140,15 @@ export class Queue<E = any> {
     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(): E | undefined {
+    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.
@@ -171,8 +189,8 @@ export class Queue<E = any> {
    * The clear function resets the nodes array and offset to their initial values.
    */
   clear(): void {
-    this.nodes = [];
-    this.offset = 0;
+    this._nodes = [];
+    this._offset = 0;
   }
 
   /**
@@ -183,7 +201,7 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     for (const item of this.nodes) {
       yield item;
     }

package/src/data-structures/stack/stack.ts

@@ -4,8 +4,6 @@
  * @class
  */
 export 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
@@ -16,6 +14,12 @@ export class Stack<E = any> {
     this._elements = Array.isArray(elements) ? elements : [];
   }
 
+  protected _elements: E[];
+
+  get elements(): E[] {
+    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,7 +35,7 @@ export class Stack<E = any> {
    * @returns A boolean value indicating whether the `_elements` array is empty or not.
    */
   isEmpty(): boolean {
-    return this._elements.length === 0;
+    return this.elements.length === 0;
   }
 
   /**
@@ -39,7 +43,7 @@ export class Stack<E = any> {
    * @returns The size of the elements array.
    */
   size(): number {
-    return this._elements.length;
+    return this.elements.length;
   }
 
   /**
@@ -49,7 +53,7 @@ export class Stack<E = any> {
   peek(): E | null {
     if (this.isEmpty()) return null;
 
-    return this._elements[this._elements.length - 1];
+    return this.elements[this.elements.length - 1];
   }
 
   /**
@@ -58,7 +62,7 @@ export class Stack<E = any> {
    * @returns The `push` method is returning the updated `Stack<E>` object.
    */
   push(element: E): Stack<E> {
-    this._elements.push(element);
+    this.elements.push(element);
     return this;
   }
 
@@ -70,7 +74,7 @@ export class Stack<E = any> {
   pop(): E | null {
     if (this.isEmpty()) return null;
 
-    return this._elements.pop() || null;
+    return this.elements.pop() || null;
   }
 
   /**
@@ -78,7 +82,7 @@ export class Stack<E = any> {
    * @returns An array of type E.
    */
   toArray(): E[] {
-    return this._elements.slice();
+    return this.elements.slice();
   }
 
   /**
@@ -93,6 +97,6 @@ export class Stack<E = any> {
    * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
    */
   clone(): Stack<E> {
-    return new Stack(this._elements.slice());
+    return new Stack(this.elements.slice());
   }
 }

package/src/data-structures/tree/tree.ts

@@ -1,38 +1,12 @@
 export class TreeNode<V = any> {
-  constructor(key: string, value?: V, children?: TreeNode<V>[]) {
-    this._key = key;
-    this._value = value || undefined;
-    this._children = children || [];
-  }
-
-  private _key: string;
-
-  get key(): string {
-    return this._key;
-  }
-
-  set key(value: string) {
-    this._key = value;
-  }
-
-  private _value?: V | undefined;
+  key: string;
+  value?: V | undefined;
+  children?: TreeNode<V>[] | undefined;
 
-  get value(): V | undefined {
-    return this._value;
-  }
-
-  set value(value: V | undefined) {
-    this._value = value;
-  }
-
-  private _children?: TreeNode<V>[] | undefined;
-
-  get children(): TreeNode<V>[] | undefined {
-    return this._children;
-  }
-
-  set children(value: TreeNode<V>[] | undefined) {
-    this._children = value;
+  constructor(key: string, value?: V, children?: TreeNode<V>[]) {
+    this.key = key;
+    this.value = value || undefined;
+    this.children = children || [];
   }
 
   addChildren(children: TreeNode<V> | TreeNode<V>[]) {

package/src/data-structures/trie/trie.ts

@@ -11,40 +11,14 @@
  * and a flag indicating whether it's the end of a word.
  */
 export class TrieNode {
-  constructor(key: string) {
-    this._key = key;
-    this._isEnd = false;
-    this._children = new Map<string, TrieNode>();
-  }
-
-  private _key;
-
-  get key(): string {
-    return this._key;
-  }
-
-  set key(v: string) {
-    this._key = v;
-  }
-
-  protected _children: Map<string, TrieNode>;
-
-  get children(): Map<string, TrieNode> {
-    return this._children;
-  }
-
-  set children(v: Map<string, TrieNode>) {
-    this._children = v;
-  }
-
-  protected _isEnd: boolean;
-
-  get isEnd(): boolean {
-    return this._isEnd;
-  }
+  key: string;
+  children: Map<string, TrieNode>;
+  isEnd: boolean;
 
-  set isEnd(v: boolean) {
-    this._isEnd = v;
+  constructor(key: string) {
+    this.key = key;
+    this.isEnd = false;
+    this.children = new Map<string, TrieNode>();
   }
 }
 
@@ -52,8 +26,6 @@ export class TrieNode {
  * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
  */
 export class Trie {
-  private readonly _caseSensitive: boolean;
-
   constructor(words?: string[], caseSensitive = true) {
     this._root = new TrieNode('');
     this._caseSensitive = caseSensitive;
@@ -64,16 +36,18 @@ export class Trie {
     }
   }
 
+  protected _caseSensitive: boolean;
+
+  get caseSensitive(): boolean {
+    return this._caseSensitive;
+  }
+
   protected _root: TrieNode;
 
   get root() {
     return this._root;
   }
 
-  set root(v: TrieNode) {
-    this._root = v;
-  }
-
   /**
    * Add a word to the Trie structure.
    * @param {string} word - The word to add.
@@ -277,7 +251,7 @@ export class Trie {
     return words;
   }
 
-  private _caseProcess(str: string) {
+  protected _caseProcess(str: string) {
     if (!this._caseSensitive) {
       str = str.toLowerCase(); // Convert str to lowercase if case-insensitive
     }

package/src/interfaces/binary-tree.ts

@@ -1,10 +1,10 @@
 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, val?: N['val']): N;
+  createNode(key: BTNKey, value?: N['value']): N;
 
-  add(keyOrNode: BTNKey | N | null, val?: N['val']): N | null | undefined;
+  add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;
 
   delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeletedResult<N>[];
 }

package/src/interfaces/graph.ts

@@ -1,7 +1,7 @@
 import {VertexKey} from '../types';
 
 export interface IGraph<V, E, VO, EO> {
-  createVertex(key: VertexKey, val?: V): VO;
+  createVertex(key: VertexKey, value?: V): VO;
 
-  createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): EO;
+  createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO;
 }

package/src/types/data-structures/binary-tree/bst.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;
 

package/src/types/data-structures/matrix/navigator.ts

@@ -1,6 +1,6 @@
 export type Direction = 'up' | 'right' | 'down' | 'left';
 
-export type Turning = {[key in Direction]: Direction};
+export type Turning = { [key in Direction]: Direction };
 
 export type NavigatorParams<T = any> = {
   matrix: T[][];

package/src/types/utils/utils.ts

@@ -1,5 +1,5 @@
 export type ToThunkFn = () => ReturnType<TrlFn>;
-export type Thunk = () => ReturnType<ToThunkFn> & {__THUNK__: symbol};
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: symbol };
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 

package/src/types/utils/validate-type.ts

@@ -1,6 +1,6 @@
-export type KeyValueObject = {[key: string]: any};
+export type KeyValueObject = { [key: string]: any };
 
-export type KeyValueObjectWithKey = {[key: string]: any; key: string | number | symbol};
+export type KeyValueObjectWithKey = { [key: string]: any; key: string | number | symbol };
 
 export type NonNumberNonObjectButDefined = string | boolean | symbol | null;