max-priority-queue-typed 2.4.3 → 2.4.5

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

@@ -294,7 +294,7 @@ export declare class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R>
   
      * @remarks Time O(1) Space O(1)
      */
-    protected _comparator: Comparator<K>;
+    protected readonly _comparator: Comparator<K>;
     /**
      * Gets the comparator function used by the tree.
      * @remarks Time O(1)

package/dist/types/data-structures/binary-tree/red-black-tree.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BTNRep, CRUD, EntryCallback, FamilyPosition, NodePredicate, RBTNColor, RedBlackTreeOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BTNRep, CRUD, EntryCallback, FamilyPosition, NodePredicate, RBTNColor, IterationType, RedBlackTreeOptions } from '../../types';
 import { BST } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any> {
@@ -375,6 +375,12 @@ export declare class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R
      * @param [thisArg] - See parameter type for details.
      * @returns A new RedBlackTree with mapped entries.
      */
+    /**
+     * Red-Black trees are self-balancing — `perfectlyBalance` rebuilds via
+     * sorted bulk insert, which naturally produces a balanced RBT.
+     * @remarks Time O(N), Space O(N)
+     */
+    perfectlyBalance(iterationType?: IterationType): boolean;
     map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<RedBlackTreeOptions<MK, MV, MR>>, thisArg?: unknown): RedBlackTree<MK, MV, MR>;
     /**
      * (Internal) Create an empty instance of the same concrete tree type.

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

@@ -337,4 +337,48 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @remarks Time O(1), Space O(1)
      */
     protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey;
+    /**
+     * The edge connector string used in visual output.
+     * Override in subclasses (e.g., '--' for undirected, '->' for directed).
+     */
+    protected get _edgeConnector(): string;
+    /**
+     * Generate a text-based visual representation of the graph.
+     *
+     * **Adjacency list format:**
+     * ```
+     * Graph (5 vertices, 6 edges):
+     * A -> B (1), C (2)
+     * B -> D (3)
+     * C -> (no outgoing edges)
+     * D -> A (1)
+     * E (isolated)
+     * ```
+     *
+     * @param options - Optional display settings.
+     * @param options.showWeight - Whether to show edge weights (default: true).
+     * @returns The visual string.
+     */
+    toVisual(options?: {
+        showWeight?: boolean;
+    }): string;
+    /**
+     * Generate DOT language representation for Graphviz.
+     *
+     * @param options - Optional display settings.
+     * @param options.name - Graph name (default: 'G').
+     * @param options.showWeight - Whether to label edges with weight (default: true).
+     * @returns DOT format string.
+     */
+    toDot(options?: {
+        name?: string;
+        showWeight?: boolean;
+    }): string;
+    /**
+     * Print the graph to console.
+     * @param options - Display settings passed to `toVisual`.
+     */
+    print(options?: {
+        showWeight?: boolean;
+    }): void;
 }

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

@@ -157,6 +157,7 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * @remarks Time O(1), Space O(1)
      */
     constructor(options?: Partial<GraphOptions<V>>);
+    protected get _edgeConnector(): string;
     protected _outEdgeMap: Map<VO, EO[]>;
     get outEdgeMap(): Map<VO, EO[]>;
     set outEdgeMap(v: Map<VO, EO[]>);
@@ -170,7 +171,7 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * @returns DirectedGraph with all keys added.
      * @remarks Time O(V), Space O(V)
      */
-    static fromKeys<K extends VertexKey>(keys: Iterable<K>): DirectedGraph<K, any, DirectedVertex<K>, DirectedEdge<any>>;
+    static fromKeys<K extends VertexKey>(keys: Iterable<K>): DirectedGraph<K, undefined, DirectedVertex<K>, DirectedEdge<undefined>>;
     /**
      * Construct a directed graph from `[key, value]` entries.
      * @template V - Vertex value type.
@@ -178,7 +179,7 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * @returns DirectedGraph with all vertices added.
      * @remarks Time O(V), Space O(V)
      */
