effect 4.0.0-beta.5 → 4.0.0-beta.50

package/dist/Graph.js

@@ -8,6 +8,7 @@ import * as Hash from "./Hash.js";
 import { NodeInspectSymbol } from "./Inspectable.js";
 import * as Option from "./Option.js";
 import { pipeArguments } from "./Pipeable.js";
+import { hasProperty } from "./Predicate.js";
 const TypeId = "~effect/collections/Graph";
 /**
  * Edge data containing source, target, and user data.
@@ -105,7 +106,7 @@ const missingNode = node => new GraphError({
  * @since 4.0.0
  * @category Guards
  */
-export const isGraph = u => typeof u === "object" && u !== null && TypeId in u;
+export const isGraph = u => hasProperty(u, TypeId);
 /**
  * Creates a directed graph, optionally with initial mutations.
  *
@@ -135,7 +136,7 @@ export const directed = mutate => {
   graph.reverseAdjacency = new Map();
   graph.nextNodeIndex = 0;
   graph.nextEdgeIndex = 0;
-  graph.acyclic = true;
+  graph.acyclic = Option.some(true);
   graph.mutable = false;
   if (mutate) {
     const mutable = beginMutation(graph);
@@ -173,7 +174,7 @@ export const undirected = mutate => {
   graph.reverseAdjacency = new Map();
   graph.nextNodeIndex = 0;
   graph.nextEdgeIndex = 0;
-  graph.acyclic = true;
+  graph.acyclic = Option.some(true);
   graph.mutable = false;
   if (mutate) {
     const mutable = beginMutation(graph);
@@ -390,10 +391,10 @@ export const nodeCount = graph => graph.nodes.size;
  * })
  *
  * const result = Graph.findNode(graph, (data) => data.startsWith("Node B"))
- * console.log(result) // 1
+ * console.log(result) // Option.some(1)
  *
  * const notFound = Graph.findNode(graph, (data) => data === "Node D")
- * console.log(notFound) // undefined
+ * console.log(notFound) // Option.none()
  * ```
  *
  * @since 4.0.0
@@ -402,9 +403,10 @@ export const nodeCount = graph => graph.nodes.size;
 export const findNode = /*#__PURE__*/dual(2, (graph, predicate) => {
   for (const [index, data] of graph.nodes) {
     if (predicate(data)) {
-      return index;
+      return Option.some(index);
     }
   }
+  return Option.none();
 });
 /**
  * Finds all nodes that match the given predicate.
@@ -454,10 +456,10 @@ export const findNodes = /*#__PURE__*/dual(2, (graph, predicate) => {
  * })
  *
  * const result = Graph.findEdge(graph, (data) => data > 15)
- * console.log(result) // 1
+ * console.log(result) // Option.some(1)
  *
  * const notFound = Graph.findEdge(graph, (data) => data > 100)
- * console.log(notFound) // undefined
+ * console.log(notFound) // Option.none()
  * ```
  *
  * @since 4.0.0
@@ -466,9 +468,10 @@ export const findNodes = /*#__PURE__*/dual(2, (graph, predicate) => {
 export const findEdge = /*#__PURE__*/dual(2, (graph, predicate) => {
   for (const [edgeIndex, edgeData] of graph.edges) {
     if (predicate(edgeData.data, edgeData.source, edgeData.target)) {
-      return edgeIndex;
+      return Option.some(edgeIndex);
     }
   }
+  return Option.none();
 });
 /**
  * Finds all edges that match the given predicate.
@@ -652,11 +655,11 @@ export const mapEdges = (mutable, f) => {
 export const reverse = mutable => {
   // Reverse all edges by swapping source and target
   for (const [index, edgeData] of mutable.edges) {
-    mutable.edges.set(index, {
+    mutable.edges.set(index, new Edge({
       source: edgeData.target,
       target: edgeData.source,
       data: edgeData.data
-    });
+    }));
   }
   // Clear and rebuild adjacency lists with reversed directions
   mutable.adjacency.clear();
@@ -673,7 +676,7 @@ export const reverse = mutable => {
     mutable.reverseAdjacency.set(edgeData.target, targetEdges);
   }
   // Invalidate cycle flag since edge directions changed
-  mutable.acyclic = undefined;
+  mutable.acyclic = Option.none();
 };
 /**
  * Filters and optionally transforms nodes in a mutable graph using a predicate function.
@@ -856,18 +859,16 @@ export const filterEdges = (mutable, predicate) => {
 // =============================================================================
 /** @internal */
 const invalidateCycleFlagOnRemoval = mutable => {
-  // Only invalidate if the graph had cycles (removing edges/nodes cannot introduce cycles in acyclic graphs)
-  // If already unknown (null) or acyclic (true), no need to change
-  if (mutable.acyclic === false) {
-    mutable.acyclic = undefined;
+  // Only invalidate if the graph had cycles (removing edges/nodes cannot introduce cycles in acyclic graphs).
+  if (mutable.acyclic._tag === "Some" && mutable.acyclic.value === false) {
+    mutable.acyclic = Option.none();
   }
 };
 /** @internal */
 const invalidateCycleFlagOnAddition = mutable => {
-  // Only invalidate if the graph was acyclic (adding edges cannot remove cycles from cyclic graphs)
-  // If already unknown (null) or cyclic (false), no need to change
-  if (mutable.acyclic === true) {
-    mutable.acyclic = undefined;
+  // Only invalidate if the graph was acyclic (adding edges cannot remove cycles from cyclic graphs).
+  if (mutable.acyclic._tag === "Some" && mutable.acyclic.value === true) {
+    mutable.acyclic = Option.none();
   }
 };
 // =============================================================================
@@ -1081,17 +1082,17 @@ const removeEdgeInternal = (mutable, edgeIndex) => {
  * const edgeIndex = 0
  * const edgeData = Graph.getEdge(graph, edgeIndex)
  *
- * if (edgeData !== undefined) {
- *   console.log(edgeData.data) // 42
- *   console.log(edgeData.source) // NodeIndex(0)
- *   console.log(edgeData.target) // NodeIndex(1)
+ * if (edgeData._tag === "Some") {
+ *   console.log(edgeData.value.data) // 42
+ *   console.log(edgeData.value.source) // NodeIndex(0)
+ *   console.log(edgeData.value.target) // NodeIndex(1)
  * }
  * ```
  *
  * @since 4.0.0
  * @category getters
  */
