min-heap-typed 1.39.6 → 1.40.0

package/dist/data-structures/binary-tree/avl-tree.js

@@ -48,7 +48,6 @@ class AVLTree extends bst_1.BST {
      * @returns The method is returning the inserted node (`N`), `null`, or `undefined`.
      */
     add(keyOrNode, value) {
-        // TODO support node as a param
         const inserted = super.add(keyOrNode, value);
         if (inserted)
             this._balancePath(inserted);

package/dist/data-structures/binary-tree/binary-indexed-tree.d.ts

@@ -13,13 +13,10 @@ export declare class BinaryIndexedTree {
     });
     protected _freqMap: Record<number, number>;
     get freqMap(): Record<number, number>;
-    set freqMap(value: Record<number, number>);
     protected _msb: number;
     get msb(): number;
-    set msb(value: number);
     protected _negativeCount: number;
     get negativeCount(): number;
-    set negativeCount(value: number);
     get freq(): number;
     get max(): number;
     /**

package/dist/data-structures/binary-tree/binary-indexed-tree.js

@@ -26,21 +26,12 @@ class BinaryIndexedTree {
     get freqMap() {
         return this._freqMap;
     }
-    set freqMap(value) {
-        this._freqMap = value;
-    }
     get msb() {
         return this._msb;
     }
-    set msb(value) {
-        this._msb = value;
-    }
     get negativeCount() {
         return this._negativeCount;
     }
-    set negativeCount(value) {
-        this._negativeCount = value;
-    }
     get freq() {
         return this._freq;
     }
@@ -198,10 +189,10 @@ class BinaryIndexedTree {
      */
     _updateNegativeCount(freqCur, freqNew) {
         if (freqCur < 0 && freqNew >= 0) {
-            this.negativeCount--;
+            this._negativeCount--;
         }
         else if (freqCur >= 0 && freqNew < 0) {
-            this.negativeCount++;
+            this._negativeCount++;
         }
     }
     /**

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -32,7 +32,7 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
      * @param {V} value - The value stored in the node.
      */
     constructor(key: BTNKey, value?: V);
-    private _left;
+    protected _left: N | null | undefined;
     /**
      * Get the left child node.
      */
@@ -42,7 +42,7 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
      * @param {N | null | undefined} v - The left child node.
      */
     set left(v: N | null | undefined);
-    private _right;
+    protected _right: N | null | undefined;
     /**
      * Get the right child node.
      */
@@ -63,27 +63,18 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
  * @template N - The type of the binary tree's nodes.
  */
 export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>> implements IBinaryTree<V, N> {
+    iterationType: IterationType;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options?: BinaryTreeOptions);
-    private _iterationType;
-    /**
-     * Get the iteration type used in the binary tree.
-     */
-    get iterationType(): IterationType;
-    /**
-     * Set the iteration type for the binary tree.
-     * @param {IterationType} v - The new iteration type to set.
-     */
-    set iterationType(v: IterationType);
-    private _root;
+    protected _root: N | null;
     /**
      * Get the root node of the binary tree.
      */
     get root(): N | null;
-    private _size;
+    protected _size: number;
     /**
      * Get the number of nodes in the binary tree.
      */
@@ -361,10 +352,4 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * type `N` or `null`.
      */
     protected _setRoot(v: N | null): void;
-    /**
-     * The function sets the value of the protected property "_size" to the given number.
-     * @param {number} v - The parameter "v" is a number that represents the size value that we want to
-     * set.
-     */
-    protected _setSize(v: number): void;
 }

package/dist/data-structures/binary-tree/binary-tree.js

@@ -87,27 +87,14 @@ class BinaryTree {
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options) {
-        this._iterationType = types_1.IterationType.ITERATIVE;
+        this.iterationType = types_1.IterationType.ITERATIVE;
         this._root = null;
         this._size = 0;
         if (options !== undefined) {
             const { iterationType = types_1.IterationType.ITERATIVE } = options;
-            this._iterationType = iterationType;
+            this.iterationType = iterationType;
         }
     }