-    static fromEntries<V>(entries: Iterable<[VertexKey, V]>): DirectedGraph<V, any, DirectedVertex<V>, DirectedEdge<any>>;
+    static fromEntries<V>(entries: Iterable<[VertexKey, V]>): DirectedGraph<V, undefined, DirectedVertex<V>, DirectedEdge<undefined>>;
     /**
      * Create a directed vertex instance. Does not insert into the graph.
      * @param key - Vertex identifier.

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

@@ -200,7 +200,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * @returns UndirectedGraph with all keys added.
      * @remarks Time O(V), Space O(V)
      */
-    static fromKeys<K extends VertexKey>(keys: Iterable<K>): UndirectedGraph<K, any, UndirectedVertex<K>, UndirectedEdge<any>>;
+    static fromKeys<K extends VertexKey>(keys: Iterable<K>): UndirectedGraph<K, undefined, UndirectedVertex<K>, UndirectedEdge<undefined>>;
     /**
      * Construct an undirected graph from `[key, value]` entries.
      * @template V - Vertex value type.
@@ -208,7 +208,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * @returns UndirectedGraph with all vertices added.
      * @remarks Time O(V), Space O(V)
      */
-    static fromEntries<V>(entries: Iterable<[VertexKey, V]>): UndirectedGraph<V, any, UndirectedVertex<V>, UndirectedEdge<any>>;
+    static fromEntries<V>(entries: Iterable<[VertexKey, V]>): UndirectedGraph<V, undefined, UndirectedVertex<V>, UndirectedEdge<undefined>>;
     /**
      * Create an undirected vertex instance. Does not insert into the graph.
      * @param key - Vertex identifier.
@@ -313,6 +313,20 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
         bridges: EO[];
         cutVertices: VO[];
     };
+    /**
+     * Find biconnected components using edge-stack Tarjan variant.
+     * A biconnected component is a maximal biconnected subgraph.
+     * @returns Array of edge arrays, each representing a biconnected component.
+     * @remarks Time O(V + E), Space O(V + E)
+     */
+    getBiconnectedComponents(): EO[][];
+    /**
+     * Detect whether the graph contains a cycle.
+     * Uses DFS with parent tracking.
+     * @returns `true` if a cycle exists, `false` otherwise.
+     * @remarks Time O(V + E), Space O(V)
+     */
+    hasCycle(): boolean;
     /**
      * Get bridges discovered by `tarjan()`.
      * @returns Array of edges that are bridges.

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

@@ -175,7 +175,7 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @returns Map of object→value.
      */
     get objMap(): Map<object, V>;
-    protected _toEntryFn?: (rawElement: R) => [K, V];
+    protected readonly _toEntryFn?: (rawElement: R) => [K, V];
     /**
      * Get the raw→entry converter function if present.
      * @remarks Time O(1), Space O(1)
@@ -346,7 +346,7 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * @returns Tail node or sentinel.
      */
     get tail(): HashMapLinkedNode<K, V | undefined>;
-    protected _toEntryFn?: (rawElement: R) => [K, V];
+    protected readonly _toEntryFn?: (rawElement: R) => [K, V];
     get toEntryFn(): ((rawElement: R) => [K, V]) | undefined;
     protected _size: number;
     get size(): number;

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

@@ -414,12 +414,8 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
      * @returns A new heap with mapped elements.
      */
     mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this;
-    protected _DEFAULT_COMPARATOR: (a: E, b: E) => number;
-    protected _comparator: Comparator<E>; /**
-     * Get the comparator used to order elements.
-     * @remarks Time O(1), Space O(1)
-     * @returns Comparator function.
-     */
+    protected readonly _DEFAULT_COMPARATOR: Comparator<E>;
+    protected readonly _comparator: Comparator<E>;
     /**
      * Get the comparator used to order elements.
      * @remarks Time O(1), Space O(1)
@@ -501,7 +497,7 @@ export declare class FibonacciHeap<E> {
      * @returns Min node or undefined.
      */
     get min(): FibonacciHeapNode<E> | undefined;
