graph-typed 1.39.5 → 1.40.0

package/dist/data-structures/linked-list/skip-linked-list.js

@@ -33,27 +33,15 @@ class SkipList {
     get head() {
         return this._head;
     }
-    set head(value) {
-        this._head = value;
-    }
     get level() {
         return this._level;
     }
-    set level(value) {
-        this._level = value;
-    }
     get maxLevel() {
         return this._maxLevel;
     }
-    set maxLevel(value) {
-        this._maxLevel = value;
-    }
     get probability() {
         return this._probability;
     }
-    set probability(value) {
-        this._probability = value;
-    }
     /**
      * The add function adds a new node with a given key and value to a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be added to the skip list.
@@ -61,7 +49,7 @@ class SkipList {
      * List.
      */
     add(key, value) {
-        const newNode = new SkipListNode(key, value, this.randomLevel());
+        const newNode = new SkipListNode(key, value, this._randomLevel());
         const update = new Array(this.maxLevel).fill(this.head);
         let current = this.head;
         for (let i = this.level - 1; i >= 0; i--) {
@@ -75,7 +63,7 @@ class SkipList {
             update[i].forward[i] = newNode;
         }
         if (newNode.forward[0] !== null) {
-            this.level = Math.max(this.level, newNode.forward.length);
+            this._level = Math.max(this.level, newNode.forward.length);
         }
     }
     /**
@@ -97,6 +85,9 @@ class SkipList {
         }
         return undefined;
     }
+    has(key) {
+        return this.get(key) !== undefined;
+    }
     /**
      * The `delete` function removes a node with a specific key from a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
@@ -121,17 +112,71 @@ class SkipList {
                 update[i].forward[i] = current.forward[i];
             }
             while (this.level > 0 && this.head.forward[this.level - 1] === null) {
-                this.level--;
+                this._level--;
             }
             return true;
         }
         return false;
     }
     /**
-     * The function "randomLevel" generates a random level based on a given probability and maximum level.
+     * Get the value of the first element (the smallest element) in the Skip List.
+     * @returns The value of the first element, or undefined if the Skip List is empty.
+     */
+    getFirst() {
+        const firstNode = this.head.forward[0];
+        return firstNode ? firstNode.value : undefined;
+    }
+    /**
+     * Get the value of the last element (the largest element) in the Skip List.
+     * @returns The value of the last element, or undefined if the Skip List is empty.
+     */
+    getLast() {
+        let current = this.head;
+        for (let i = this.level - 1; i >= 0; i--) {
+            while (current.forward[i]) {
+                current = current.forward[i];
+            }
+        }
+        return current.value;
+    }
+    /**
+     * Get the value of the first element in the Skip List that is greater than the given key.
+     * @param key - the given key.
+     * @returns The value of the first element greater than the given key, or undefined if there is no such element.
+     */
+    higher(key) {
+        let current = this.head;
+        for (let i = this.level - 1; i >= 0; i--) {
+            while (current.forward[i] && current.forward[i].key <= key) {
+                current = current.forward[i];
+            }
+        }
+        const nextNode = current.forward[0];
+        return nextNode ? nextNode.value : undefined;
+    }
+    /**
+     * Get the value of the last element in the Skip List that is less than the given key.
+     * @param key - the given key.
+     * @returns The value of the last element less than the given key, or undefined if there is no such element.
+     */
+    lower(key) {
+        let current = this.head;
+        let lastLess = null;
+        for (let i = this.level - 1; i >= 0; i--) {
+            while (current.forward[i] && current.forward[i].key < key) {
+                current = current.forward[i];
+            }
+            if (current.key < key) {
+                lastLess = current;
+            }
+        }
+        return lastLess ? lastLess.value : undefined;
+    }
+    /**
+     * The function "_randomLevel" generates a random level based on a given probability and maximum level.
      * @returns the level, which is a number.
      */
-    randomLevel() {
+    _randomLevel() {
         let level = 1;
         while (Math.random() < this.probability && level < this.maxLevel) {
             level++;

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 export declare class MatrixNTI2D<V = any> {
-    private readonly _matrix;
+    protected readonly _matrix: Array<Array<V>>;
     /**
      * The constructor creates a matrix with the specified number of rows and columns, and initializes all elements to a
      * given initial value or 0 if not provided.

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

@@ -7,7 +7,7 @@
  */
 import { Vector2D } from './vector2d';
 export declare class Matrix2D {
-    private readonly _matrix;
+    protected readonly _matrix: number[][];
     /**
      * The constructor function initializes a Matrix2D object with either a default identity matrix, or a provided matrix
      * or Vector2D object.

package/dist/data-structures/matrix/navigator.d.ts

@@ -21,10 +21,10 @@ export declare class Character {
 }
 export declare class Navigator<T = number> {
     onMove: (cur: [number, number]) => void;
-    private readonly _matrix;
-    private readonly _cur;
-    private _character;
-    private readonly _VISITED;
+    protected readonly _matrix: T[][];
+    protected readonly _cur: [number, number];
+    protected _character: Character;
+    protected readonly _VISITED: T;
     /**
      * The constructor initializes the Navigator object with the given parameters and sets the current position as visited
      * in the matrix.

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

@@ -10,20 +10,19 @@ export declare class Deque<E = any> extends DoublyLinkedList<E> {
 }
 export declare class ObjectDeque<E = number> {
     constructor(capacity?: number);
-    private _nodes;
+    protected _nodes: {
+        [key: number]: E;
+    };
     get nodes(): {
         [p: number]: E;
     };
-    private _capacity;
+    protected _capacity: number;
     get capacity(): number;
-    set capacity(value: number);
-    private _first;
+    protected _first: number;
     get first(): number;
-    set first(value: number);
-    private _last;
+    protected _last: number;
     get last(): number;
-    set last(value: number);
-    private _size;
+    protected _size: number;
     get size(): number;
     /**
      * The "addFirst" function adds a value to the beginning of an array-like data structure.
@@ -69,13 +68,10 @@ export declare 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(): boolean;
-    protected _seNodes(value: {
-        [p: number]: E;
-    }): void;
-    protected _setSize(value: number): void;
 }
 export declare class ArrayDeque<E> {
     protected _nodes: E[];
+    get nodes(): E[];
     get size(): number;
     /**
      * O(n) time complexity of adding at the beginning and the end

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.val;
+        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`.