-    /**
-     * Get the iteration type used in the binary tree.
-     */
-    get iterationType() {
-        return this._iterationType;
-    }
-    /**
-     * Set the iteration type for the binary tree.
-     * @param {IterationType} v - The new iteration type to set.
-     */
-    set iterationType(v) {
-        this._iterationType = v;
-    }
     /**
      * Get the root node of the binary tree.
      */
@@ -133,7 +120,7 @@ class BinaryTree {
      * Clear the binary tree, removing all nodes.
      */
     clear() {
-        this._root = null;
+        this._setRoot(null);
         this._size = 0;
     }
     /**
@@ -197,10 +184,10 @@ class BinaryTree {
         else {
             this._setRoot(needInsert);
             if (needInsert !== null) {
-                this._setSize(1);
+                this._size = 1;
             }
             else {
-                this._setSize(0);
+                this._size = 0;
             }
             inserted = this.root;
         }
@@ -297,7 +284,7 @@ class BinaryTree {
                 }
             }
         }
-        this._setSize(this.size - 1);
+        this._size = this.size - 1;
         bstDeletedResult.push({ deleted: orgCurrent, needBalanced });
         return bstDeletedResult;
     }
@@ -1093,14 +1080,14 @@ class BinaryTree {
             if (parent.left === undefined) {
                 parent.left = newNode;
                 if (newNode) {
-                    this._setSize(this.size + 1);
+                    this._size = this.size + 1;
                 }
                 return parent.left;
             }
             else if (parent.right === undefined) {
                 parent.right = newNode;
                 if (newNode) {
-                    this._setSize(this.size + 1);
+                    this._size = this.size + 1;
                 }
                 return parent.right;
             }
@@ -1124,13 +1111,5 @@ class BinaryTree {
         }
         this._root = v;
     }
-    /**
-     * The function sets the value of the protected property "_size" to the given number.
-     * @param {number} v - The parameter "v" is a number that represents the size value that we want to
-     * set.
-     */
-    _setSize(v) {
-        this._size = v;
-    }
 }
 exports.BinaryTree = BinaryTree;

package/dist/data-structures/binary-tree/bst.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BTNKey, BSTComparator, BSTNodeNested, BSTOptions, BTNCallback } from '../../types';
+import type { BSTComparator, BSTNodeNested, BSTOptions, BTNCallback, BTNKey } from '../../types';
 import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';

package/dist/data-structures/binary-tree/bst.js

@@ -63,7 +63,7 @@ class BST extends binary_tree_1.BinaryTree {
         }
         if (this.root === null) {
             this._setRoot(newNode);
-            this._setSize(this.size + 1);
+            this._size = this.size + 1;
             inserted = this.root;
         }
         else {
@@ -87,7 +87,7 @@ class BST extends binary_tree_1.BinaryTree {
                             }
                             //Add to the left of the current node
                             cur.left = newNode;
-                            this._setSize(this.size + 1);
+                            this._size = this.size + 1;
                             traversing = false;
                             inserted = cur.left;
                         }
@@ -105,7 +105,7 @@ class BST extends binary_tree_1.BinaryTree {
                             }
                             //Add to the right of the current node
                             cur.right = newNode;
-                            this._setSize(this.size + 1);
+                            this._size = this.size + 1;
                             traversing = false;
                             inserted = cur.right;
                         }

package/dist/data-structures/binary-tree/rb-tree.d.ts

@@ -3,9 +3,7 @@ import { IBinaryTree } from '../../interfaces';
 import { BST, BSTNode } from './bst';
 export declare class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
     constructor(key: BTNKey, value?: V);
-    private _color;
-    get color(): RBColor;
-    set color(value: RBColor);
+    color: RBColor;
 }
 export declare class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
     constructor(options?: RBTreeOptions);

package/dist/data-structures/binary-tree/rb-tree.js