-    protected _comparator: Comparator<E>;
+    protected readonly _comparator: Comparator<E>;
     get comparator(): Comparator<E>;
     clear(): void;
     add(element: E): boolean;

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

@@ -143,7 +143,10 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      * @param [options] - Options such as bucketSize, toElementFn, and maxLen.
      * @returns New Deque instance.
      */
-    constructor(elements?: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>, options?: DequeOptions<E, R>);
+    constructor(elements?: IterableWithSizeOrLength<E>, options?: DequeOptions<E, R>);
+    constructor(elements: IterableWithSizeOrLength<R>, options: DequeOptions<E, R> & {
+        toElementFn: (rawElement: R) => E;
+    });
     protected _bucketSize: number;
     /**
      * Get the current bucket size.
@@ -151,6 +154,26 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      * @returns Bucket capacity per bucket.
      */
     get bucketSize(): number;
+    protected _autoCompactRatio: number;
+    /**
+     * Get the auto-compaction ratio.
+     * When `elements / (bucketCount * bucketSize)` drops below this ratio after
+     * enough shift/pop operations, the deque auto-compacts.
+     * @remarks Time O(1), Space O(1)
+     * @returns Current ratio threshold. 0 means auto-compact is disabled.
+     */
+    get autoCompactRatio(): number;
+    /**
+     * Set the auto-compaction ratio.
+     * @remarks Time O(1), Space O(1)
+     * @param value - Ratio in [0,1]. 0 disables auto-compact.
+     */
+    set autoCompactRatio(value: number);
+    /**
+     * Counter for shift/pop operations since last compaction check.
+     * Only checks ratio every `_bucketSize` operations to minimize overhead.
+     */
+    protected _compactCounter: number;
     protected _bucketFirst: number;
     /**
      * Get the index of the first bucket in use.
@@ -369,6 +392,23 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      * @remarks Time O(N), Space O(1)
      * @returns void
      */
+    /**
+     * (Protected) Trigger auto-compaction if space utilization drops below threshold.
+     * Only checks every `_bucketSize` operations to minimize hot-path overhead.
+     * Uses element-based ratio: `elements / (bucketCount * bucketSize)`.
+     */
+    protected _autoCompact(): void;
+    /**
+     * Compact the deque by removing unused buckets.
+     * @remarks Time O(N), Space O(1)
+     * @returns True if compaction was performed (bucket count reduced).
+     */
+    /**
+     * Compact the deque by removing unused buckets.
+     * @remarks Time O(N), Space O(1)
+     * @returns True if compaction was performed (bucket count reduced).
+     */
+    compact(): boolean;
     shrinkToFit(): void;
     /**
      * Deep clone this deque, preserving options.

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

@@ -1,2 +1,2 @@
 import { BSTOptions } from './bst';
-export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};
+export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R>;

package/dist/types/types/data-structures/binary-tree/red-black-tree.d.ts

@@ -1,3 +1,3 @@
 import type { BSTOptions } from './bst';
 export type RBTNColor = 'RED' | 'BLACK';
-export type RedBlackTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};
+export type RedBlackTreeOptions<K, V, R> = BSTOptions<K, V, R>;

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

@@ -1,2 +1,2 @@
 import { LinearBaseOptions } from '../base';
-export type DoublyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};
+export type DoublyLinkedListOptions<E, R> = LinearBaseOptions<E, R>;

package/dist/types/types/data-structures/linked-list/singly-linked-list.d.ts

@@ -1,2 +1,2 @@
 import { LinearBaseOptions } from '../base';
-export type SinglyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};
+export type SinglyLinkedListOptions<E, R> = LinearBaseOptions<E, R>;

package/dist/types/types/data-structures/priority-queue/priority-queue.d.ts

@@ -1,2 +1,2 @@
 import { HeapOptions } from '../heap';
-export type PriorityQueueOptions<E, R> = HeapOptions<E, R> & {};
+export type PriorityQueueOptions<E, R> = HeapOptions<E, R>;

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

@@ -1,4 +1,10 @@
 import { LinearBaseOptions } from '../base';
 export type DequeOptions<E, R> = {
     bucketSize?: number;
+    /**
+     * When the ratio of used buckets to total buckets falls below this threshold
+     * after a shift/pop, auto-compact is triggered. Set to 0 to disable.
+     * Default: 0.5 (compact when less than half the buckets are in use).
+     */
+    autoCompactRatio?: number;
 } & LinearBaseOptions<E, R>;

