min-heap-typed 1.39.6 → 1.40.0

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

@@ -37,20 +37,8 @@ class DirectedEdge extends abstract_graph_1.AbstractEdge {
      */
     constructor(src, dest, weight, value) {
         super(weight, value);
-        this._src = src;
-        this._dest = dest;
-    }
-    get src() {
-        return this._src;
-    }
-    set src(v) {
-        this._src = v;
-    }
-    get dest() {
-        return this._dest;
-    }
-    set dest(v) {
-        this._dest = v;
+        this.src = src;
+        this.dest = dest;
     }
 }
 exports.DirectedEdge = DirectedEdge;
@@ -412,11 +400,5 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
             return false;
         }
     }
-    _setOutEdgeMap(value) {
-        this._outEdgeMap = value;
-    }
-    _setInEdgeMap(value) {
-        this._inEdgeMap = value;
-    }
 }
 exports.DirectedGraph = DirectedGraph;

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

@@ -1,6 +1,8 @@
 import { MapGraphCoordinate, VertexKey } from '../../types';
 import { DirectedEdge, DirectedGraph, DirectedVertex } from './directed-graph';
 export declare class MapVertex<V = any> extends DirectedVertex<V> {
+    lat: number;
+    long: number;
     /**
      * The constructor function initializes an object with an key, latitude, longitude, and an optional value.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex.
@@ -14,12 +16,6 @@ export declare class MapVertex<V = any> extends DirectedVertex<V> {
      * creating an instance of the class.
      */
     constructor(key: VertexKey, value: V, lat: number, long: number);
-    private _lat;
-    get lat(): number;
-    set lat(value: number);
-    private _long;
-    get long(): number;
-    set long(value: number);
 }
 export declare class MapEdge<E = any> extends DirectedEdge<E> {
     /**
@@ -45,12 +41,10 @@ export declare class MapGraph<V = any, E = any, VO extends MapVertex<V> = MapVer
      * it will default to `undefined`.
      */
     constructor(origin: MapGraphCoordinate, bottomRight?: MapGraphCoordinate);
-    private _origin;
+    protected _origin: MapGraphCoordinate;
     get origin(): MapGraphCoordinate;
-    set origin(value: MapGraphCoordinate);
-    private _bottomRight;
+    protected _bottomRight: MapGraphCoordinate | undefined;
     get bottomRight(): MapGraphCoordinate | undefined;
-    set bottomRight(value: MapGraphCoordinate | undefined);
     /**
      * The function creates a new vertex with the given key, value, latitude, and longitude.
      * @param {VertexKey} key - The key parameter is the unique identifier for the vertex. It is of type VertexKey, which could

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

@@ -17,20 +17,8 @@ class MapVertex extends directed_graph_1.DirectedVertex {
      */
     constructor(key, value, lat, long) {
         super(key, value);
-        this._lat = lat;
-        this._long = long;
-    }
-    get lat() {
-        return this._lat;
-    }
-    set lat(value) {
-        this._lat = value;
-    }
-    get long() {
-        return this._long;
-    }
-    set long(value) {
-        this._long = value;
+        this.lat = lat;
+        this.long = long;
     }
 }
 exports.MapVertex = MapVertex;
@@ -69,15 +57,9 @@ class MapGraph extends directed_graph_1.DirectedGraph {
     get origin() {
         return this._origin;
     }
-    set origin(value) {
-        this._origin = value;
-    }
     get bottomRight() {
         return this._bottomRight;
     }
-    set bottomRight(value) {
-        this._bottomRight = value;
-    }
     /**
      * The function creates a new vertex with the given key, value, latitude, and longitude.
      * @param {VertexKey} key - The key parameter is the unique identifier for the vertex. It is of type VertexKey, which could

package/dist/data-structures/graph/undirected-graph.d.ts

@@ -12,6 +12,7 @@ export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
     constructor(key: VertexKey, value?: V);
 }
 export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
+    vertices: [VertexKey, VertexKey];
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -23,9 +24,6 @@ export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
      * with the edge.
      */
     constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E);
-    private _vertices;
-    get vertices(): [VertexKey, VertexKey];
-    set vertices(v: [VertexKey, VertexKey]);
 }
 export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVertex<V> = UndirectedVertex<V>, EO extends UndirectedEdge<E> = UndirectedEdge<E>> extends AbstractGraph<V, E, VO, EO> implements IGraph<V, E, VO, EO> {
     /**
@@ -119,9 +117,4 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * @returns a boolean value.
      */
     protected _addEdgeOnly(edge: EO): boolean;
-    /**
-     * 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.
-     */
-    protected _setEdges(v: Map<VO, EO[]>): void;
 }

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

@@ -36,13 +36,7 @@ class UndirectedEdge extends abstract_graph_1.AbstractEdge {
      */
     constructor(v1, v2, weight, value) {
         super(weight, value);
-        this._vertices = [v1, v2];
-    }
-    get vertices() {
-        return this._vertices;
-    }
-    set vertices(v) {
-        this._vertices = v;
+        this.vertices = [v1, v2];
     }
 }
 exports.UndirectedEdge = UndirectedEdge;
@@ -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

@@ -13,20 +13,17 @@ export declare class HashTableNode<K, 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

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

@@ -26,24 +26,15 @@ 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

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];
             }
         }
     }

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -6,34 +6,26 @@
  * @license MIT License
  */
 export declare class DoublyLinkedListNode<E = any> {
+    value: E;
+    next: DoublyLinkedListNode<E> | null;
+    prev: DoublyLinkedListNode<E> | null;
     /**
      * The constructor function initializes the value, next, and previous properties of an object.
      * @param {E} value - The "value" parameter is the value that will be stored in the node. It can be of any data type, as it
      * is defined as a generic type "E".
      */
     constructor(value: E);
-    private _value;
-    get value(): E;
-    set value(value: E);
-    private _next;
-    get next(): DoublyLinkedListNode<E> | null;
-    set next(value: DoublyLinkedListNode<E> | null);
-    private _prev;
-    get prev(): DoublyLinkedListNode<E> | null;
-    set prev(value: DoublyLinkedListNode<E> | null);
 }
 export declare class DoublyLinkedList<E = any> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
     constructor();
-    private _head;
+    protected _head: DoublyLinkedListNode<E> | null;
     get head(): DoublyLinkedListNode<E> | null;
-    set head(value: DoublyLinkedListNode<E> | null);
-    private _tail;
+    protected _tail: DoublyLinkedListNode<E> | null;
     get tail(): DoublyLinkedListNode<E> | null;
-    set tail(value: DoublyLinkedListNode<E> | null);
-    private _length;
+    protected _length: number;
     get length(): number;
     get size(): number;
     /**