@@ -6,13 +6,7 @@ const bst_1 = require("./bst");
 class RBTreeNode extends bst_1.BSTNode {
     constructor(key, value) {
         super(key, value);
-        this._color = types_1.RBColor.RED;
-    }
-    get color() {
-        return this._color;
-    }
-    set color(value) {
-        this._color = value;
+        this.color = types_1.RBColor.RED;
     }
 }
 exports.RBTreeNode = RBTreeNode;

package/dist/data-structures/binary-tree/segment-tree.d.ts

@@ -7,25 +7,13 @@
  */
 import type { SegmentTreeNodeVal } from '../../types';
 export declare class SegmentTreeNode {
+    start: number;
+    end: number;
+    value: SegmentTreeNodeVal | null;
+    sum: number;
+    left: SegmentTreeNode | null;
+    right: SegmentTreeNode | null;
     constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | null);
-    private _start;
-    get start(): number;
-    set start(v: number);
-    private _end;
-    get end(): number;
-    set end(v: number);
-    private _value;
-    get value(): SegmentTreeNodeVal | null;
-    set value(v: SegmentTreeNodeVal | null);
-    private _sum;
-    get sum(): number;
-    set sum(v: number);
-    private _left;
-    get left(): SegmentTreeNode | null;
-    set left(v: SegmentTreeNode | null);
-    private _right;
-    get right(): SegmentTreeNode | null;
-    set right(v: SegmentTreeNode | null);
 }
 export declare class SegmentTree {
     /**
@@ -38,13 +26,13 @@ export declare class SegmentTree {
      * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
      */
     constructor(values: number[], start?: number, end?: number);
-    private _values;
+    protected _values: number[];
     get values(): number[];
-    private _start;
+    protected _start: number;
     get start(): number;
-    private _end;
+    protected _end: number;
     get end(): number;
-    private _root;
+    protected _root: SegmentTreeNode | null;
     get root(): SegmentTreeNode | null;
     /**
      * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning
@@ -76,8 +64,4 @@ export declare class SegmentTree {
      * @returns The function `querySumByRange` returns a number.
      */
     querySumByRange(indexA: number, indexB: number): number;
-    protected _setValues(value: number[]): void;
-    protected _setStart(value: number): void;
-    protected _setEnd(value: number): void;
-    protected _setRoot(v: SegmentTreeNode | null): void;
 }

package/dist/data-structures/binary-tree/segment-tree.js

@@ -10,52 +10,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentTree = exports.SegmentTreeNode = void 0;
 class SegmentTreeNode {
     constructor(start, end, sum, value) {
-        this._start = 0;
-        this._end = 0;
-        this._value = null;
-        this._sum = 0;
-        this._left = null;
-        this._right = null;
-        this._start = start;
-        this._end = end;
-        this._sum = sum;
-        this._value = value || null;
-    }
-    get start() {
-        return this._start;
-    }
-    set start(v) {
-        this._start = v;
-    }
-    get end() {
-        return this._end;
-    }
-    set end(v) {
-        this._end = v;
-    }
-    get value() {
-        return this._value;
-    }
-    set value(v) {
-        this._value = v;
-    }
-    get sum() {
-        return this._sum;
-    }
-    set sum(v) {
-        this._sum = v;
-    }
-    get left() {
-        return this._left;
-    }
-    set left(v) {
-        this._left = v;
-    }
-    get right() {
-        return this._right;
-    }
-    set right(v) {
-        this._right = v;
+        this.start = 0;
+        this.end = 0;
+        this.value = null;
+        this.sum = 0;
+        this.left = null;
+        this.right = null;
+        this.start = start;
+        this.end = end;
+        this.sum = sum;
+        this.value = value || null;
     }
 }
 exports.SegmentTreeNode = SegmentTreeNode;
@@ -212,17 +176,5 @@ class SegmentTree {
         };
         return dfs(root, indexA, indexB);
     }
-    _setValues(value) {
-        this._values = value;
-    }
-    _setStart(value) {
-        this._start = value;
-    }
-    _setEnd(value) {
-        this._end = value;
-    }
-    _setRoot(v) {
-        this._root = v;
-    }
 }
 exports.SegmentTree = SegmentTree;

