directed-graph-typed 1.39.5 → 1.40.0

package/src/data-structures/hash/coordinate-set.ts

@@ -49,8 +49,4 @@ export class CoordinateSet extends Set<any> {
   override delete(value: number[]) {
     return super.delete(value.join(this._joint));
   }
-
-  protected _setJoint(v: string) {
-    this._joint = v;
-  }
 }

package/src/data-structures/hash/hash-map.ts

@@ -38,66 +38,42 @@ export class HashMap<K, V> {
       });
   }
 
-  private _initialCapacity: number;
+  protected _initialCapacity: number;
 
   get initialCapacity(): number {
     return this._initialCapacity;
   }
 
-  set initialCapacity(value: number) {
-    this._initialCapacity = value;
-  }
-
-  private _loadFactor: number;
+  protected _loadFactor: number;
 
   get loadFactor(): number {
     return this._loadFactor;
   }
 
-  set loadFactor(value: number) {
-    this._loadFactor = value;
-  }
-
-  private _capacityMultiplier: number;
+  protected _capacityMultiplier: number;
 
   get capacityMultiplier(): number {
     return this._capacityMultiplier;
   }
 
-  set capacityMultiplier(value: number) {
-    this._capacityMultiplier = value;
-  }
-
-  private _size: number;
+  protected _size: number;
 
   get size(): number {
     return this._size;
   }
 
-  set size(value: number) {
-    this._size = value;
-  }
-
-  private _table: Array<Array<[K, V]>>;
+  protected _table: Array<Array<[K, V]>>;
 
   get table(): Array<Array<[K, V]>> {
     return this._table;
   }
 
-  set table(value: Array<Array<[K, V]>>) {
-    this._table = value;
-  }
-
-  private _hashFn: HashFunction<K>;
+  protected _hashFn: HashFunction<K>;
 
   get hashFn(): HashFunction<K> {
     return this._hashFn;
   }
 
