@effect/language-service 0.52.1 → 0.53.1

package/index.js

@@ -1243,7 +1243,8 @@ var defaults = {
     skipLeadingPath: ["src/"]
   }],
   extendedKeyDetection: false,
-  pipeableMinArgCount: 1
+  pipeableMinArgCount: 1,
+  layerGraphFollowDepth: 0
 };
 function parseKeyPatterns(patterns) {
   const result = [];
@@ -1279,7 +1280,8 @@ function parse(config) {
     noExternal: isObject(config) && hasProperty(config, "noExternal") && isBoolean(config.noExternal) ? config.noExternal : defaults.noExternal,
     keyPatterns: isObject(config) && hasProperty(config, "keyPatterns") && isArray(config.keyPatterns) ? parseKeyPatterns(config.keyPatterns) : defaults.keyPatterns,
     extendedKeyDetection: isObject(config) && hasProperty(config, "extendedKeyDetection") && isBoolean(config.extendedKeyDetection) ? config.extendedKeyDetection : defaults.extendedKeyDetection,
-    pipeableMinArgCount: isObject(config) && hasProperty(config, "pipeableMinArgCount") && isNumber(config.pipeableMinArgCount) ? config.pipeableMinArgCount : defaults.pipeableMinArgCount
+    pipeableMinArgCount: isObject(config) && hasProperty(config, "pipeableMinArgCount") && isNumber(config.pipeableMinArgCount) ? config.pipeableMinArgCount : defaults.pipeableMinArgCount,
+    layerGraphFollowDepth: isObject(config) && hasProperty(config, "layerGraphFollowDepth") && isNumber(config.layerGraphFollowDepth) ? config.layerGraphFollowDepth : defaults.layerGraphFollowDepth
   };
 }
 
@@ -13901,6 +13903,20 @@ var { Inflate, inflate, inflateRaw, ungzip } = inflate_1$1;
 var deflate_1 = deflate;
 
 // src/core/LayerGraph.ts