package/dist/data-structures/binary-tree/tree-multiset.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BTNKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
-import { BinaryTreeDeletedResult, IterationType, BTNCallback } from '../../types';
+import { BinaryTreeDeletedResult, BTNCallback, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, N> {

package/dist/data-structures/binary-tree/tree-multiset.js

@@ -75,7 +75,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         }
         if (!this.root) {
             this._setRoot(newNode);
-            this._setSize(this.size + 1);
+            this._size = this.size + 1;
             newNode && this._setCount(this.count + newNode.count);
             inserted = this.root;
         }
@@ -97,7 +97,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                             if (cur.left === undefined) {
                                 //Add to the left of the current node
                                 cur.left = newNode;
-                                this._setSize(this.size + 1);
+                                this._size = this.size + 1;
                                 this._setCount(this.count + newNode.count);
                                 traversing = false;
                                 inserted = cur.left;
@@ -113,7 +113,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                             if (cur.right === undefined) {
                                 //Add to the right of the current node
                                 cur.right = newNode;
-                                this._setSize(this.size + 1);
+                                this._size = this.size + 1;
                                 this._setCount(this.count + newNode.count);
                                 traversing = false;
                                 inserted = cur.right;
@@ -151,7 +151,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             if (parent.left === undefined) {
                 parent.left = newNode;
                 if (newNode !== null) {
-                    this._setSize(this.size + 1);
+                    this._size = this.size + 1;
                     this._setCount(this.count + newNode.count);
                 }
                 return parent.left;
@@ -159,7 +159,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             else if (parent.right === undefined) {
                 parent.right = newNode;
                 if (newNode !== null) {
-                    this._setSize(this.size + 1);
+                    this._size = (this.size + 1);
                     this._setCount(this.count + newNode.count);
                 }
                 return parent.right;
@@ -304,7 +304,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                     }
                 }
             }
-            this._setSize(this.size - 1);
+            this._size = this.size - 1;
             // TODO How to handle when the count of target node is lesser than current node's count
             this._setCount(this.count - orgCurrent.count);
         }

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

@@ -1,6 +1,8 @@
 import type { DijkstraResult, VertexKey } from '../../types';
 import { IGraph } from '../../interfaces';
 export declare abstract class AbstractVertex<V = any> {
+    key: VertexKey;
+    value: V | undefined;
     /**
      * The function is a protected constructor that takes an key and an optional value as parameters.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
@@ -9,14 +11,10 @@ export declare abstract class AbstractVertex<V = any> {
      * vertex. If no value is provided, it will be set to undefined.
      */
     protected constructor(key: VertexKey, value?: V);
-    private _key;
-    get key(): VertexKey;
-    set key(v: VertexKey);
-    private _value;
-    get value(): V | undefined;
-    set value(value: V | undefined);
 }
 export declare abstract class AbstractEdge<E = any> {
+    value: E | undefined;
+    weight: number;
     /**
      * The above function is a protected constructor that initializes the weight, value, and hash code properties of an
      * object.
@@ -27,27 +25,11 @@ export declare abstract class AbstractEdge<E = any> {
      * meaning it can be omitted when creating an instance of the class.
      */
     protected constructor(weight?: number, value?: E);
-    private _value;
-    get value(): E | undefined;
-    set value(value: E | undefined);
-    private _weight;
-    get weight(): number;
-    set weight(v: number);
     protected _hashCode: string;
     get hashCode(): string;
-    /**
-     * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
-     * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
-     */
-    /**
-     * The function sets the value of the _hashCode property to the provided string.
-     * @param {string} v - The parameter "v" is of type string and represents the value that will be assigned to the
-     * "_hashCode" property.
-     */
-    protected _setHashCode(v: string): void;
 }
 export declare abstract class AbstractGraph<V = any, E = any, VO extends AbstractVertex<V> = AbstractVertex<V>, EO extends AbstractEdge<E> = AbstractEdge<E>> implements IGraph<V, E, VO, EO> {
-    private _vertices;
+    protected _vertices: Map<VertexKey, VO>;
     get vertices(): Map<VertexKey, VO>;
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
@@ -328,5 +310,4 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
     protected _addVertexOnly(newVertex: VO): boolean;
     protected _getVertex(vertexOrKey: VertexKey | VO): VO | null;
     protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey;
-    protected _setVertices(value: Map<VertexKey, VO>): void;
 }

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

@@ -20,20 +20,8 @@ class AbstractVertex {
      * vertex. If no value is provided, it will be set to undefined.
      */
     constructor(key, value) {
-        this._key = key;
-        this._value = value;
-    }
-    get key() {
-        return this._key;
-    }
-    set key(v) {
-        this._key = v;
-    }
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
+        this.key = key;
+        this.value = value;
     }
 }
 exports.AbstractVertex = AbstractVertex;