-  set hashFn(value: HashFunction<K>) {
-    this._hashFn = value;
-  }
-
   set(key: K, value: V): void {
     const loadFactor = this.size / this.table.length;
     if (loadFactor >= this.loadFactor) {
@@ -118,7 +94,7 @@ export class HashMap<K, V> {
     }
 
     this.table[index].push([key, value]);
-    this.size++;
+    this._size++;
   }
 
   get(key: K): V | undefined {
@@ -145,7 +121,7 @@ export class HashMap<K, V> {
     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;
@@ -157,7 +133,7 @@ export class HashMap<K, V> {
     }
   }
 
-  *entries(): IterableIterator<[K, V]> {
+  * entries(): IterableIterator<[K, V]> {
     for (const bucket of this.table) {
       if (bucket) {
         for (const [key, value] of bucket) {
@@ -172,15 +148,15 @@ export class HashMap<K, V> {
   }
 
   clear(): void {
-    this.size = 0;
-    this.table = new Array(this.initialCapacity);
+    this._size = 0;
+    this._table = new Array(this.initialCapacity);
   }
 
   isEmpty(): boolean {
     return this.size === 0;
   }
 
-  private _hash(key: K): number {
+  protected _hash(key: K): number {
     return this._hashFn(key);
   }
 
@@ -190,7 +166,7 @@ export class HashMap<K, V> {
    * @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(newCapacity: number): void {
+  protected resizeTable(newCapacity: number): void {
     const newTable = new Array(newCapacity);
     for (const bucket of this._table) {
       // Note that this is this._table

package/src/data-structures/hash/hash-table.ts

@@ -8,12 +8,12 @@
 
 export 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) {
     this.key = key;
-    this.val = val;
+    this.value = value;
     this.next = null;
   }
 }
@@ -21,8 +21,8 @@ export class HashTableNode<K, V> {
 import {HashFunction} from '../../types';
 
 export class HashTable<K, V> {
-  private static readonly DEFAULT_CAPACITY = 16;
-  private static readonly LOAD_FACTOR = 0.75;
+  protected static readonly DEFAULT_CAPACITY = 16;
+  protected static readonly LOAD_FACTOR = 0.75;
 
   constructor(capacity: number = HashTable.DEFAULT_CAPACITY, hashFn?: HashFunction<K>) {
     this._hashFn = hashFn || this._defaultHashFn;
@@ -31,54 +31,42 @@ export class HashTable<K, V> {
     this._buckets = new Array<HashTableNode<K, V> | null>(this._capacity).fill(null);
   }
 
-  private _capacity: number;
+  protected _capacity: number;
 
   get capacity(): number {
     return this._capacity;
   }
 
-  set capacity(value: number) {
-    this._capacity = value;
-  }
-
-  private _size: number;
+  protected _size: number;
 
   get size(): number {
     return this._size;
   }
 
-  private _buckets: Array<HashTableNode<K, V> | null>;
+  protected _buckets: Array<HashTableNode<K, V> | null>;
 
   get buckets(): Array<HashTableNode<K, V> | null> {
     return this._buckets;
   }
 
-  set buckets(value: Array<HashTableNode<K, V> | null>) {
-    this._buckets = value;
-  }
-
-  private _hashFn: HashFunction<K>;
+  protected _hashFn: HashFunction<K>;
 
   get hashFn(): HashFunction<K> {
     return this._hashFn;
   }
 
-  set hashFn(value: HashFunction<K>) {
-    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: K, val: V): void {
+  set(key: K, value: V): void {
     const index = this._hash(key);
-    const newNode = new HashTableNode<K, V>(key, val);
+    const newNode = new HashTableNode<K, V>(key, value);
 
     if (!this._buckets[index]) {
       this._buckets[index] = newNode;
@@ -88,7 +76,7 @@ export class HashTable<K, V> {
       while (currentNode) {
         if (currentNode.key === key) {
           // If the key already exists, update the value
-          currentNode.val = val;
+          currentNode.value = value;
           return;
         }
         if (!currentNode.next) {
@@ -120,7 +108,7 @@ export class HashTable<K, V> {
 
     while (currentNode) {
       if (currentNode.key === key) {
-        return currentNode.val;
+        return currentNode.value;
       }
       currentNode = currentNode.next;
     }
@@ -259,7 +247,7 @@ export class HashTable<K, V> {
       let currentNode = bucket;
       while (currentNode) {
         const newIndex = this._hash(currentNode.key);
-        const newNode = new HashTableNode<K, V>(currentNode.key, currentNode.val);
+        const newNode = new HashTableNode<K, V>(currentNode.key, currentNode.value);
 
         if (!newBuckets[newIndex]) {
           newBuckets[newIndex] = newNode;

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

@@ -1 +1,2 @@
-export class TreeMap {}
+export class TreeMap {
+}

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

@@ -1 +1,2 @@
-export class TreeSet {}
+export class TreeSet {
+}

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

@@ -8,17 +8,26 @@
 import type {Comparator, DFSOrderPattern} from '../../types';
 
 export class Heap<E = any> {
-  protected nodes: E[] = [];
-  protected readonly comparator: Comparator<E>;
-
-  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
-    this.comparator = options.comparator;
+  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+    this._comparator = options.comparator;
     if (options.nodes && options.nodes.length > 0) {
-      this.nodes = options.nodes;
+      this._nodes = options.nodes;
       this.fix();
     }
   }
 
+  protected _nodes: E[] = [];
+
+  get nodes(): E[] {
+    return this._nodes;
+  }
+
+  protected _comparator: Comparator<E>;
+
+  get comparator(): Comparator<E> {
+    return this._comparator;
+  }
+
   /**
    * Get the size (number of elements) of the heap.
    */
@@ -39,7 +48,7 @@ export class Heap<E = any> {
    * @returns A new Heap instance.
    * @param options
    */
-  static heapify<E>(options: {nodes: E[]; comparator: Comparator<E>}): Heap<E> {
+  static heapify<E>(options: { nodes: E[]; comparator: Comparator<E> }): Heap<E> {
     return new Heap<E>(options);
   }
 
@@ -110,7 +119,7 @@ export class Heap<E = any> {
    * Reset the nodes of the heap. Make the nodes empty.
    */
   clear() {
-    this.nodes = [];
+    this._nodes = [];
   }
 
   /**
@@ -118,7 +127,7 @@ export class Heap<E = any> {
    * @param nodes
    */
   refill(nodes: E[]) {
-    this.nodes = nodes;
+    this._nodes = nodes;
     this.fix();
   }
 
@@ -181,7 +190,7 @@ export class Heap<E = any> {
    */
   clone(): Heap<E> {
     const clonedHeap = new Heap<E>({comparator: this.comparator});
-    clonedHeap.nodes = [...this.nodes];
+    clonedHeap._nodes = [...this.nodes];
     return clonedHeap;
   }
 
@@ -268,28 +277,47 @@ export class FibonacciHeapNode<E> {
 }
 
 export class FibonacciHeap<E> {
-  root?: FibonacciHeapNode<E>;
-  size = 0;
-  protected min?: FibonacciHeapNode<E>;
-  protected readonly comparator: Comparator<E>;
-
   constructor(comparator?: Comparator<E>) {
     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.');
     }
   }
 
+  protected _root?: FibonacciHeapNode<E>;
+
+  get root(): FibonacciHeapNode<E> | undefined {
+    return this._root;
+  }
+
+  protected _size = 0;
+
+  get size(): number {
+    return this._size;
+  }
+
+  protected _min?: FibonacciHeapNode<E>;
+
+  get min(): FibonacciHeapNode<E> | undefined {
+    return this._min;
+  }
+
+  protected _comparator: Comparator<E>;
+
+  get comparator(): Comparator<E> {
+    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(): void {
-    this.root = undefined;
-    this.min = undefined;
-    this.size = 0;
+    this._root = undefined;
+    this._min = undefined;
+    this._size = 0;
   }
 
   /**
@@ -315,10 +343,10 @@ export class FibonacciHeap<E> {
     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;
   }
 
@@ -405,14 +433,14 @@ export class FibonacciHeap<E> {
     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;
   }
@@ -444,11 +472,11 @@ export class FibonacciHeap<E> {
 
     // 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();
@@ -481,7 +509,7 @@ export class FibonacciHeap<E> {
    */
   protected mergeWithRoot(node: FibonacciHeapNode<E>): void {
     if (!this.root) {
-      this.root = node;
+      this._root = node;
     } else {
       node.right = this.root.right;
       node.left = this.root;
@@ -497,7 +525,7 @@ export class FibonacciHeap<E> {
    * @protected
    */
   protected removeFromRoot(node: FibonacciHeapNode<E>): void {
-    if (this.root === node) this.root = node.right;
+    if (this.root === node) this._root = node.right;
     if (node.left) node.left.right = node.right;
     if (node.right) node.right.left = node.left;
   }
@@ -554,7 +582,7 @@ export class FibonacciHeap<E> {
 
     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/src/data-structures/heap/max-heap.ts

@@ -11,7 +11,7 @@ import type {Comparator} from '../../types';
 
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/heap/min-heap.ts

@@ -11,7 +11,7 @@ import type {Comparator} from '../../types';
 
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');