package/dist/types/types/data-structures/stack/stack.d.ts

@@ -1,2 +1,2 @@
 import { IterableElementBaseOptions } from '../base';
-export type StackOptions<E, R> = IterableElementBaseOptions<E, R> & {};
+export type StackOptions<E, R> = IterableElementBaseOptions<E, R>;

package/dist/umd/max-priority-queue-typed.js

@@ -24,6 +24,7 @@ var maxPriorityQueueTyped = (() => {
   var src_exports = {};
   __export(src_exports, {
     DFSOperation: () => DFSOperation,
+    ERR: () => ERR,
     FibonacciHeap: () => FibonacciHeap,
     FibonacciHeapNode: () => FibonacciHeapNode,
     Heap: () => Heap,
@@ -32,6 +33,52 @@ var maxPriorityQueueTyped = (() => {
     Range: () => Range
   });
 
+  // src/common/error.ts
+  var ERR = {
+    // Range / index
+    indexOutOfRange: (index, min, max, ctx) => `${ctx ? ctx + ": " : ""}Index ${index} is out of range [${min}, ${max}].`,
+    invalidIndex: (ctx) => `${ctx ? ctx + ": " : ""}Index must be an integer.`,
+    // Type / argument
+    invalidArgument: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    comparatorRequired: (ctx) => `${ctx ? ctx + ": " : ""}Comparator is required for non-number/non-string/non-Date keys.`,
+    invalidKey: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    notAFunction: (name, ctx) => `${ctx ? ctx + ": " : ""}${name} must be a function.`,
+    invalidEntry: (ctx) => `${ctx ? ctx + ": " : ""}Each entry must be a [key, value] tuple.`,
+    invalidNaN: (ctx) => `${ctx ? ctx + ": " : ""}NaN is not a valid key.`,
+    invalidDate: (ctx) => `${ctx ? ctx + ": " : ""}Invalid Date key.`,
+    reduceEmpty: (ctx) => `${ctx ? ctx + ": " : ""}Reduce of empty structure with no initial value.`,
+    callbackReturnType: (expected, got, ctx) => `${ctx ? ctx + ": " : ""}Callback must return ${expected}; got ${got}.`,
+    // State / operation
+    invalidOperation: (reason, ctx) => `${ctx ? ctx + ": " : ""}${reason}`,
+    // Matrix
+    matrixDimensionMismatch: (op) => `Matrix: Dimensions must be compatible for ${op}.`,
+    matrixSingular: () => "Matrix: Singular matrix, inverse does not exist.",
+    matrixNotSquare: () => "Matrix: Must be square for inversion.",
+    matrixNotRectangular: () => "Matrix: Must be rectangular for transposition.",
+    matrixRowMismatch: (expected, got) => `Matrix: Expected row length ${expected}, but got ${got}.`
+  };
+
+  // src/common/index.ts
+  var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
+    DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
+    DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
+    return DFSOperation2;
+  })(DFSOperation || {});
+  var Range = class {
+    constructor(low, high, includeLow = true, includeHigh = true) {
+      this.low = low;
+      this.high = high;
+      this.includeLow = includeLow;
+      this.includeHigh = includeHigh;
+    }
+    // Determine whether a key is within the range
+    isInRange(key, comparator) {
+      const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+      const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+      return lowCheck && highCheck;
+    }
+  };
+
   // src/data-structures/base/iterable-element-base.ts
   var IterableElementBase = class {
     /**
@@ -54,7 +101,7 @@ var maxPriorityQueueTyped = (() => {
       if (options) {
         const { toElementFn } = options;
         if (typeof toElementFn === "function") this._toElementFn = toElementFn;
-        else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+        else if (toElementFn) throw new TypeError(ERR.notAFunction("toElementFn"));
       }
     }
     /**
@@ -210,7 +257,7 @@ var maxPriorityQueueTyped = (() => {
         acc = initialValue;
       } else {
         const first = iter.next();
-        if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
+        if (first.done) throw new TypeError(ERR.reduceEmpty());
         acc = first.value;
         index = 1;
       }
@@ -267,7 +314,7 @@ var maxPriorityQueueTyped = (() => {
       __publicField(this, "_elements", []);
       __publicField(this, "_DEFAULT_COMPARATOR", (a, b) => {
         if (typeof a === "object" || typeof b === "object") {
-          throw TypeError("When comparing object types, define a custom comparator in options.");
+          throw new TypeError(ERR.comparatorRequired("Heap"));
         }
         if (a > b) return 1;
         if (a < b) return -1;
@@ -577,7 +624,7 @@ var maxPriorityQueueTyped = (() => {
      */
     map(callback, options, thisArg) {
       const { comparator, toElementFn, ...rest } = options != null ? options : {};
-      if (!comparator) throw new TypeError("Heap.map requires options.comparator for EM");
+      if (!comparator) throw new TypeError(ERR.comparatorRequired("Heap.map"));
       const out = this._createLike([], { ...rest, comparator, toElementFn });
       let i = 0;
       for (const x of this) {
@@ -602,11 +649,6 @@ var maxPriorityQueueTyped = (() => {
       }
       return out;
     }
-    /**
-    * Get the comparator used to order elements.
-    * @remarks Time O(1), Space O(1)
-    * @returns Comparator function.
-    */
     /**
      * Get the comparator used to order elements.
      * @remarks Time O(1), Space O(1)
@@ -655,8 +697,7 @@ var maxPriorityQueueTyped = (() => {
      */
     _createInstance(options) {
       const Ctor = this.constructor;
-      const next = new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...options != null ? options : {} });
-      return next;
+      return new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...options != null ? options : {} });
     }
     /**
      * (Protected) Create a like-kind instance seeded by elements.
@@ -711,7 +752,7 @@ var maxPriorityQueueTyped = (() => {
       __publicField(this, "_comparator");
       this.clear();
       this._comparator = comparator || this._defaultComparator;
-      if (typeof this.comparator !== "function") throw new Error("FibonacciHeap: comparator must be a function.");
+      if (typeof this.comparator !== "function") throw new TypeError(ERR.notAFunction("comparator", "FibonacciHeap"));
     }
     /**
      * Get the circular root list head.
@@ -929,9 +970,7 @@ var maxPriorityQueueTyped = (() => {
       super(elements, {
         comparator: (a, b) => {
           if (typeof a === "object" || typeof b === "object") {
-            throw TypeError(
-              `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
-            );
+            throw new TypeError(ERR.comparatorRequired("MaxPriorityQueue"));
           }
           if (a < b) return 1;
           if (a > b) return -1;
@@ -941,27 +980,6 @@ var maxPriorityQueueTyped = (() => {
       });
     }
   };
-
-  // src/common/index.ts
-  var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
-    DFSOperation2[DFSOperation2["VISIT"] = 0] = "VISIT";
-    DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
-    return DFSOperation2;
-  })(DFSOperation || {});
-  var Range = class {
-    constructor(low, high, includeLow = true, includeHigh = true) {
-      this.low = low;
-      this.high = high;
-      this.includeLow = includeLow;
-      this.includeHigh = includeHigh;
-    }
-    // Determine whether a key is within the range
-    isInRange(key, comparator) {
-      const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
-      const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
-      return lowCheck && highCheck;
-    }
-  };
   return __toCommonJS(src_exports);
 })();
 /**