@effect/language-service 0.62.3 → 0.62.4

package/index.js

@@ -745,6 +745,7 @@ var isNonEmptyArray = (self) => self.length > 0;
 var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
 var string2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
 var number2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
+var reverse = (O) => make2((self, that) => O(that, self));
 var mapInput = /* @__PURE__ */ dual(2, (self, f) => make2((b1, b2) => self(f(b1), f(b2))));
 
 // node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Option.js
@@ -793,7 +794,7 @@ var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
 var head = /* @__PURE__ */ get(0);
 var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
 var tailNonEmpty = (self) => self.slice(1);
-var reverse = (self) => Array.from(self).reverse();
+var reverse2 = (self) => Array.from(self).reverse();
 var sort = /* @__PURE__ */ dual(2, (self, O) => {
   const out = Array.from(self);
   out.sort(O);
@@ -1032,21 +1033,21 @@ var reverseChunk = (self) => {
     case "IArray": {
       return makeChunk({
         _tag: "IArray",
-        array: reverse(self.backing.array)
+        array: reverse2(self.backing.array)
       });
     }
     case "IConcat": {
       return makeChunk({
         _tag: "IConcat",
-        left: reverse2(self.backing.right),
-        right: reverse2(self.backing.left)
+        left: reverse3(self.backing.right),
+        right: reverse3(self.backing.left)
       });
     }
     case "ISlice":
-      return unsafeFromArray(reverse(toReadonlyArray(self)));
+      return unsafeFromArray(reverse2(toReadonlyArray(self)));
   }
 };
-var reverse2 = reverseChunk;
+var reverse3 = reverseChunk;
 var unsafeFromArray = (self) => self.length === 0 ? empty2() : self.length === 1 ? of(self[0]) : makeChunk({
   _tag: "IArray",
   array: self
@@ -1903,7 +1904,7 @@ var flattenCauseLoop = (causes, flattened) => {
     }));
     const updated = size3(parallel2) > 0 ? pipe(flattened, prepend(parallel2)) : flattened;
     if (isEmpty(sequential2)) {
-      return reverse2(updated);
+      return reverse3(updated);
     }
     causes = sequential2;
     flattened = updated;
@@ -2750,7 +2751,7 @@ var addNode = (mutable, data) => {
 var getNode = (graph, nodeIndex) => graph.nodes.has(nodeIndex) ? some2(graph.nodes.get(nodeIndex)) : none2();
 var hasNode = (graph, nodeIndex) => graph.nodes.has(nodeIndex);
 var nodeCount = (graph) => graph.nodes.size;
-var reverse3 = (mutable) => {
+var reverse4 = (mutable) => {
   for (const [index, edgeData] of mutable.edges) {
     mutable.edges.set(index, {
       source: edgeData.target,
@@ -3009,70 +3010,6 @@ var Walker = class {
 var indices = (walker) => walker.visit((index, _) => index);
 var values2 = (walker) => walker.visit((_, data) => data);
 var entries = (walker) => walker.visit((index, data) => [index, data]);
-var dfsPostOrder = (graph, config = {}) => {
-  const start = config.start ?? [];
-  const direction = config.direction ?? "outgoing";
-  for (const nodeIndex of start) {
-    if (!hasNode(graph, nodeIndex)) {
-      throw missingNode(nodeIndex);
-    }
-  }
-  return new Walker((f) => ({
-    [Symbol.iterator]: () => {
-      const stack = [];
-      const discovered = /* @__PURE__ */ new Set();
-      const finished = /* @__PURE__ */ new Set();
-      for (let i = start.length - 1; i >= 0; i--) {
-        stack.push({
-          node: start[i],
-          visitedChildren: false
-        });
-      }
-      const nextMapped = () => {
-        while (stack.length > 0) {
-          const current = stack[stack.length - 1];
-          if (!discovered.has(current.node)) {
-            discovered.add(current.node);
-            current.visitedChildren = false;
-          }
-          if (!current.visitedChildren) {
-            current.visitedChildren = true;
-            const neighbors = neighborsDirected(graph, current.node, direction);
-            for (let i = neighbors.length - 1; i >= 0; i--) {
-              const neighbor = neighbors[i];
-              if (!discovered.has(neighbor) && !finished.has(neighbor)) {
-                stack.push({
-                  node: neighbor,
-                  visitedChildren: false
-                });
-              }
-            }
-          } else {
-            const nodeToEmit = stack.pop().node;
-            if (!finished.has(nodeToEmit)) {
-              finished.add(nodeToEmit);
-              const nodeData = getNode(graph, nodeToEmit);
-              if (isSome2(nodeData)) {
-                return {
-                  done: false,
-                  value: f(nodeToEmit, nodeData.value)
-                };
-              }
-              return nextMapped();
-            }
-          }
-        }
-        return {
-          done: true,
-          value: void 0
-        };
-      };
-      return {
-        next: nextMapped
-      };
-    }
-  }));
-};
 var nodes = (graph) => new Walker((f) => ({
   [Symbol.iterator]() {
     const nodeMap = graph.nodes;
@@ -8216,7 +8153,7 @@ var missedPipeableOpportunity = createDiagnostic({
                         parentChain,
                         filter(ts.isCallExpression),
                         map4((call) => call.expression),
-                        reverse
+                        reverse2
                       )
                     )
                   );
@@ -15843,6 +15780,54 @@ _${formatSourceFileNameLineAndColumn(ts, tsUtils, tsNode, fromSourceFile)}_`;
     });
   }
 );
+var dfsPostOrderWithOrder = (graph, config) => {
+  const start = config.start ?? [];
+  const direction = config.direction ?? "outgoing";
+  const orderByIndex = mapInput(config.order, (_) => graph.nodes.get(_));
+  return new Walker((f) => ({
+    [Symbol.iterator]: () => {
+      const stack = [];
+      const discovered = /* @__PURE__ */ new Set();
+      const finished = /* @__PURE__ */ new Set();
+      const sortedStart = sort(start, orderByIndex);
+      for (let i = sortedStart.length - 1; i >= 0; i--) {
+        stack.push({ node: sortedStart[i], visitedChildren: false });
+      }
+      const nextMapped = () => {
+        while (stack.length > 0) {
+          const current = stack[stack.length - 1];
+          if (!discovered.has(current.node)) {
+            discovered.add(current.node);
+            current.visitedChildren = false;
+          }
+          if (!current.visitedChildren) {
+            current.visitedChildren = true;
+            const neighbors = neighborsDirected(graph, current.node, direction);
+            const sortedNeighbors = sort(neighbors, orderByIndex);
+            for (let i = sortedNeighbors.length - 1; i >= 0; i--) {
+              const neighbor = sortedNeighbors[i];
+              if (!discovered.has(neighbor) && !finished.has(neighbor)) {
+                stack.push({ node: neighbor, visitedChildren: false });
+              }
+            }
+          } else {
+            const nodeToEmit = stack.pop().node;
+            if (!finished.has(nodeToEmit)) {
+              finished.add(nodeToEmit);
+              const nodeData = getNode(graph, nodeToEmit);
+              if (isSome2(nodeData)) {
+                return { done: false, value: f(nodeToEmit, nodeData.value) };
+              }
+              return nextMapped();
+            }
+          }
+        }
+        return { done: true, value: void 0 };
+      };
+      return { next: nextMapped };
+    }
+  }));
+};
 var convertOutlineGraphToLayerMagic = fn("convertOutlineGraphToLayerMagic")(
   function* (outlineGraph, targetOutput) {
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
@@ -15850,9 +15835,15 @@ var convertOutlineGraphToLayerMagic = fn("convertOutlineGraphToLayerMagic")(
     const result = [];
     const missingOutputTypes = new Set(typeCheckerUtils.unrollUnionMembers(targetOutput));
     const currentRequiredTypes = /* @__PURE__ */ new Set();
-    const reversedGraph = mutate2(outlineGraph, reverse3);
+    const orderByProvidedCount = mapInput(
+      reverse(number2),
+      (_) => _.provides.length
+    );
+    const reversedGraph = mutate2(outlineGraph, reverse4);
     const rootIndexes = fromIterable(indices(externals(reversedGraph, { direction: "incoming" })));
-    const allNodes = fromIterable(values2(dfsPostOrder(reversedGraph, { start: rootIndexes })));
+    const allNodes = fromIterable(
+      values2(dfsPostOrderWithOrder(reversedGraph, { start: rootIndexes, order: orderByProvidedCount }))
+    );
     for (const nodeInfo of allNodes) {
       if (!ts.isExpression(nodeInfo.node)) continue;
       const reallyProvidedTypes = nodeInfo.provides.filter((_) => nodeInfo.requires.indexOf(_) === -1);