graph-typed 1.39.5 → 1.40.0

package/dist/data-structures/graph/undirected-graph.js

@@ -15,11 +15,11 @@ class UndirectedVertex extends abstract_graph_1.AbstractVertex {
      * The constructor function initializes a vertex with an optional value.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex within a graph or network.
-     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It is used to initialize the value of the
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
-    constructor(key, val) {
-        super(key, val);
+    constructor(key, value) {
+        super(key, value);
     }
 }
 exports.UndirectedVertex = UndirectedVertex;
@@ -31,18 +31,12 @@ class UndirectedEdge extends abstract_graph_1.AbstractEdge {
      * @param {VertexKey} v2 - The parameter `v2` is a `VertexKey`, which represents the identifier of the second vertex in a
      * graph edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {E} [val] - The "val" parameter is an optional parameter of type E. It is used to store a value associated
+     * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store a value associated
      * with the edge.
      */
-    constructor(v1, v2, weight, val) {
-        super(weight, val);
-        this._vertices = [v1, v2];
-    }
-    get vertices() {
-        return this._vertices;
-    }
-    set vertices(v) {
-        this._vertices = v;
+    constructor(v1, v2, weight, value) {
+        super(weight, value);
+        this.vertices = [v1, v2];
     }
 }
 exports.UndirectedEdge = UndirectedEdge;
@@ -61,13 +55,13 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * The function creates a new vertex with an optional value and returns it.
      * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is used to distinguish one
      * vertex from another in the graph.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the vertex. If a value is provided,
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the vertex. If a value is provided,
      * it will be used as the value of the vertex. If no value is provided, the `key` parameter will be used as the value of
      * the vertex.
      * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `VO`.
      */
-    createVertex(key, val) {
-        return new UndirectedVertex(key, val !== null && val !== void 0 ? val : key);
+    createVertex(key, value) {
+        return new UndirectedVertex(key, value !== null && value !== void 0 ? value : key);
     }
     /**
      * The function creates an undirected edge between two vertices with an optional weight and value.
@@ -75,18 +69,18 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * @param {VertexKey} v2 - The parameter `v2` represents the second vertex of the edge.
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
      * no weight is provided, it defaults to 1.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type and
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type and
      * is used to store additional information or data associated with the edge.
      * @returns a new instance of the `UndirectedEdge` class, which is casted as type `EO`.
      */
-    createEdge(v1, v2, weight, val) {
-        return new UndirectedEdge(v1, v2, weight !== null && weight !== void 0 ? weight : 1, val);
+    createEdge(v1, v2, weight, value) {
+        return new UndirectedEdge(v1, v2, weight !== null && weight !== void 0 ? weight : 1, value);
     }
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
-     * @param {VO | null | VertexKey} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
+     * @param {VO | VertexKey | null} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
-     * @param {VO | null | VertexKey} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
+     * @param {VO | VertexKey | null} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `null`, or `VertexKey` (vertex ID).
      * @returns an edge (EO) or null.
      */
@@ -241,12 +235,5 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
         }
         return true;
     }
-    /**
-     * The function sets the edges of a graph.
-     * @param v - A map where the keys are of type VO and the values are arrays of type EO.
-     */
-    _setEdges(v) {
-        this._edges = v;
-    }
 }
 exports.UndirectedGraph = UndirectedGraph;

package/dist/data-structures/hash/coordinate-map.d.ts

@@ -41,5 +41,4 @@ export declare class CoordinateMap<V> extends Map<any, V> {
      * `key` array joined together using the `_joint` property.
      */
     delete(key: number[]): boolean;
-    protected _setJoint(v: string): void;
 }

package/dist/data-structures/hash/coordinate-map.js

@@ -58,8 +58,5 @@ class CoordinateMap extends Map {
     delete(key) {
         return super.delete(key.join(this._joint));
     }
-    _setJoint(v) {
-        this._joint = v;
-    }
 }
 exports.CoordinateMap = CoordinateMap;

package/dist/data-structures/hash/coordinate-set.d.ts

@@ -33,5 +33,4 @@ export declare class CoordinateSet extends Set<any> {
      * `value` array joined together using the `_joint` property.
      */
     delete(value: number[]): boolean;
-    protected _setJoint(v: string): void;
 }

package/dist/data-structures/hash/coordinate-set.js

@@ -48,8 +48,5 @@ class CoordinateSet extends Set {
     delete(value) {
         return super.delete(value.join(this._joint));
     }
-    _setJoint(v) {
-        this._joint = v;
-    }
 }
 exports.CoordinateSet = CoordinateSet;

package/dist/data-structures/hash/hash-map.d.ts

@@ -20,24 +20,18 @@ export declare class HashMap<K, V> {
      * default hash function converts the key to a string, calculates the sum of the
      */
     constructor(initialCapacity?: number, loadFactor?: number, hashFn?: HashFunction<K>);
-    private _initialCapacity;
+    protected _initialCapacity: number;
     get initialCapacity(): number;
-    set initialCapacity(value: number);
-    private _loadFactor;
+    protected _loadFactor: number;
     get loadFactor(): number;
-    set loadFactor(value: number);
-    private _capacityMultiplier;
+    protected _capacityMultiplier: number;
     get capacityMultiplier(): number;
-    set capacityMultiplier(value: number);
-    private _size;
+    protected _size: number;
     get size(): number;
-    set size(value: number);
-    private _table;
+    protected _table: Array<Array<[K, V]>>;
     get table(): Array<Array<[K, V]>>;
-    set table(value: Array<Array<[K, V]>>);
-    private _hashFn;
+    protected _hashFn: HashFunction<K>;
     get hashFn(): HashFunction<K>;
-    set hashFn(value: HashFunction<K>);
     set(key: K, value: V): void;
     get(key: K): V | undefined;
     delete(key: K): void;
@@ -45,12 +39,12 @@ export declare class HashMap<K, V> {
     [Symbol.iterator](): IterableIterator<[K, V]>;
     clear(): void;
     isEmpty(): boolean;
-    private _hash;
+    protected _hash(key: K): number;
     /**
      * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
      * rehashing the key-value pairs from the old table into the new table.
      * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
      * the number of buckets that the new table should have.
      */
-    private resizeTable;
+    protected resizeTable(newCapacity: number): void;
 }

package/dist/data-structures/hash/hash-map.js

@@ -41,39 +41,21 @@ class HashMap {
     get initialCapacity() {
         return this._initialCapacity;
     }
-    set initialCapacity(value) {
-        this._initialCapacity = value;
-    }
     get loadFactor() {
         return this._loadFactor;
     }
-    set loadFactor(value) {
-        this._loadFactor = value;
-    }
     get capacityMultiplier() {
         return this._capacityMultiplier;
     }
-    set capacityMultiplier(value) {
-        this._capacityMultiplier = value;
-    }
     get size() {
         return this._size;
     }
-    set size(value) {
-        this._size = value;
-    }
     get table() {
         return this._table;
     }
-    set table(value) {
-        this._table = value;
-    }
     get hashFn() {
         return this._hashFn;
     }
-    set hashFn(value) {
-        this._hashFn = value;
-    }
     set(key, value) {
         const loadFactor = this.size / this.table.length;
         if (loadFactor >= this.loadFactor) {
@@ -91,7 +73,7 @@ class HashMap {
             }
         }
         this.table[index].push([key, value]);
-        this.size++;
+        this._size++;
     }
     get(key) {
         const index = this._hash(key);
@@ -113,7 +95,7 @@ class HashMap {
         for (let i = 0; i < this.table[index].length; i++) {
             if (this.table[index][i][0] === key) {
                 this.table[index].splice(i, 1);
-                this.size--;
+                this._size--;
                 // Check if the table needs to be resized down
                 const loadFactor = this.size / this.table.length;
                 if (loadFactor < this.loadFactor / this.capacityMultiplier) {
@@ -136,8 +118,8 @@ class HashMap {
         return this.entries();
     }
     clear() {
-        this.size = 0;
-        this.table = new Array(this.initialCapacity);
+        this._size = 0;
+        this._table = new Array(this.initialCapacity);
     }
     isEmpty() {
         return this.size === 0;

package/dist/data-structures/hash/hash-table.d.ts

@@ -7,36 +7,33 @@
  */
 export declare class HashTableNode<K, V> {
     key: K;
-    val: V;
+    value: V;
     next: HashTableNode<K, V> | null;
-    constructor(key: K, val: V);
+    constructor(key: K, value: V);
 }
 import { HashFunction } from '../../types';
 export declare class HashTable<K, V> {
-    private static readonly DEFAULT_CAPACITY;
-    private static readonly LOAD_FACTOR;
+    protected static readonly DEFAULT_CAPACITY = 16;
+    protected static readonly LOAD_FACTOR = 0.75;
     constructor(capacity?: number, hashFn?: HashFunction<K>);
-    private _capacity;
+    protected _capacity: number;
     get capacity(): number;
-    set capacity(value: number);
-    private _size;
+    protected _size: number;
     get size(): number;
-    private _buckets;
+    protected _buckets: Array<HashTableNode<K, V> | null>;
     get buckets(): Array<HashTableNode<K, V> | null>;
-    set buckets(value: Array<HashTableNode<K, V> | null>);
-    private _hashFn;
+    protected _hashFn: HashFunction<K>;
     get hashFn(): HashFunction<K>;
-    set hashFn(value: HashFunction<K>);
     /**
      * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
      * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
      * table. It is of type K, which is a generic type representing the key's data type.
-     * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
+     * @param {V} value - The parameter `value` represents the value that you want to associate with the given key in the hash
      * table.
      * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
      * value.
      */
-    set(key: K, val: V): void;
+    set(key: K, value: V): void;
     /**
      * The `get` function retrieves the value associated with a given key from a hash table.
      * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data

package/dist/data-structures/hash/hash-table.js

@@ -9,9 +9,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HashTable = exports.HashTableNode = void 0;
 class HashTableNode {
-    constructor(key, val) {
+    constructor(key, value) {
         this.key = key;
-        this.val = val;
+        this.value = value;
         this.next = null;
     }
 }
@@ -26,36 +26,27 @@ class HashTable {
     get capacity() {
         return this._capacity;
     }
-    set capacity(value) {
-        this._capacity = value;
-    }
     get size() {
         return this._size;
     }
     get buckets() {
         return this._buckets;
     }
-    set buckets(value) {
-        this._buckets = value;
-    }
     get hashFn() {
         return this._hashFn;
     }
-    set hashFn(value) {
-        this._hashFn = value;
-    }
     /**
      * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
      * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
      * table. It is of type K, which is a generic type representing the key's data type.
-     * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
+     * @param {V} value - The parameter `value` represents the value that you want to associate with the given key in the hash
      * table.
      * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
      * value.
      */
-    set(key, val) {
+    set(key, value) {
         const index = this._hash(key);
-        const newNode = new HashTableNode(key, val);
+        const newNode = new HashTableNode(key, value);
         if (!this._buckets[index]) {
             this._buckets[index] = newNode;
         }
@@ -65,7 +56,7 @@ class HashTable {
             while (currentNode) {
                 if (currentNode.key === key) {
                     // If the key already exists, update the value
-                    currentNode.val = val;
+                    currentNode.value = value;
                     return;
                 }
                 if (!currentNode.next) {
@@ -94,7 +85,7 @@ class HashTable {
         let currentNode = this._buckets[index];
         while (currentNode) {
             if (currentNode.key === key) {
-                return currentNode.val;
+                return currentNode.value;
             }
             currentNode = currentNode.next;
         }
@@ -222,7 +213,7 @@ class HashTable {
             let currentNode = bucket;
             while (currentNode) {
                 const newIndex = this._hash(currentNode.key);
-                const newNode = new HashTableNode(currentNode.key, currentNode.val);
+                const newNode = new HashTableNode(currentNode.key, currentNode.value);
                 if (!newBuckets[newIndex]) {
                     newBuckets[newIndex] = newNode;
                 }

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

@@ -6,12 +6,14 @@
  */
 import type { Comparator, DFSOrderPattern } from '../../types';
 export declare class Heap<E = any> {
-    protected nodes: E[];
-    protected readonly comparator: Comparator<E>;
     constructor(options: {
         comparator: Comparator<E>;
         nodes?: E[];
     });
+    protected _nodes: E[];
+    get nodes(): E[];
+    protected _comparator: Comparator<E>;
+    get comparator(): Comparator<E>;
     /**
      * Get the size (number of elements) of the heap.
      */
@@ -123,11 +125,15 @@ export declare class FibonacciHeapNode<E> {
     constructor(element: E, degree?: number);
 }
 export declare class FibonacciHeap<E> {
-    root?: FibonacciHeapNode<E>;
-    size: number;
-    protected min?: FibonacciHeapNode<E>;
-    protected readonly comparator: Comparator<E>;
     constructor(comparator?: Comparator<E>);
+    protected _root?: FibonacciHeapNode<E>;
+    get root(): FibonacciHeapNode<E> | undefined;
+    protected _size: number;
+    get size(): number;
+    protected _min?: FibonacciHeapNode<E>;
+    get min(): FibonacciHeapNode<E> | undefined;
+    protected _comparator: Comparator<E>;
+    get comparator(): Comparator<E>;
     /**
      * Get the size (number of elements) of the heap.
      * @returns {number} The size of the heap.  Returns 0 if the heap is empty. Returns -1 if the heap is invalid.

package/dist/data-structures/heap/heap.js

@@ -9,13 +9,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FibonacciHeap = exports.FibonacciHeapNode = exports.Heap = void 0;
 class Heap {
     constructor(options) {
-        this.nodes = [];
-        this.comparator = options.comparator;
+        this._nodes = [];
+        this._comparator = options.comparator;
         if (options.nodes && options.nodes.length > 0) {
-            this.nodes = options.nodes;
+            this._nodes = options.nodes;
             this.fix();
         }
     }
+    get nodes() {
+        return this._nodes;
+    }
+    get comparator() {
+        return this._comparator;
+    }
     /**
      * Get the size (number of elements) of the heap.
      */
@@ -98,14 +104,14 @@ class Heap {
      * Reset the nodes of the heap. Make the nodes empty.
      */
     clear() {
-        this.nodes = [];
+        this._nodes = [];
     }
     /**
      * Clear and add nodes of the heap
      * @param nodes
      */
     refill(nodes) {
-        this.nodes = nodes;
+        this._nodes = nodes;
         this.fix();
     }
     /**
@@ -162,7 +168,7 @@ class Heap {
      */
     clone() {
         const clonedHeap = new Heap({ comparator: this.comparator });
-        clonedHeap.nodes = [...this.nodes];
+        clonedHeap._nodes = [...this.nodes];
         return clonedHeap;
     }
     /**
@@ -239,21 +245,33 @@ class FibonacciHeapNode {
 exports.FibonacciHeapNode = FibonacciHeapNode;
 class FibonacciHeap {
     constructor(comparator) {
-        this.size = 0;
+        this._size = 0;
         this.clear();
-        this.comparator = comparator || this.defaultComparator;
+        this._comparator = comparator || this.defaultComparator;
         if (typeof this.comparator !== 'function') {
             throw new Error('FibonacciHeap constructor: given comparator should be a function.');
         }
     }
+    get root() {
+        return this._root;
+    }
+    get size() {
+        return this._size;
+    }
+    get min() {
+        return this._min;
+    }
+    get comparator() {
+        return this._comparator;
+    }
     /**
      * Get the size (number of elements) of the heap.
      * @returns {number} The size of the heap.  Returns 0 if the heap is empty. Returns -1 if the heap is invalid.
      */
     clear() {
-        this.root = undefined;
-        this.min = undefined;
-        this.size = 0;
+        this._root = undefined;
+        this._min = undefined;
+        this._size = 0;
     }
     /**
      * O(1) time operation.
@@ -276,9 +294,9 @@ class FibonacciHeap {
         node.right = node;
         this.mergeWithRoot(node);
         if (!this.min || this.comparator(node.element, this.min.element) <= 0) {
-            this.min = node;
+            this._min = node;
         }
-        this.size++;
+        this._size++;
         return this;
     }
     /**
@@ -358,14 +376,14 @@ class FibonacciHeap {
         }
         this.removeFromRoot(z);
         if (z === z.right) {
-            this.min = undefined;
-            this.root = undefined;
+            this._min = undefined;
+            this._root = undefined;
         }
         else {
-            this.min = z.right;
+            this._min = z.right;
             this.consolidate();
         }
-        this.size--;
+        this._size--;
         return z.element;
     }
     /**
@@ -390,10 +408,10 @@ class FibonacciHeap {
         }
         // Update the minimum node
         if (!this.min || (heapToMerge.min && this.comparator(heapToMerge.min.element, this.min.element) < 0)) {
-            this.min = heapToMerge.min;
+            this._min = heapToMerge.min;
         }
         // Update the size
-        this.size += heapToMerge.size;
+        this._size += heapToMerge.size;
         // Clear the heap that was merged
         heapToMerge.clear();
     }
@@ -424,7 +442,7 @@ class FibonacciHeap {
      */
     mergeWithRoot(node) {
         if (!this.root) {
-            this.root = node;
+            this._root = node;
         }
         else {
             node.right = this.root.right;
@@ -441,7 +459,7 @@ class FibonacciHeap {
      */
     removeFromRoot(node) {
         if (this.root === node)
-            this.root = node.right;
+            this._root = node.right;
         if (node.left)
             node.left.right = node.right;
         if (node.right)
@@ -489,7 +507,7 @@ class FibonacciHeap {
         }
         for (let i = 0; i < this.size; i++) {
             if (A[i] && this.comparator(A[i].element, this.min.element) <= 0) {
-                this.min = A[i];
+                this._min = A[i];
             }
         }
     }