-export const getEdge = /*#__PURE__*/dual(2, (graph, edgeIndex) => graph.edges.get(edgeIndex));
+export const getEdge = /*#__PURE__*/dual(2, (graph, edgeIndex) => Option.fromUndefinedOr(graph.edges.get(edgeIndex)));
 /**
  * Checks if an edge exists between two nodes in the graph.
  *
@@ -1309,12 +1310,9 @@ export const toGraphViz = /*#__PURE__*/dual(args => isGraph(args[0]), (graph, op
  * Escapes special characters in labels for Mermaid syntax compatibility.
  */
 const escapeMermaidLabel = label => {
-  return label.replace(/\\/g, "\\\\") // Escape backslashes first
-  .replace(/"/g, "\\\"") // Escape quotes
-  .replace(/\[/g, "\\[") // Escape square brackets
-  .replace(/\]/g, "\\]") // Escape square brackets
-  .replace(/\|/g, "\\|") // Escape pipes
-  .replace(/\n/g, "<br/>"); // Convert newlines to HTML breaks
+  // Escape special characters for Mermaid using HTML entity codes
+  // According to: https://mermaid.js.org/syntax/flowchart.html#special-characters-that-break-syntax
+  return label.replace(/#/g, "#35;").replace(/"/g, "#quot;").replace(/</g, "#lt;").replace(/>/g, "#gt;").replace(/&/g, "#amp;").replace(/\[/g, "#91;").replace(/\]/g, "#93;").replace(/\{/g, "#123;").replace(/\}/g, "#125;").replace(/\(/g, "#40;").replace(/\)/g, "#41;").replace(/\|/g, "#124;").replace(/\\/g, "#92;").replace(/\n/g, "<br/>");
 };
 /**
  * Formats a Mermaid node with the specified shape and label.
@@ -1594,8 +1592,8 @@ export const toMermaid = /*#__PURE__*/dual(args => isGraph(args[0]), (graph, opt
  */
 export const isAcyclic = graph => {
   // Use existing cycle flag if available
-  if (graph.acyclic !== undefined) {
-    return graph.acyclic;
+  if (Option.isSome(graph.acyclic)) {
+    return graph.acyclic.value;
   }
   // Stack-safe DFS cycle detection using iterative approach
   const visited = new Set();
@@ -1613,7 +1611,7 @@ export const isAcyclic = graph => {
       if (isFirstVisit) {
         if (recursionStack.has(node)) {
           // Back edge found - cycle detected
-          graph.acyclic = false;
+          graph.acyclic = Option.some(false);
           return false;
         }
         if (visited.has(node)) {
@@ -1633,7 +1631,7 @@ export const isAcyclic = graph => {
         stack[stack.length - 1] = [node, neighbors, neighborIndex + 1, false];
         if (recursionStack.has(neighbor)) {
           // Back edge found - cycle detected
-          graph.acyclic = false;
+          graph.acyclic = Option.some(false);
           return false;
         }
         if (!visited.has(neighbor)) {
@@ -1647,7 +1645,7 @@ export const isAcyclic = graph => {
     }
   }
   // Cache the result
-  graph.acyclic = true;
+  graph.acyclic = Option.some(true);
   return true;
 };
 /**
@@ -1917,9 +1915,9 @@ export const stronglyConnectedComponents = graph => {
  *   cost: (edgeData) => edgeData
  * })
  *
- * if (result !== undefined) {
- *   console.log(result.path) // [0, 1, 2] - shortest path A->B->C
- *   console.log(result.distance) // 7 - total distance
+ * if (result._tag === "Some") {
+ *   console.log(result.value.path) // [0, 1, 2] - shortest path A->B->C
+ *   console.log(result.value.distance) // 7 - total distance
  * }
  * ```
  *
@@ -1936,11 +1934,11 @@ export const dijkstra = /*#__PURE__*/dual(2, (graph, config) => {
   }
   // Early return if source equals target
   if (config.source === config.target) {
-    return {
+    return Option.some({
       path: [config.source],
       distance: 0,
       costs: []
-    };
+    });
   }
   // Distance tracking and priority queue simulation
   const distances = new Map();
@@ -2016,7 +2014,7 @@ export const dijkstra = /*#__PURE__*/dual(2, (graph, config) => {
   // Check if target is reachable
   const distance = distances.get(config.target);
   if (distance === Infinity) {
-    return undefined; // No path exists
+    return Option.none(); // No path exists
   }
   // Reconstruct path
   const path = [];
@@ -2032,11 +2030,11 @@ export const dijkstra = /*#__PURE__*/dual(2, (graph, config) => {
       currentNode = null;
     }
   }
-  return {
+  return Option.some({
     path,
     distance,
     costs
-  };
+  });
 });
 /**
  * Find shortest paths between all pairs of nodes using Floyd-Warshall algorithm.
@@ -2192,9 +2190,9 @@ export const floydWarshall = /*#__PURE__*/dual(2, (graph, cost) => {
  *   heuristic
  * })
  *
- * if (result !== undefined) {
- *   console.log(result.path) // [0, 1, 2] - shortest path
- *   console.log(result.distance) // 2 - total distance
+ * if (result._tag === "Some") {
+ *   console.log(result.value.path) // [0, 1, 2] - shortest path
+ *   console.log(result.value.distance) // 2 - total distance
  * }
  * ```
  *
@@ -2211,11 +2209,11 @@ export const astar = /*#__PURE__*/dual(2, (graph, config) => {
   }
   // Early return if source equals target
   if (config.source === config.target) {
-    return {
+    return Option.some({
       path: [config.source],
       distance: 0,
       costs: []
-    };
+    });
   }
   // Get target node data for heuristic calculations
   const targetNodeData = getNode(graph, config.target);
@@ -2314,7 +2312,7 @@ export const astar = /*#__PURE__*/dual(2, (graph, config) => {
   // Check if target is reachable
   const distance = gScore.get(config.target);
   if (distance === Infinity) {
-    return undefined; // No path exists
+    return Option.none(); // No path exists
   }
   // Reconstruct path
   const path = [];
@@ -2330,11 +2328,11 @@ export const astar = /*#__PURE__*/dual(2, (graph, config) => {
       currentNode = null;
     }
   }
-  return {
+  return Option.some({
     path,
     distance,
     costs
-  };
+  });
 });
 /**
  * Find the shortest path between two nodes using Bellman-Ford algorithm.
@@ -2362,9 +2360,9 @@ export const astar = /*#__PURE__*/dual(2, (graph, config) => {
  *   cost: (edgeData) => edgeData
  * })
  *
- * if (result !== undefined) {
- *   console.log(result.path) // [0, 1, 2] - shortest path A->B->C
- *   console.log(result.distance) // 2 - total distance
+ * if (result._tag === "Some") {
+ *   console.log(result.value.path) // [0, 1, 2] - shortest path A->B->C
+ *   console.log(result.value.distance) // 2 - total distance
  * }
  * ```
  *
@@ -2381,11 +2379,11 @@ export const bellmanFord = /*#__PURE__*/dual(2, (graph, config) => {
   }
   // Early return if source equals target
   if (config.source === config.target) {
-    return {
+    return Option.some({
       path: [config.source],
       distance: 0,
       costs: []
-    };
+    });
   }
   // Initialize distances and predecessors
   const distances = new Map();
@@ -2451,16 +2449,16 @@ export const bellmanFord = /*#__PURE__*/dual(2, (graph, config) => {
           }
         }
       }
-      // If target is affected by negative cycle, return null
+      // If target is affected by a negative cycle, no shortest path exists.
       if (affectedNodes.has(config.target)) {
-        return undefined;
+        return Option.none();
       }
     }
   }
   // Check if target is reachable
   const distance = distances.get(config.target);
   if (distance === Infinity) {
-    return undefined; // No path exists
+    return Option.none(); // No path exists
   }
   // Reconstruct path
   const path = [];
@@ -2476,11 +2474,11 @@ export const bellmanFord = /*#__PURE__*/dual(2, (graph, config) => {
       currentNode = null;
     }
   }
-  return {
+  return Option.some({
     path,
     distance,
     costs
-  };
+  });
 });
 /**
  * Concrete class for iterables that produce [NodeIndex, NodeData] tuples.