priority-queue-typed 2.4.4 → 2.5.0

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

@@ -24,6 +24,7 @@ var priorityQueueTyped = (() => {
   var src_exports = {};
   __export(src_exports, {
     DFSOperation: () => DFSOperation,
+    ERR: () => ERR,
     FibonacciHeap: () => FibonacciHeap,
     FibonacciHeapNode: () => FibonacciHeapNode,
     Heap: () => Heap,
@@ -255,6 +256,52 @@ var priorityQueueTyped = (() => {
     }
   };
 
+  // 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/heap/heap.ts
   var Heap = class _Heap extends IterableElementBase {
     /**
@@ -270,7 +317,7 @@ var priorityQueueTyped = (() => {
       __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;
@@ -292,10 +339,30 @@ var priorityQueueTyped = (() => {
       return this._elements;
     }
     /**
-     * Get the number of elements.
-     * @remarks Time O(1), Space O(1)
-     * @returns Heap size.
-     */
+      * Get the number of elements.
+      * @remarks Time O(1), Space O(1)
+      * @returns Heap size.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Track heap capacity
+    *  const heap = new Heap<number>();
+    *     console.log(heap.size); // 0;
+    *     heap.add(10);
+    *     heap.add(20);
+    *     console.log(heap.size); // 2;
+    *     heap.poll();
+    *     console.log(heap.size); // 1;
+      */
     get size() {
       return this.elements.length;
     }
@@ -334,21 +401,61 @@ var priorityQueueTyped = (() => {
       return new _Heap(elements, options);
     }
     /**
-     * Insert an element.
-     * @remarks Time O(1) amortized, Space O(1)
-     * @param element - Element to insert.
-     * @returns True.
-     */
+      * Insert an element.
+      * @remarks Time O(1) amortized, Space O(1)
+      * @param element - Element to insert.
+      * @returns True.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // basic Heap creation and add operation
+    *  // Create a min heap (default)
+    *     const minHeap = new Heap([5, 3, 7, 1, 9, 2]);
+    *
+    *     // Verify size
+    *     console.log(minHeap.size); // 6;
+    *
+    *     // Add new element
+    *     minHeap.add(4);
+    *     console.log(minHeap.size); // 7;
+    *
+    *     // Min heap property: smallest element at root
+    *     const min = minHeap.peek();
+    *     console.log(min); // 1;
+      */
     add(element) {
       this._elements.push(element);
       return this._bubbleUp(this.elements.length - 1);
     }
     /**
-     * Insert many elements from an iterable.
-     * @remarks Time O(N log N), Space O(1)
-     * @param elements - Iterable of elements or raw values.
-     * @returns Array of per-element success flags.
-     */
+      * Insert many elements from an iterable.
+      * @remarks Time O(N log N), Space O(1)
+      * @param elements - Iterable of elements or raw values.
+      * @returns Array of per-element success flags.
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Add multiple elements
+    *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
+    *     heap.addMany([5, 3, 7, 1]);
+    *     console.log(heap.peek()); // 1;
+    *     console.log(heap.size); // 4;
+      */
     addMany(elements) {
       const flags = [];
       for (const el of elements) {
@@ -363,10 +470,46 @@ var priorityQueueTyped = (() => {
       return flags;
     }
     /**
-     * Remove and return the top element.
-     * @remarks Time O(log N), Space O(1)
-     * @returns Top element or undefined.
-     */
+      * Remove and return the top element.
+      * @remarks Time O(log N), Space O(1)
+      * @returns Top element or undefined.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Heap with custom comparator (MaxHeap behavior)
+    *  interface Task {
+    *       id: number;
+    *       priority: number;
+    *       name: string;
+    *     }
+    *
+    *     // Custom comparator for max heap behavior (higher priority first)
+    *     const tasks: Task[] = [
+    *       { id: 1, priority: 5, name: 'Email' },
+    *       { id: 2, priority: 3, name: 'Chat' },
+    *       { id: 3, priority: 8, name: 'Alert' }
+    *     ];
+    *
+    *     const maxHeap = new Heap(tasks, {
+    *       comparator: (a: Task, b: Task) => b.priority - a.priority
+    *     });
+    *
+    *     console.log(maxHeap.size); // 3;
+    *
+    *     // Peek returns highest priority task
+    *     const topTask = maxHeap.peek();
+    *     console.log(topTask?.priority); // 8;
+    *     console.log(topTask?.name); // 'Alert';
+      */
     poll() {
       if (this.elements.length === 0) return;
       const value = this.elements[0];
@@ -378,26 +521,125 @@ var priorityQueueTyped = (() => {
       return value;
     }
     /**
-     * Get the current top element without removing it.
-     * @remarks Time O(1), Space O(1)
-     * @returns Top element or undefined.
-     */
+      * Get the current top element without removing it.
+      * @remarks Time O(1), Space O(1)
+      * @returns Top element or undefined.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Heap for event processing with priority
+    *  interface Event {
+    *       id: number;
+    *       type: 'critical' | 'warning' | 'info';
+    *       timestamp: number;
+    *       message: string;
+    *     }
+    *
+    *     // Custom priority: critical > warning > info
+    *     const priorityMap = { critical: 3, warning: 2, info: 1 };
+    *
+    *     const eventHeap = new Heap<Event>([], {
+    *       comparator: (a: Event, b: Event) => {
+    *         const priorityA = priorityMap[a.type];
+    *         const priorityB = priorityMap[b.type];
+    *         return priorityB - priorityA; // Higher priority first
+    *       }
+    *     });
+    *
+    *     // Add events in random order
+    *     eventHeap.add({ id: 1, type: 'info', timestamp: 100, message: 'User logged in' });
+    *     eventHeap.add({ id: 2, type: 'critical', timestamp: 101, message: 'Server down' });
+    *     eventHeap.add({ id: 3, type: 'warning', timestamp: 102, message: 'High memory' });
+    *     eventHeap.add({ id: 4, type: 'info', timestamp: 103, message: 'Cache cleared' });
+    *     eventHeap.add({ id: 5, type: 'critical', timestamp: 104, message: 'Database error' });
+    *
+    *     console.log(eventHeap.size); // 5;
+    *
+    *     // Process events by priority (critical first)
+    *     const processedOrder: Event[] = [];
+    *     while (eventHeap.size > 0) {
+    *       const event = eventHeap.poll();
+    *       if (event) {
+    *         processedOrder.push(event);
+    *       }
+    *     }
+    *
+    *     // Verify critical events came first
+    *     console.log(processedOrder[0].type); // 'critical';
+    *     console.log(processedOrder[1].type); // 'critical';
+    *     console.log(processedOrder[2].type); // 'warning';
+    *     console.log(processedOrder[3].type); // 'info';
+    *     console.log(processedOrder[4].type); // 'info';
+    *
+    *     // Verify O(log n) operations
+    *     const newHeap = new Heap<number>([5, 3, 7, 1]);
+    *
+    *     // Add - O(log n)
+    *     newHeap.add(2);
+    *     console.log(newHeap.size); // 5;
+    *
+    *     // Poll - O(log n)
+    *     const removed = newHeap.poll();
+    *     console.log(removed); // 1;
+    *
+    *     // Peek - O(1)
+    *     const top = newHeap.peek();
+    *     console.log(top); // 2;
+      */
     peek() {
       return this.elements[0];
     }
     /**
-     * Check whether the heap is empty.
-     * @remarks Time O(1), Space O(1)
-     * @returns True if size is 0.
-     */
+      * Check whether the heap is empty.
+      * @remarks Time O(1), Space O(1)
+      * @returns True if size is 0.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Check if heap is empty
+    *  const heap = new Heap<number>([], { comparator: (a, b) => a - b });
+    *     console.log(heap.isEmpty()); // true;
+    *     heap.add(1);
+    *     console.log(heap.isEmpty()); // false;
+      */
     isEmpty() {
       return this.size === 0;
     }
     /**
-     * Remove all elements.
-     * @remarks Time O(1), Space O(1)
-     * @returns void
-     */
+      * Remove all elements.
+      * @remarks Time O(1), Space O(1)
+      * @returns void
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Remove all elements
+    *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
+    *     heap.clear();
+    *     console.log(heap.isEmpty()); // true;
+      */
     clear() {
       this._elements = [];
     }
@@ -412,21 +654,41 @@ var priorityQueueTyped = (() => {
       return this.fix();
     }
     /**
-     * Check if an equal element exists in the heap.
-     * @remarks Time O(N), Space O(1)
-     * @param element - Element to search for.
-     * @returns True if found.
-     */
+      * Check if an equal element exists in the heap.
+      * @remarks Time O(N), Space O(1)
+      * @param element - Element to search for.
+      * @returns True if found.
+      
+      
+       * @example
+    * // Check element existence
+    *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
+    *     console.log(heap.has(1)); // true;
+    *     console.log(heap.has(99)); // false;
+      */
     has(element) {
       for (const el of this.elements) if (this._equals(el, element)) return true;
       return false;
     }
     /**
-     * Delete one occurrence of an element.
-     * @remarks Time O(N), Space O(1)
-     * @param element - Element to delete.
-     * @returns True if an element was removed.
-     */
+      * Delete one occurrence of an element.
+      * @remarks Time O(N), Space O(1)
+      * @param element - Element to delete.
+      * @returns True if an element was removed.
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Remove specific element
+    *  const heap = new Heap<number>([3, 1, 4, 1, 5], { comparator: (a, b) => a - b });
+    *     heap.delete(4);
+    *     console.log(heap.toArray().includes(4)); // false;
+      */
     delete(element) {
       let index = -1;
       for (let i = 0; i < this.elements.length; i++) {
@@ -484,11 +746,18 @@ var priorityQueueTyped = (() => {
       return this;
     }
     /**
-     * Traverse the binary heap as a complete binary tree and collect elements.
-     * @remarks Time O(N), Space O(H)
-     * @param [order] - Traversal order: 'PRE' | 'IN' | 'POST'.
-     * @returns Array of visited elements.
-     */
+      * Traverse the binary heap as a complete binary tree and collect elements.
+      * @remarks Time O(N), Space O(H)
+      * @param [order] - Traversal order: 'PRE' | 'IN' | 'POST'.
+      * @returns Array of visited elements.
+      
+      
+       * @example
+    * // Depth-first traversal
+    *  const heap = new Heap<number>([3, 1, 2], { comparator: (a, b) => a - b });
+    *     const result = heap.dfs('IN');
+    *     console.log(result.length); // 3;
+      */
     dfs(order = "PRE") {
       const result = [];
       const _dfs = (index) => {
@@ -525,10 +794,26 @@ var priorityQueueTyped = (() => {
       return results;
     }
     /**
-     * Return all elements in ascending order by repeatedly polling.
-     * @remarks Time O(N log N), Space O(N)
-     * @returns Sorted array of elements.
-     */
+      * Return all elements in ascending order by repeatedly polling.
+      * @remarks Time O(N log N), Space O(N)
+      * @returns Sorted array of elements.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Sort elements using heap
+    *  const heap = new Heap<number>([5, 1, 3, 2, 4]);
+    *     const sorted = heap.sort();
+    *     console.log(sorted); // [1, 2, 3, 4, 5];
+      */
     sort() {
       const visited = [];
       const cloned = this._createInstance();
@@ -540,22 +825,52 @@ var priorityQueueTyped = (() => {
       return visited;
     }
     /**
-     * Deep clone this heap.
-     * @remarks Time O(N), Space O(N)
-     * @returns A new heap with the same elements.
-     */
+      * Deep clone this heap.
+      * @remarks Time O(N), Space O(N)
+      * @returns A new heap with the same elements.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Create independent copy
+    *  const heap = new Heap<number>([3, 1, 4], { comparator: (a, b) => a - b });
+    *     const copy = heap.clone();
+    *     copy.poll();
+    *     console.log(heap.size); // 3;
+    *     console.log(copy.size); // 2;
+      */
     clone() {
       const next = this._createInstance();
       for (const x of this.elements) next.add(x);
       return next;
     }
     /**
-     * Filter elements into a new heap of the same class.
-     * @remarks Time O(N log N), Space O(N)
-     * @param callback - Predicate (element, index, heap) → boolean to keep element.
-     * @param [thisArg] - Value for `this` inside the callback.
-     * @returns A new heap with the kept elements.
-     */
+      * Filter elements into a new heap of the same class.
+      * @remarks Time O(N log N), Space O(N)
+      * @param callback - Predicate (element, index, heap) → boolean to keep element.
+      * @param [thisArg] - Value for `this` inside the callback.
+      * @returns A new heap with the kept elements.
+      
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Filter elements
+    *  const heap = new Heap<number>([1, 2, 3, 4, 5], { comparator: (a, b) => a - b });
+    *     const evens = heap.filter(x => x % 2 === 0);
+    *     console.log(evens.size); // 2;
+      */
     filter(callback, thisArg) {
       const out = this._createInstance();
       let i = 0;
@@ -569,18 +884,31 @@ var priorityQueueTyped = (() => {
       return out;
     }
     /**
-     * Map elements into a new heap of possibly different element type.
-     * @remarks Time O(N log N), Space O(N)
-     * @template EM
-     * @template RM
-     * @param callback - Mapping function (element, index, heap) → newElement.
-     * @param options - Options for the output heap, including comparator for EM.
-     * @param [thisArg] - Value for `this` inside the callback.
-     * @returns A new heap with mapped elements.
-     */
+      * Map elements into a new heap of possibly different element type.
+      * @remarks Time O(N log N), Space O(N)
+      * @template EM
+      * @template RM
+      * @param callback - Mapping function (element, index, heap) → newElement.
+      * @param options - Options for the output heap, including comparator for EM.
+      * @param [thisArg] - Value for `this` inside the callback.
+      * @returns A new heap with mapped elements.
+      
+      
+      
+      
+      
+      
+      
+      
+       * @example
+    * // Transform elements
+    *  const heap = new Heap<number>([1, 2, 3], { comparator: (a, b) => a - b });
+    *     const doubled = heap.map(x => x * 2, { comparator: (a, b) => a - b });
+    *     console.log(doubled.peek()); // 2;
+      */
     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) {
@@ -708,7 +1036,7 @@ var priorityQueueTyped = (() => {
       __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.
@@ -917,9 +1245,7 @@ var priorityQueueTyped = (() => {
       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("MaxHeap"));
           }
           if (a < b) return 1;
           if (a > b) return -1;
@@ -975,9 +1301,7 @@ var priorityQueueTyped = (() => {
       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;
@@ -987,27 +1311,6 @@ var priorityQueueTyped = (() => {
       });
     }
   };
-
-  // 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);
 })();
 /**