effect 3.21.2 → 3.21.4

package/src/Graph.ts

@@ -1923,6 +1923,37 @@ export const isAcyclic = <N, E, T extends Kind = "directed">(
     return graph.isAcyclic.value
   }
 
+  if (graph.type === "undirected") {
+    const visited = new Set<NodeIndex>()
+
+    for (const startNode of graph.nodes.keys()) {
+      if (visited.has(startNode)) {
+        continue
+      }
+
+      visited.add(startNode)
+      const stack: Array<{ node: NodeIndex; parent: NodeIndex | null }> = [{ node: startNode, parent: null }]
+
+      while (stack.length > 0) {
+        const { node, parent } = stack.pop()!
+        const nodeNeighbors = getUndirectedNeighbors(graph as any, node)
+
+        for (const neighbor of nodeNeighbors) {
+          if (!visited.has(neighbor)) {
+            visited.add(neighbor)
+            stack.push({ node: neighbor, parent: node })
+          } else if (neighbor !== parent) {
+            graph.isAcyclic = Option.some(false)
+            return false
+          }
+        }
+      }
+    }
+
+    graph.isAcyclic = Option.some(true)
+    return true
+  }
+
   // Stack-safe DFS cycle detection using iterative approach
   const visited = new Set<NodeIndex>()
   const recursionStack = new Set<NodeIndex>()
@@ -2103,6 +2134,21 @@ const getUndirectedNeighbors = <N, E>(
   return Array.from(neighbors)
 }
 
+const getTraversalNeighbors = <N, E, T extends Kind>(
+  graph: Graph<N, E, T> | MutableGraph<N, E, T>,
+  nodeIndex: NodeIndex,
+  direction: Direction
+): Array<NodeIndex> =>
+  graph.type === "undirected"
+    ? getUndirectedNeighbors(graph as any, nodeIndex)
+    : neighborsDirected(graph, nodeIndex, direction)
+
+const getTraversableNeighbor = <N, E, T extends Kind>(
+  graph: Graph<N, E, T> | MutableGraph<N, E, T>,
+  current: NodeIndex,
+  edge: Edge<E>
+): NodeIndex => graph.type === "undirected" && edge.target === current ? edge.source : edge.target
+
 /**
  * Find connected components in an undirected graph.
  * Each component is represented as an array of node indices.
@@ -2432,7 +2478,7 @@ export const dijkstra = <N, E, T extends Kind = "directed">(
       for (const edgeIndex of adjacencyList) {
         const edge = graph.edges.get(edgeIndex)
         if (edge !== undefined) {
-          const neighbor = edge.target
+          const neighbor = getTraversableNeighbor(graph, currentNode, edge)
           const weight = cost(edge.data)
 
           // Validate non-negative weights
@@ -2564,6 +2610,15 @@ export const floydWarshall = <N, E, T extends Kind = "directed">(
       next.get(i)!.set(j, j)
       edgeMatrix.get(i)!.set(j, edgeData.data)
     }
+
+    if (graph.type === "undirected") {
+      const reverseWeight = dist.get(j)!.get(i)!
+      if (weight < reverseWeight) {
+        dist.get(j)!.set(i, weight)
+        next.get(j)!.set(i, i)
+        edgeMatrix.get(j)!.set(i, edgeData.data)
+      }
+    }
   }
 
   // Floyd-Warshall main loop
@@ -2757,7 +2812,7 @@ export const astar = <N, E, T extends Kind = "directed">(
       for (const edgeIndex of adjacencyList) {
         const edge = graph.edges.get(edgeIndex)
         if (edge !== undefined) {
-          const neighbor = edge.target
+          const neighbor = getTraversableNeighbor(graph, currentNode, edge)
           const weight = cost(edge.data)
 
           // Validate non-negative weights
@@ -2893,6 +2948,14 @@ export const bellmanFord = <N, E, T extends Kind = "directed">(
       weight,
       edgeData: edgeData.data
     })
+    if (graph.type === "undirected" && edgeData.source !== edgeData.target) {
+      edges.push({
+        source: edgeData.target,
+        target: edgeData.source,
+        weight,
+        edgeData: edgeData.data
+      })
+    }
   }
 
   // Relax edges up to V-1 times
@@ -2934,14 +2997,8 @@ export const bellmanFord = <N, E, T extends Kind = "directed">(
         affectedNodes.add(node)
 
         // Add all nodes reachable from this node
-        const adjacencyList = graph.adjacency.get(node)
-        if (adjacencyList !== undefined) {
-          for (const edgeIndex of adjacencyList) {
-            const edge = graph.edges.get(edgeIndex)
-            if (edge !== undefined) {
-              queue.push(edge.target)
-            }
-          }
+        for (const neighbor of getTraversalNeighbors(graph, node, "outgoing")) {
+          queue.push(neighbor)
         }
       }
 
@@ -3259,7 +3316,7 @@ export const dfs = <N, E, T extends Kind = "directed">(
             continue
           }
 
-          const neighbors = neighborsDirected(graph, current, direction)
+          const neighbors = getTraversalNeighbors(graph, current, direction)
           for (let i = neighbors.length - 1; i >= 0; i--) {
             const neighbor = neighbors[i]
             if (!discovered.has(neighbor)) {
@@ -3336,7 +3393,7 @@ export const bfs = <N, E, T extends Kind = "directed">(
           if (!discovered.has(current)) {
             discovered.add(current)
 
-            const neighbors = neighborsDirected(graph, current, direction)
+            const neighbors = getTraversalNeighbors(graph, current, direction)
             for (const neighbor of neighbors) {
               if (!discovered.has(neighbor)) {
                 queue.push(neighbor)
@@ -3418,6 +3475,10 @@ export const topo = <N, E, T extends Kind = "directed">(
   graph: Graph<N, E, T> | MutableGraph<N, E, T>,
   config: TopoConfig = {}
 ): NodeWalker<N> => {
+  if (graph.type === "undirected") {
+    throw new Error("Cannot perform topological sort on undirected graph")
+  }
+
   // Check if graph is acyclic first
   if (!isAcyclic(graph)) {
     throw new Error("Cannot perform topological sort on cyclic graph")
@@ -3562,7 +3623,7 @@ export const dfsPostOrder = <N, E, T extends Kind = "directed">(
 
           if (!current.visitedChildren) {
             current.visitedChildren = true
-            const neighbors = neighborsDirected(graph, current.node, direction)
+            const neighbors = getTraversalNeighbors(graph, current.node, direction)
 
             for (let i = neighbors.length - 1; i >= 0; i--) {
               const neighbor = neighbors[i]

package/src/JSONSchema.ts

@@ -843,7 +843,7 @@ function go(
         const parameter = is.parameter
         switch (parameter._tag) {
           case "StringKeyword": {
-            output.additionalProperties = go(
+            const additionalProperties = go(
               pruned,
               $defs,
               "handle-identifier",
@@ -852,6 +852,9 @@ function go(
               "handle-annotation",
               errors
             )
+            output.additionalProperties = isNeverWithoutCustomAnnotations(additionalProperties)
+              ? false
+              : additionalProperties
             break
           }
           case "TemplateLiteral": {

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.21.2"
+let moduleVersion = "3.21.4"
 
 export const getCurrentVersion = () => moduleVersion