@@ -48,37 +36,13 @@ class AbstractEdge {
      * meaning it can be omitted when creating an instance of the class.
      */
     constructor(weight, value) {
-        this._weight = weight !== undefined ? weight : 1;
-        this._value = value;
+        this.weight = weight !== undefined ? weight : 1;
+        this.value = value;
         this._hashCode = (0, utils_1.uuidV4)();
     }
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-    }
-    get weight() {
-        return this._weight;
-    }
-    set weight(v) {
-        this._weight = v;
-    }
     get hashCode() {
         return this._hashCode;
     }
-    /**
-     * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
-     * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
-     */
-    /**
-     * The function sets the value of the _hashCode property to the provided string.
-     * @param {string} v - The parameter "v" is of type string and represents the value that will be assigned to the
-     * "_hashCode" property.
-     */
-    _setHashCode(v) {
-        this._hashCode = v;
-    }
 }
 exports.AbstractEdge = AbstractEdge;
 class AbstractGraph {
@@ -916,8 +880,5 @@ class AbstractGraph {
     _getVertexKey(vertexOrKey) {
         return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
     }
-    _setVertices(value) {
-        this._vertices = value;
-    }
 }
 exports.AbstractGraph = AbstractGraph;

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

@@ -12,6 +12,8 @@ export declare class DirectedVertex<V = any> extends AbstractVertex<V> {
     constructor(key: VertexKey, value?: V);
 }
 export declare class DirectedEdge<E = any> extends AbstractEdge<E> {
+    src: VertexKey;
+    dest: VertexKey;
     /**
      * The constructor function initializes the source and destination vertices of an edge, along with an optional weight
      * and value.
@@ -24,21 +26,15 @@ export declare class DirectedEdge<E = any> extends AbstractEdge<E> {
      * the edge.
      */
     constructor(src: VertexKey, dest: VertexKey, weight?: number, value?: E);
-    private _src;
-    get src(): VertexKey;
-    set src(v: VertexKey);
-    private _dest;
-    get dest(): VertexKey;
-    set dest(v: VertexKey);
 }
 export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V> = DirectedVertex<V>, EO extends DirectedEdge<E> = DirectedEdge<E>> extends AbstractGraph<V, E, VO, EO> implements IGraph<V, E, VO, EO> {
     /**
      * The constructor function initializes an instance of a class.
      */
     constructor();
-    private _outEdgeMap;
+    protected _outEdgeMap: Map<VO, EO[]>;
     get outEdgeMap(): Map<VO, EO[]>;
-    private _inEdgeMap;
+    protected _inEdgeMap: Map<VO, EO[]>;
     get inEdgeMap(): Map<VO, EO[]>;
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
@@ -195,6 +191,4 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * source or destination vertex does not exist in the graph.
      */
     protected _addEdgeOnly(edge: EO): boolean;
-    protected _setOutEdgeMap(value: Map<VO, EO[]>): void;
-    protected _setInEdgeMap(value: Map<VO, EO[]>): void;
 }