+var formatSourceFileName = (sourceFile) => {
+  let fileName = sourceFile.fileName;
+  if (fileName.indexOf("/") > -1) {
+    fileName = fileName.split("/").pop();
+  }
+  return fileName;
+};
+var formatSourceFileNameLineAndColumn = (ts, tsUtils, node, fromSourceFile) => {
+  const nodeSourceFile = tsUtils.getSourceFileOfNode(node);
+  const nodePosition = ts.getTokenPosOfNode(node, nodeSourceFile);
+  const { character, line } = ts.getLineAndCharacterOfPosition(nodeSourceFile, nodePosition);
+  if (!fromSourceFile || nodeSourceFile === fromSourceFile) return `ln ${line + 1} col ${character}`;
+  return `in ${formatSourceFileName(nodeSourceFile)} at ln ${line + 1} col ${character}`;
+};
 var UnableToProduceLayerGraphError = class {
   constructor(message, node) {
     this.message = message;
@@ -13919,11 +13935,14 @@ var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
   const visitedNodes = /* @__PURE__ */ new WeakSet();
   const nodeInPipeContext = /* @__PURE__ */ new WeakSet();
   const nodeToGraph = /* @__PURE__ */ new WeakMap();
-  const nodeToVisit = [node];
-  const appendNodeToVisit = (node2) => {
+  const depthBudget = /* @__PURE__ */ new WeakMap();
+  const nodeToVisit = [];
+  const appendNodeToVisit = (node2, nodeDepthBudget) => {
+    depthBudget.set(node2, nodeDepthBudget);
     nodeToVisit.push(node2);
     return void 0;
   };
+  appendNodeToVisit(node, opts.followSymbolsDepth);
   const mutableGraph = beginMutation3(directed());
   const extractNodeInfo = fn("extractNodeInfo")(function* (node2) {
     let provides = [];
@@ -13951,21 +13970,30 @@ var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
       provides = typeCheckerUtils.unrollUnionMembers(layerTypes.ROut).filter((_) => !(_.flags & ts.TypeFlags.Never));
       requires = typeCheckerUtils.unrollUnionMembers(layerTypes.RIn).filter((_) => !(_.flags & ts.TypeFlags.Never));
     }
-    return { node: node2, layerType, layerTypes, provides, requires };
+    let displayNode = node2;
+    if (node2.parent && ts.isVariableDeclaration(node2.parent) && node2.parent.initializer === node2) {
+      displayNode = node2.parent.name;
+    }
+    return { node: node2, displayNode, layerType, layerTypes, provides, requires };
   });
   const addNode2 = fn("addNode")(function* (node2, nodeInfo) {
     const graphNode = addNode(mutableGraph, nodeInfo ? nodeInfo : yield* extractNodeInfo(node2));
     nodeToGraph.set(node2, graphNode);
     return graphNode;
   });
+  const isSimpleIdentifier = (node2) => {
+    return ts.isIdentifier(node2) || ts.isPropertyAccessExpression(node2) && ts.isIdentifier(node2.name) && isSimpleIdentifier(node2.expression);
+  };
+  const getAdjustedNode2 = (node2) => ts.isPropertyDeclaration(node2) || ts.isVariableDeclaration(node2) ? node2.initializer : ts.isExpression(node2) ? node2 : void 0;
   while (nodeToVisit.length > 0) {
     const node2 = nodeToVisit.pop();
+    const currentDepthBudget = depthBudget.get(node2);
     const pipeArgs = yield* pipe(typeParser.pipeCall(node2), orElse2(() => void_));
     if (pipeArgs) {
       if (!visitedNodes.has(node2)) {
-        appendNodeToVisit(node2);
-        appendNodeToVisit(pipeArgs.subject);
-        pipeArgs.args.forEach(appendNodeToVisit);
+        appendNodeToVisit(node2, currentDepthBudget);
+        appendNodeToVisit(pipeArgs.subject, currentDepthBudget);
+        pipeArgs.args.forEach((_) => appendNodeToVisit(_, currentDepthBudget));
         pipeArgs.args.forEach((_) => nodeInPipeContext.add(_));
         visitedNodes.add(node2);
       } else {
@@ -14000,8 +14028,8 @@ var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
       }
       if (shouldExplode) {
         if (!visitedNodes.has(node2)) {
-          appendNodeToVisit(node2);
-          node2.arguments.forEach(appendNodeToVisit);
+          appendNodeToVisit(node2, currentDepthBudget);
+          node2.arguments.forEach((_) => appendNodeToVisit(_, currentDepthBudget));
           visitedNodes.add(node2);
         } else {
           const childNodes = node2.arguments.map((_) => nodeToGraph.get(_)).filter(isNumber).filter(
@@ -14023,8 +14051,8 @@ var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
     }
     if (opts.arrayLiteralAsMerge && ts.isArrayLiteralExpression(node2)) {
       if (!visitedNodes.has(node2)) {
-        appendNodeToVisit(node2);
-        node2.elements.forEach(appendNodeToVisit);
+        appendNodeToVisit(node2, currentDepthBudget);
+        node2.elements.forEach((_) => appendNodeToVisit(_, currentDepthBudget));
         visitedNodes.add(node2);
       } else {
         const childNodes = node2.elements.map((_) => nodeToGraph.get(_)).filter(isNumber).filter(
@@ -14039,110 +14067,139 @@ var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
       }
       continue;
     }
+    if (currentDepthBudget > 0 && isSimpleIdentifier(node2)) {
+      let symbol3 = typeChecker.getSymbolAtLocation(node2);
+      if (symbol3) {
+        if (symbol3.flags & ts.SymbolFlags.Alias) {
+          symbol3 = typeChecker.getAliasedSymbol(symbol3);
+        }
+        if (symbol3.declarations && symbol3.declarations.length === 1) {
+          const declarationNode = getAdjustedNode2(symbol3.declarations[0]);
+          if (declarationNode) {
+            if (!visitedNodes.has(declarationNode)) {
+              appendNodeToVisit(node2, currentDepthBudget);
+              appendNodeToVisit(declarationNode, currentDepthBudget - 1);
+              visitedNodes.add(node2);
+              continue;
+            }
+            const childNode = nodeToGraph.get(declarationNode);
+            if (isNumber(childNode)) {
+              const graphNode = yield* addNode2(node2);
+              addEdge(mutableGraph, graphNode, childNode, { relationship: "symbol" });
+              continue;
+            }
+          }
+        }
+      }
+    }
     if (ts.isExpression(node2)) {
       const nodeInfo = yield* extractNodeInfo(node2);
       if (nodeInfo.layerTypes) {
         yield* addNode2(node2, nodeInfo);
-        continue;
       }
+      continue;
     }
     return yield* fail(new UnableToProduceLayerGraphError("Unable to produce layer graph for node", node2));
   }
   return endMutation2(mutableGraph);
 });
-var formatLayerGraph = fn("formatLayerGraph")(function* (layerGraph) {
-  const tsUtils = yield* service(TypeScriptUtils);
-  const typeChecker = yield* service(TypeCheckerApi);
-  const ts = yield* service(TypeScriptApi);
-  return toMermaid(layerGraph, {
-    edgeLabel: (edge) => JSON.stringify(edge),
-    nodeLabel: (graphNode) => {
-      const sourceFile = tsUtils.getSourceFileOfNode(graphNode.node);
-      let text = sourceFile.text.substring(graphNode.node.pos, graphNode.node.end).trim();
-      text += "\nprovides: " + graphNode.provides.map((_) => typeChecker.typeToString(_, void 0, ts.TypeFormatFlags.NoTruncation)).join(
-        ", "
-      );
-      text += "\nrequires: " + graphNode.requires.map((_) => typeChecker.typeToString(_, void 0, ts.TypeFormatFlags.NoTruncation)).join(
-        ", "
-      );
-      return text;
-    }
-  });
-});
-var formatNestedLayerGraph = fn("formatNestedLayerGraph")(function* (layerGraph) {
-  const tsUtils = yield* service(TypeScriptUtils);
-  const typeChecker = yield* service(TypeCheckerApi);
-  const ts = yield* service(TypeScriptApi);
-  const mermaidSafe = (value) => value.replace(/\n/g, " ").replace(
-    /\s+/g,
-    " "
-  ).substring(0, 50).replace(/"/g, "#quot;").replace(/</mg, "#lt;").replace(/>/mg, "#gt;").trim();
-  const typeNameCache = /* @__PURE__ */ new Map();
-  const typeName = (type) => {
-    if (typeNameCache.has(type)) return typeNameCache.get(type);
-    const name = typeChecker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
-    typeNameCache.set(type, name);
-    return name;
-  };
-  let result = [];
-  for (const [graphNodeIndex, graphNode] of entries(nodes(layerGraph))) {
-    let subgraphDefs = [];
-    for (const kind of ["requires", "provides"]) {
-      const typesMermaidNodes = [];
-      for (let i = 0; i < graphNode[kind].length; i++) {
-        typesMermaidNodes.push(`${graphNodeIndex}_${kind}_${i}["${mermaidSafe(typeName(graphNode[kind][i]))}"]`);
-      }
-      if (typesMermaidNodes.length > 0) {
-        subgraphDefs = [
-          ...subgraphDefs,
-          `subgraph ${graphNodeIndex}_${kind} [${kind === "provides" ? "Provides" : "Requires"}]`,
-          ...typesMermaidNodes.map((_) => `  ${_}`),
-          `end`,
-          `style ${graphNodeIndex}_${kind} stroke:none`
-        ];
-      }
-    }
-    subgraphDefs = [
-      `subgraph ${graphNodeIndex}_wrap[" "]`,
-      ...subgraphDefs.map((_) => `  ${_}`),
-      `end`,
-      `style ${graphNodeIndex}_wrap fill:transparent`,
-      `style ${graphNodeIndex}_wrap stroke:none`
-    ];
-    const sourceFile = tsUtils.getSourceFileOfNode(graphNode.node);
-    const nodePosition = graphNode.node.getStart(sourceFile, false);
-    const { character, line } = ts.getLineAndCharacterOfPosition(sourceFile, nodePosition);
-    const nodeText = sourceFile.text.substring(graphNode.node.pos, graphNode.node.end).trim();
-    result = [
-      ...result,
-      `subgraph ${graphNodeIndex} ["\`${mermaidSafe(nodeText)}<br/>_at ln ${line + 1} col ${character}_\`"]`,
-      ...subgraphDefs.map((_) => `  ${_}`),
-      `end`,
-      `style ${graphNodeIndex} fill:transparent`
-    ];
+var formatLayerGraph = fn("formatLayerGraph")(
+  function* (layerGraph, _fromSourceFile) {
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const ts = yield* service(TypeScriptApi);
+    return toMermaid(layerGraph, {
+      edgeLabel: (edge) => JSON.stringify(edge),
+      nodeLabel: (graphNode) => {
+        const sourceFile = tsUtils.getSourceFileOfNode(graphNode.node);
+        let text = sourceFile.text.substring(graphNode.node.pos, graphNode.node.end).trim();
+        text += "\nprovides: " + graphNode.provides.map((_) => typeChecker.typeToString(_, void 0, ts.TypeFormatFlags.NoTruncation)).join(
+          ", "
+        );
+        text += "\nrequires: " + graphNode.requires.map((_) => typeChecker.typeToString(_, void 0, ts.TypeFormatFlags.NoTruncation)).join(
+          ", "
+        );
+        return text;
+      }
+    });
   }
-  for (const edgeInfo of values2(edges(layerGraph))) {
-    const sourceData = layerGraph.nodes.get(edgeInfo.source);
-    const targetData = layerGraph.nodes.get(edgeInfo.target);
-    let connected = false;
-    for (const kind of ["requires", "provides"]) {
-      for (let i = 0; i < sourceData[kind].length; i++) {
-        const targetIdx = targetData[kind].indexOf(sourceData[kind][i]);
-        if (targetIdx > -1) {
-          result.push(`${edgeInfo.source}_${kind}_${i} -.-> ${edgeInfo.target}_${kind}_${targetIdx}`);
-          connected = true;
+);
+var formatNestedLayerGraph = fn("formatNestedLayerGraph")(
+  function* (layerGraph, fromSourceFile) {
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const ts = yield* service(TypeScriptApi);
+    const mermaidSafe = (value) => value.replace(/\n/g, " ").replace(
+      /\s+/g,
+      " "
+    ).substring(0, 50).replace(/"/g, "#quot;").replace(/</mg, "#lt;").replace(/>/mg, "#gt;").trim();
+    const typeNameCache = /* @__PURE__ */ new Map();
+    const typeName = (type) => {
+      if (typeNameCache.has(type)) return typeNameCache.get(type);
+      const name = typeChecker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+      typeNameCache.set(type, name);
+      return name;
+    };
+    let result = [];
+    for (const [graphNodeIndex, graphNode] of entries(nodes(layerGraph))) {
+      let subgraphDefs = [];
+      for (const kind of ["requires", "provides"]) {
+        const typesMermaidNodes = [];
+        for (let i = 0; i < graphNode[kind].length; i++) {
+          typesMermaidNodes.push(`${graphNodeIndex}_${kind}_${i}["${mermaidSafe(typeName(graphNode[kind][i]))}"]`);
+        }
+        if (typesMermaidNodes.length > 0) {
+          subgraphDefs = [
+            ...subgraphDefs,
+            `subgraph ${graphNodeIndex}_${kind} [${kind === "provides" ? "Provides" : "Requires"}]`,
+            ...typesMermaidNodes.map((_) => `  ${_}`),
+            `end`,
+            `style ${graphNodeIndex}_${kind} stroke:none`
+          ];
         }
       }
+      subgraphDefs = [
+        `subgraph ${graphNodeIndex}_wrap[" "]`,
+        ...subgraphDefs.map((_) => `  ${_}`),
+        `end`,
+        `style ${graphNodeIndex}_wrap fill:transparent`,
+        `style ${graphNodeIndex}_wrap stroke:none`
+      ];
+      const tsNode = graphNode.displayNode;
+      const sourceFile = tsUtils.getSourceFileOfNode(tsNode);
+      const nodeText = sourceFile.text.substring(tsNode.pos, tsNode.end).trim();
+      result = [
+        ...result,
+        `subgraph ${graphNodeIndex} ["\`${mermaidSafe(nodeText)}<br/><small>_${mermaidSafe(formatSourceFileNameLineAndColumn(ts, tsUtils, tsNode, fromSourceFile))}_</small>\`"]`,
+        ...subgraphDefs.map((_) => `  ${_}`),
+        `end`,
+        `style ${graphNodeIndex} fill:transparent`
+      ];
+    }
+    for (const edgeInfo of values2(edges(layerGraph))) {
+      const sourceData = layerGraph.nodes.get(edgeInfo.source);
+      const targetData = layerGraph.nodes.get(edgeInfo.target);
+      let connected = false;
+      for (const kind of ["requires", "provides"]) {
+        for (let i = 0; i < sourceData[kind].length; i++) {
+          const targetIdx = targetData[kind].indexOf(sourceData[kind][i]);
+          if (targetIdx > -1) {
+            result.push(`${edgeInfo.source}_${kind}_${i} -.-> ${edgeInfo.target}_${kind}_${targetIdx}`);
+            connected = true;
+          }
+        }
+      }
+      if (!connected) {
+        result.push(`${edgeInfo.source} -.-x ${edgeInfo.target}`);
+      }
     }
-    if (!connected) {
-      result.push(`${edgeInfo.source} -.-x ${edgeInfo.target}`);
-    }
+    if (result.length === 0) return "";
+    return [
+      `flowchart TB`,
+      ...result.map((_) => `  ${_}`)
+    ].join("\n");
   }
-  return [
-    `flowchart TB`,
-    ...result.map((_) => `  ${_}`)
-  ].join("\n");
-});
+);
 var extractOutlineGraph = fn("extractOutlineGraph")(function* (layerGraph) {
   const typeChecker = yield* service(TypeCheckerApi);
   const mutableGraph = beginMutation3(directed());
@@ -14162,6 +14219,7 @@ var extractOutlineGraph = fn("extractOutlineGraph")(function* (layerGraph) {
   for (const leafNode of dedupedLeafNodes) {
     const nodeIndex = addNode(mutableGraph, {
       node: leafNode.node,
+      displayNode: leafNode.displayNode,
       requires: leafNode.requires,
       provides: leafNode.provides
     });
@@ -14185,13 +14243,18 @@ var extractOutlineGraph = fn("extractOutlineGraph")(function* (layerGraph) {
   return endMutation2(mutableGraph);
 });
 var formatLayerOutlineGraph = fn("formatLayerOutlineGraph")(
-  function* (layerOutlineGraph) {
+  function* (layerOutlineGraph, fromSourceFile) {
     const tsUtils = yield* service(TypeScriptUtils);
+    const ts = yield* service(TypeScriptApi);
     return toMermaid(layerOutlineGraph, {
       edgeLabel: () => "",
       nodeLabel: (graphNode) => {
-        const sourceFile = tsUtils.getSourceFileOfNode(graphNode.node);
-        return sourceFile.text.substring(graphNode.node.pos, graphNode.node.end).trim();
+        const tsNode = graphNode.displayNode;
+        const sourceFile = tsUtils.getSourceFileOfNode(tsNode);
+        const nodeText = sourceFile.text.substring(tsNode.pos, tsNode.end).trim();
+        if (sourceFile === fromSourceFile) return nodeText;
+        return `${nodeText}
+_${formatSourceFileNameLineAndColumn(ts, tsUtils, tsNode, fromSourceFile)}_`;
       }
     });
   }
@@ -14274,6 +14337,7 @@ var extractProvidersAndRequirers = fn("extractProvidersAndRequirers")(
       const sortedTypes = pipe(fromIterable(rootTypes), sort(typeCheckerUtils.deterministicTypeOrder));
       for (const layerType of sortedTypes) {
         const tsNodes = [];
+        const tsDisplayNodes = [];
         for (const layerNode of values2(
           walkLeavesMatching(
             layerGraph,
@@ -14284,11 +14348,13 @@ var extractProvidersAndRequirers = fn("extractProvidersAndRequirers")(
           )
         )) {
           tsNodes.push(layerNode.node);
+          tsDisplayNodes.push(layerNode.displayNode);
         }
         result.push({
           kind,
           type: layerType,
-          nodes: tsNodes
+          nodes: tsNodes,
+          displayNodes: tsDisplayNodes
         });
       }
     };
@@ -14298,7 +14364,7 @@ var extractProvidersAndRequirers = fn("extractProvidersAndRequirers")(
   }
 );
 var formatLayerProvidersAndRequirersInfo = fn("formatLayerProvidersAndRequirersInfo")(
-  function* (info) {
+  function* (info, fromSourceFile) {
     const typeChecker = yield* service(TypeCheckerApi);
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
@@ -14310,12 +14376,10 @@ var formatLayerProvidersAndRequirersInfo = fn("formatLayerProvidersAndRequirersI
         void 0,
         ts.TypeFormatFlags.NoTruncation
       );
-      const positions = infoNode.nodes.map((_) => {
+      const positions = infoNode.displayNodes.map((_) => {
         const sourceFile = tsUtils.getSourceFileOfNode(_);
-        const nodePosition = ts.getTokenPosOfNode(_, sourceFile);
-        const { character, line } = ts.getLineAndCharacterOfPosition(sourceFile, nodePosition);
         const nodeText = sourceFile.text.substring(_.pos, _.end).trim().replace(/\n/g, " ").substr(0, 50);
-        return `ln ${line + 1} col ${character} by \`${nodeText}\``;
+        return `${formatSourceFileNameLineAndColumn(ts, tsUtils, _, fromSourceFile)} by \`${nodeText}\``;
       });
       textualExplanation.push(`- ${typeString} ${infoNode.kind} at ${positions.join(", ")}`);
     };
@@ -14370,16 +14434,21 @@ function getAdjustedNode(sourceFile, position) {
 }
 function parseLayerGraph(layerNode) {
   return gen(function* () {
+    const options = yield* service(LanguageServicePluginOptions);
+    const tsUtils = yield* service(TypeScriptUtils);
     const layerGraph = yield* extractLayerGraph(layerNode, {
       arrayLiteralAsMerge: false,
-      explodeOnlyLayerCalls: false
+      explodeOnlyLayerCalls: false,
+      followSymbolsDepth: options.layerGraphFollowDepth
     });
-    const nestedGraphMermaid = yield* formatNestedLayerGraph(layerGraph);
+    const sourceFile = tsUtils.getSourceFileOfNode(layerNode);
+    const nestedGraphMermaid = yield* formatNestedLayerGraph(layerGraph, sourceFile);
     const outlineGraph = yield* extractOutlineGraph(layerGraph);
-    const outlineGraphMermaid = yield* formatLayerOutlineGraph(outlineGraph);
+    const outlineGraphMermaid = yield* formatLayerOutlineGraph(outlineGraph, sourceFile);
     const providersAndRequirers = yield* extractProvidersAndRequirers(layerGraph);
     const providersAndRequirersTextualExplanation = yield* formatLayerProvidersAndRequirersInfo(
-      providersAndRequirers
+      providersAndRequirers,
+      sourceFile
     );
     return { nestedGraphMermaid, outlineGraphMermaid, providersAndRequirersTextualExplanation };
   });
@@ -14974,7 +15043,8 @@ var layerMagic = createRefactor({
       return pipe(
         extractLayerGraph(atLocation, {
           arrayLiteralAsMerge: true,
-          explodeOnlyLayerCalls: true
+          explodeOnlyLayerCalls: true,
+          followSymbolsDepth: 0
         }),
         flatMap2(extractOutlineGraph),
         flatMap2(
@@ -15070,7 +15140,8 @@ var layerMagic = createRefactor({
           (_targetLayer) => pipe(
             extractLayerGraph(_targetLayer.castedStructure, {
               arrayLiteralAsMerge: true,
-              explodeOnlyLayerCalls: true
+              explodeOnlyLayerCalls: true,
+              followSymbolsDepth: 0
             }),
             flatMap2(extractOutlineGraph),
             flatMap2(