directed-graph-typed 2.4.3 → 2.4.5

package/dist/umd/directed-graph-typed.js

@@ -30,6 +30,7 @@ var directedGraphTyped = (() => {
     DirectedEdge: () => DirectedEdge,
     DirectedGraph: () => DirectedGraph,
     DirectedVertex: () => DirectedVertex,
+    ERR: () => ERR,
     Range: () => Range
   });
 
@@ -54,6 +55,52 @@ var directedGraphTyped = (() => {
     return result;
   };
 
+  // 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-entry-base.ts
   var IterableEntryBase = class {
     /**
@@ -255,7 +302,7 @@ var directedGraphTyped = (() => {
       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"));
       }
     }
     /**
@@ -411,7 +458,7 @@ var directedGraphTyped = (() => {
         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;
       }
@@ -468,7 +515,7 @@ var directedGraphTyped = (() => {
       __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;
@@ -778,7 +825,7 @@ var directedGraphTyped = (() => {
      */
     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) {
@@ -803,11 +850,6 @@ var directedGraphTyped = (() => {
       }
       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)
@@ -856,8 +898,7 @@ var directedGraphTyped = (() => {
      */
     _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.
@@ -1576,7 +1617,7 @@ var directedGraphTyped = (() => {
           const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
           return this._addEdge(newEdge);
         } else {
-          throw new Error("dest must be a Vertex or vertex key while srcOrEdge is an Edge");
+          throw new TypeError(ERR.invalidArgument("dest must be a Vertex or vertex key when srcOrEdge is an Edge.", "Graph"));
         }
       }
     }
@@ -2185,8 +2226,8 @@ var directedGraphTyped = (() => {
       const Ctor = this.constructor;
       const instance = new Ctor();
       const graph = _options == null ? void 0 : _options.graph;
-      if (graph) instance._options = { ...instance._options, ...graph };
-      else instance._options = { ...instance._options, ...this._options };
+      if (graph) instance["_options"] = { ...instance["_options"], ...graph };
+      else instance["_options"] = { ...instance["_options"], ...this._options };
       return instance;
     }
     /**
@@ -2219,12 +2260,10 @@ var directedGraphTyped = (() => {
         const [va, vb] = ends;
         const ka = va.key;
         const kb = vb.key;
-        const hasA = g.hasVertex ? g.hasVertex(ka) : false;
-        const hasB = g.hasVertex ? g.hasVertex(kb) : false;
+        const hasA = typeof g.hasVertex === "function" ? g.hasVertex(ka) : false;
+        const hasB = typeof g.hasVertex === "function" ? g.hasVertex(kb) : false;
         if (hasA && hasB) {
-          const w = e.weight;
-          const val = e.value;
-          const newEdge = g.createEdge(ka, kb, w, val);
+          const newEdge = g.createEdge(ka, kb, e.weight, e.value);
           g._addEdge(newEdge);
         }
       }
@@ -2262,6 +2301,94 @@ var directedGraphTyped = (() => {
     _getVertexKey(vertexOrKey) {
       return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
     }
+    /**
+     * The edge connector string used in visual output.
+     * Override in subclasses (e.g., '--' for undirected, '->' for directed).
+     */
+    get _edgeConnector() {
+      return "--";
+    }
+    /**
+     * 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) {
+      var _a;
+      const showWeight = (_a = options == null ? void 0 : options.showWeight) != null ? _a : true;
+      const vertices = [...this._vertexMap.values()];
+      const vertexCount = vertices.length;
+      const edgeCount = this.edgeSet().length;
+      const lines = [`Graph (${vertexCount} vertices, ${edgeCount} edges):`];
+      for (const vertex of vertices) {
+        const neighbors = this.getNeighbors(vertex);
+        if (neighbors.length === 0) {
+          lines.push(`  ${vertex.key} (isolated)`);
+        } else {
+          const edgeStrs = neighbors.map((neighbor) => {
+            const edge = this.getEdge(vertex, neighbor);
+            if (edge && showWeight && edge.weight !== void 0 && edge.weight !== 1) {
+              return `${neighbor.key} (${edge.weight})`;
+            }
+            return `${neighbor.key}`;
+          });
+          lines.push(`  ${vertex.key} ${this._edgeConnector} ${edgeStrs.join(", ")}`);
+        }
+      }
+      return lines.join("\n");
+    }
+    /**
+     * 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) {
+      var _a, _b;
+      const name = (_a = options == null ? void 0 : options.name) != null ? _a : "G";
+      const showWeight = (_b = options == null ? void 0 : options.showWeight) != null ? _b : true;
+      const isDirected = this._edgeConnector === "->";
+      const graphType = isDirected ? "digraph" : "graph";
+      const edgeOp = isDirected ? "->" : "--";
+      const lines = [`${graphType} ${name} {`];
+      for (const vertex of this._vertexMap.values()) {
+        lines.push(`  "${vertex.key}";`);
+      }
+      const visited = /* @__PURE__ */ new Set();
+      for (const vertex of this._vertexMap.values()) {
+        for (const neighbor of this.getNeighbors(vertex)) {
+          const edgeId = isDirected ? `${vertex.key}->${neighbor.key}` : [vertex.key, neighbor.key].sort().join("--");
+          if (visited.has(edgeId)) continue;
+          visited.add(edgeId);
+          const edge = this.getEdge(vertex, neighbor);
+          const label = edge && showWeight && edge.weight !== void 0 && edge.weight !== 1 ? ` [label="${edge.weight}"]` : "";
+          lines.push(`  "${vertex.key}" ${edgeOp} "${neighbor.key}"${label};`);
+        }
+      }
+      lines.push("}");
+      return lines.join("\n");
+    }
+    /**
+     * Print the graph to console.
+     * @param options - Display settings passed to `toVisual`.
+     */
+    print(options) {
+      console.log(this.toVisual(options));
+    }
   };
 
   // src/data-structures/graph/directed-graph.ts
@@ -2290,6 +2417,9 @@ var directedGraphTyped = (() => {
       __publicField(this, "_outEdgeMap", /* @__PURE__ */ new Map());
       __publicField(this, "_inEdgeMap", /* @__PURE__ */ new Map());
     }
+    get _edgeConnector() {
+      return "->";
+    }
     get outEdgeMap() {
       return this._outEdgeMap;
     }
@@ -2735,27 +2865,6 @@ var directedGraphTyped = (() => {
       }
     }
   };
-
-  // 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);
 })();
 /**