@effect/language-service 0.22.2 → 0.23.0

package/README.md

@@ -84,8 +84,10 @@ Few options can be provided alongside the initialization of the Language Service
         },
         "quickinfo": true, // controls quickinfo over Effect (default: true)
         "completions": true, // controls Effect completions (default: true)
+        "goto": true, // controls Effect goto references (default: true)
         "allowedDuplicatedPackages": [], // list of package names that has effect in peer dependencies and are allowed to be duplicated (default: [])
-        "namespaceImportPackages": [] // list of package names that should be preferred as imported with namespace imports e.g. ["effect"] (default: [])
+        "barrelImportPackages": [], // package names that should be preferred as imported from the top level barrel file (default: [])
+        "namespaceImportPackages": [] // package names that should be preferred as imported with namespace imports e.g. ["effect"] (default: [])
       }
     ]
   }

package/index.js

@@ -1423,7 +1423,8 @@ function parse(config) {
     completions: isObject(config) && hasProperty(config, "completions") && isBoolean(config.completions) ? config.completions : true,
     goto: isObject(config) && hasProperty(config, "goto") && isBoolean(config.goto) ? config.goto : true,
     allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : [],
-    namespaceImportPackages: isObject(config) && hasProperty(config, "namespaceImportPackages") && isArray(config.namespaceImportPackages) && config.namespaceImportPackages.every(isString) ? config.namespaceImportPackages.map((_) => _.toLowerCase()) : []
+    namespaceImportPackages: isObject(config) && hasProperty(config, "namespaceImportPackages") && isArray(config.namespaceImportPackages) && config.namespaceImportPackages.every(isString) ? config.namespaceImportPackages.map((_) => _.toLowerCase()) : [],
+    barrelImportPackages: isObject(config) && hasProperty(config, "barrelImportPackages") && isArray(config.barrelImportPackages) && config.barrelImportPackages.every(isString) ? config.barrelImportPackages.map((_) => _.toLowerCase()) : []
   };
 }
 
@@ -3484,7 +3485,7 @@ var completions = [
   effectDiagnosticsComment
 ];
 
-// src/completions/middlewareNamespaceImports.ts
+// src/completions/middlewareAutoImports.ts
 var importablePackagesMetadataCache = /* @__PURE__ */ new Map();
 var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(function* (sourceFile) {
   const ts = yield* service(TypeScriptApi);
@@ -3494,7 +3495,18 @@ var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(functi
   const namespaceByFileName = /* @__PURE__ */ new Map();
   const excludedByFileName = /* @__PURE__ */ new Map();
   const unbarreledModulePathByFileName = /* @__PURE__ */ new Map();
-  for (const packageName of languageServicePluginOptions.namespaceImportPackages) {
+  const barreledModulePathByFileName = /* @__PURE__ */ new Map();
+  const packages = [
+    ...languageServicePluginOptions.namespaceImportPackages.map((packageName) => ({
+      packageName,
+      kind: "namespace"
+    })),
+    ...languageServicePluginOptions.barrelImportPackages.map((packageName) => ({
+      packageName,
+      kind: "barrel"
+    }))
+  ];
+  for (const { kind, packageName } of packages) {
     const barrelModule = ts.resolveModuleName(packageName, sourceFile.fileName, program.getCompilerOptions(), host);
     if (barrelModule.resolvedModule) {
       const barrelPath = barrelModule.resolvedModule.resolvedFileName;
@@ -3514,18 +3526,32 @@ var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(functi
               if (unbarreledModulePathResolved.resolvedModule) {
                 const unbarreledModulePath = unbarreledModulePathResolved.resolvedModule.resolvedFileName;
                 if (exportClause && ts.isNamespaceExport(exportClause) && ts.isIdentifier(exportClause.name)) {
-                  namespaceByFileName.set(unbarreledModulePath, exportClause.name.text);
-                  const existingUnbarreledModulePath = unbarreledModulePathByFileName.get(barrelSource.fileName) || [];
-                  existingUnbarreledModulePath.push([exportClause.name.text, unbarreledModulePath]);
-                  unbarreledModulePathByFileName.set(barrelSource.fileName, existingUnbarreledModulePath);
+                  if (kind === "namespace") {
+                    namespaceByFileName.set(unbarreledModulePath, exportClause.name.text);
+                    const existingUnbarreledModulePath = unbarreledModulePathByFileName.get(barrelSource.fileName) || [];
+                    existingUnbarreledModulePath.push({
+                      fileName: unbarreledModulePath,
+                      exportName: exportClause.name.text
+                    });
+                    unbarreledModulePathByFileName.set(barrelSource.fileName, existingUnbarreledModulePath);
+                  }
+                  if (kind === "barrel") {
+                    barreledModulePathByFileName.set(unbarreledModulePath, {
+                      fileName: barrelSource.fileName,
+                      exportName: exportClause.name.text,
+                      packageName
+                    });
+                  }
                 }
                 if (exportClause && ts.isNamedExports(exportClause)) {
                   for (const element of exportClause.elements) {
                     if (!ts.isIdentifier(element.name)) continue;
                     const methodName = element.name.text;
-                    const excludedMethods = excludedByFileName.get(methodName) || [];
-                    excludedMethods.push(unbarreledModulePath);
-                    excludedByFileName.set(methodName, excludedMethods);
+                    if (kind === "namespace") {
+                      const excludedMethods = excludedByFileName.get(methodName) || [];
+                      excludedMethods.push(unbarreledModulePath);
+                      excludedByFileName.set(methodName, excludedMethods);
+                    }
                   }
                 }
               }
@@ -3538,141 +3564,252 @@ var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(functi
   return {
     getImportNamespaceByFileName: (fileName) => namespaceByFileName.get(fileName),
     isExcludedFromNamespaceImport: (fileName, exportName) => (excludedByFileName.get(exportName) || []).includes(fileName),
-    getUnbarreledModulePath: (fileName, exportName) => unbarreledModulePathByFileName.get(fileName)?.find(([name]) => name === exportName)?.[1]
+    getUnbarreledModulePath: (fileName, exportName) => unbarreledModulePathByFileName.get(fileName)?.find((_) => _.exportName === exportName)?.fileName,
+    getBarreledModulePath: (fileName) => barreledModulePathByFileName.get(fileName)
   };
 });
-var appendEffectCompletionEntryData = fn("collectNamespaceImports")(
-  function* (sourceFile, applicableCompletions) {
+var appendEffectCompletionEntryData = fn("appendEffectCompletionEntryData")(
+  function* (_sourceFile, applicableCompletions) {
     const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
-    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return applicableCompletions;
-    const packagesMetadata = importablePackagesMetadataCache.get(sourceFile.fileName) || (yield* makeImportablePackagesMetadata(sourceFile));
-    importablePackagesMetadataCache.set(sourceFile.fileName, packagesMetadata);
+    if (languageServicePluginOptions.namespaceImportPackages.length === 0 && languageServicePluginOptions.barrelImportPackages.length === 0) return applicableCompletions;
     if (applicableCompletions) {
       return {
         ...applicableCompletions,
-        entries: applicableCompletions.entries.map((entry) => {
-          if (entry.data && entry.data.fileName && !entry.insertText && !entry.filterText && entry.data.exportName && entry.data.moduleSpecifier) {
-            const isExcluded = packagesMetadata.isExcludedFromNamespaceImport(
-              entry.data.fileName,
-              entry.data.exportName
-            );
-            if (isExcluded) return entry;
-            const unbarreledModulePath = packagesMetadata.getUnbarreledModulePath(
-              entry.data.fileName,
-              entry.data.exportName
-            );
-            const namespaceName = packagesMetadata.getImportNamespaceByFileName(
-              unbarreledModulePath || entry.data.fileName
-            );
-            if (namespaceName) {
-              return {
-                ...entry,
-                // insertText: unbarreledModulePath ? namespaceName : namespaceName + "." + entry.name,
-                // filterText: entry.name,
-                data: {
-                  ...entry.data,
-                  effectNamespaceName: namespaceName,
-                  effectUnbarreledModulePath: unbarreledModulePath || "",
-                  effectReplaceSpan: entry.replacementSpan || applicableCompletions.optionalReplacementSpan
-                }
-              };
+        entries: applicableCompletions.entries.map(
+          (entry) => entry.data ? {
+            ...entry,
+            data: {
+              ...entry.data,
+              effectReplaceSpan: entry.replacementSpan || applicableCompletions.optionalReplacementSpan
             }
-          }
-          return entry;
-        })
+          } : entry
+        )
       };
     }
     return applicableCompletions;
   }
 );
+var isAutoImportOnlyCodeActions = fn("isAutoImportOnlyCodeActions")(
+  function* (sourceFile, codeActions, exportName) {
+    const ts = yield* service(TypeScriptApi);
+    if (!codeActions) return;
+    if (codeActions.length !== 1) return;
+    const action = codeActions[0];
+    const changes = action.changes;
+    if (changes.length !== 1) return;
+    const fileTextChanges = action.changes[0];
+    if (fileTextChanges.fileName !== sourceFile.fileName) return;
+    const textChanges = fileTextChanges.textChanges;
+    if (textChanges.length !== 1) return;
+    const change = textChanges[0];
+    if (change.newText.trim().toLowerCase().startsWith("import") && change.newText.indexOf(exportName) > -1) {
+      return {
+        type: "create"
+      };
+    }
+    if (change.newText.indexOf(exportName) > -1) {
+      const ancestorNodes = yield* getAncestorNodesInRange(sourceFile, {
+        pos: change.span.start,
+        end: change.span.start
+      });
+      const importNodes = ancestorNodes.filter((node) => ts.isImportDeclaration(node));
+      if (importNodes.length > 0) {
+        return {
+          type: "update"
+        };
+      }
+    }
+  }
+);
+var getImportFromNamespaceCodeActions = fn("getImportFromNamespaceCodeActions")(function* (formatOptions, preferences, languageServiceHost, sourceFile, effectReplaceSpan, effectNamespaceName, effectUnbarreledModulePath, newModuleSpecifier) {
+  const ts = yield* service(TypeScriptApi);
+  const formatContext = ts.formatting.getFormatContext(
+    formatOptions || {},
+    languageServiceHost
+  );
+  const changes = ts.textChanges.ChangeTracker.with(
+    {
+      formatContext,
+      host: languageServiceHost,
+      preferences: preferences || {}
+    },
+    (changeTracker) => {
+      ts.insertImports(
+        changeTracker,
+        sourceFile,
+        ts.factory.createImportDeclaration(
+          void 0,
+          ts.factory.createImportClause(
+            false,
+            void 0,
+            ts.factory.createNamespaceImport(ts.factory.createIdentifier(effectNamespaceName))
+          ),
+          ts.factory.createStringLiteral(newModuleSpecifier)
+        ),
+        true,
+        preferences || {}
+      );
+      if (!effectUnbarreledModulePath) {
+        changeTracker.insertText(
+          sourceFile,
+          effectReplaceSpan.start,
+          effectNamespaceName + "."
+        );
+      }
+    }
+  );
+  return [
+    {
+      description: "Import * as " + effectNamespaceName + " from " + newModuleSpecifier,
+      changes
+    }
+  ];
+});
+var getImportFromBarrelCodeActions = fn("getImportFromBarrelCodeActions")(function* (formatOptions, preferences, languageServiceHost, sourceFile, effectReplaceSpan, newModuleSpecifier, barrelExportName) {
+  const ts = yield* service(TypeScriptApi);
+  const formatContext = ts.formatting.getFormatContext(
+    formatOptions || {},
+    languageServiceHost
+  );
+  const changes = ts.textChanges.ChangeTracker.with(
+    {
+      formatContext,
+      host: languageServiceHost,
+      preferences: preferences || {}
+    },
+    (changeTracker) => {
+      let foundImportDeclaration = false;
+      for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement)) {
+          const moduleSpecifier = statement.moduleSpecifier;
+          if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === newModuleSpecifier) {
+            const importClause = statement.importClause;
+            if (importClause && importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
+              const namedImports = importClause.namedBindings;
+              changeTracker.replaceNode(
+                sourceFile,
+                namedImports,
+                ts.factory.createNamedImports(
+                  namedImports.elements.concat([
+                    ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(barrelExportName))
+                  ])
+                )
+              );
+              foundImportDeclaration = true;
+              break;
+            }
+          }
+        }
+      }
+      if (!foundImportDeclaration) {
+        ts.insertImports(
+          changeTracker,
+          sourceFile,
+          ts.factory.createImportDeclaration(
+            void 0,
+            ts.factory.createImportClause(
+              false,
+              void 0,
+              ts.factory.createNamedImports(
+                [
+                  ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(barrelExportName))
+                ]
+              )
+            ),
+            ts.factory.createStringLiteral(newModuleSpecifier)
+          ),
+          true,
+          preferences || {}
+        );
+      }
+      changeTracker.insertText(
+        sourceFile,
+        effectReplaceSpan.start,
+        barrelExportName + "."
+      );
+    }
+  );
+  return [
+    {
+      description: "Import { " + barrelExportName + " } from " + newModuleSpecifier,
+      changes
+    }
+  ];
+});
 var postprocessCompletionEntryDetails = fn("postprocessCompletionEntryDetails")(
   function* (sourceFile, data, applicableCompletionEntryDetails, formatOptions, preferences, languageServiceHost) {
     const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
-    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return applicableCompletionEntryDetails;
+    if (languageServicePluginOptions.namespaceImportPackages.length === 0 && languageServicePluginOptions.barrelImportPackages.length === 0) return applicableCompletionEntryDetails;
     const ts = yield* service(TypeScriptApi);
     const program = yield* service(TypeScriptProgram);
     const getModuleSpecifier = makeGetModuleSpecifier(ts);
     if (!getModuleSpecifier) return applicableCompletionEntryDetails;
     if (!applicableCompletionEntryDetails) return applicableCompletionEntryDetails;
     if (!data) return applicableCompletionEntryDetails;
-    if (!("effectNamespaceName" in data && "effectUnbarreledModulePath" in data && "effectReplaceSpan" in data)) {
-      return applicableCompletionEntryDetails;
-    }
+    const { exportName, fileName, moduleSpecifier } = data;
+    if (!fileName) return applicableCompletionEntryDetails;
+    if (!exportName) return applicableCompletionEntryDetails;
+    if (!moduleSpecifier) return applicableCompletionEntryDetails;
+    if (!("effectReplaceSpan" in data)) return applicableCompletionEntryDetails;
     const effectReplaceSpan = data.effectReplaceSpan;
-    const codeActions = applicableCompletionEntryDetails.codeActions;
-    if (codeActions && codeActions.length === 1) {
-      const action = codeActions[0];
-      if (action.changes.length === 1) {
-        const fileTextChanges = action.changes[0];
-        if (fileTextChanges.fileName === sourceFile.fileName && fileTextChanges.textChanges.length === 1) {
-          const change = fileTextChanges.textChanges[0];
-          let hasImportActions = false;
-          if (change.newText.trim().toLowerCase().startsWith("import") && change.newText.indexOf(data.exportName) > -1) {
-            hasImportActions = true;
-          }
-          if (!hasImportActions && change.newText.indexOf(data.exportName) > -1) {
-            const ancestorNodes = yield* getAncestorNodesInRange(sourceFile, {
-              pos: change.span.start,
-              end: change.span.start
-            });
-            const importNodes = ancestorNodes.filter((node) => ts.isImportDeclaration(node));
-            hasImportActions = importNodes.length > 0;
-          }
-          if (!hasImportActions) return applicableCompletionEntryDetails;
-          const formatContext = ts.formatting.getFormatContext(
-            formatOptions || {},
-            languageServiceHost
-          );
-          const changes = ts.textChanges.ChangeTracker.with(
-            {
-              formatContext,
-              host: languageServiceHost,
-              preferences: preferences || {}
-            },
-            (changeTracker) => {
-              const isBarrelRedirect = String(data.effectUnbarreledModulePath).length > 0;
-              const moduleSpecifier = isBarrelRedirect ? getModuleSpecifier(
-                program.getCompilerOptions(),
-                sourceFile,
-                sourceFile.fileName,
-                String(data.effectUnbarreledModulePath),
-                program
-              ) : String(data.moduleSpecifier);
-              ts.insertImports(
-                changeTracker,
-                sourceFile,
-                ts.factory.createImportDeclaration(
-                  void 0,
-                  ts.factory.createImportClause(
-                    false,
-                    void 0,
-                    ts.factory.createNamespaceImport(ts.factory.createIdentifier(String(data.effectNamespaceName)))
-                  ),
-                  ts.factory.createStringLiteral(moduleSpecifier)
-                ),
-                true,
-                preferences || {}
-              );
-              if (!isBarrelRedirect) {
-                changeTracker.insertText(
-                  sourceFile,
-                  effectReplaceSpan.start,
-                  String(data.effectNamespaceName) + "."
-                );
-              }
-            }
-          );
-          return {
-            ...applicableCompletionEntryDetails,
-            codeActions: [
-              {
-                description: "Import * as " + data.effectNamespaceName + " from " + data.effectUnbarreledModulePath,
-                changes
-              }
-            ]
-          };
-        }
-      }
+    const result = yield* isAutoImportOnlyCodeActions(
+      sourceFile,
+      applicableCompletionEntryDetails.codeActions,
+      exportName
+    );
+    if (!result) return applicableCompletionEntryDetails;
+    const packagesMetadata = importablePackagesMetadataCache.get(sourceFile.fileName) || (yield* makeImportablePackagesMetadata(sourceFile));
+    importablePackagesMetadataCache.set(sourceFile.fileName, packagesMetadata);
+    const isExcluded = packagesMetadata.isExcludedFromNamespaceImport(
+      fileName,
+      exportName
+    );
+    if (isExcluded) return applicableCompletionEntryDetails;
+    const asBarrelImport = packagesMetadata.getBarreledModulePath(fileName);
+    if (asBarrelImport) {
+      const codeActions = yield* getImportFromBarrelCodeActions(
+        formatOptions,
+        preferences,
+        languageServiceHost,
+        sourceFile,
+        effectReplaceSpan,
+        asBarrelImport.packageName,
+        asBarrelImport.exportName
+      );
+      return {
+        ...applicableCompletionEntryDetails,
+        codeActions
+      };
+    }
+    const effectUnbarreledModulePath = packagesMetadata.getUnbarreledModulePath(
+      fileName,
+      exportName
+    );
+    const asNamespaceImport = packagesMetadata.getImportNamespaceByFileName(
+      effectUnbarreledModulePath || fileName
+    );
+    if (asNamespaceImport) {
+      const newModuleSpecifier = effectUnbarreledModulePath ? getModuleSpecifier(
+        program.getCompilerOptions(),
+        sourceFile,
+        sourceFile.fileName,
+        String(effectUnbarreledModulePath || fileName),
+        program
+      ) : moduleSpecifier;
+      const codeActions = yield* getImportFromNamespaceCodeActions(
+        formatOptions,
+        preferences,
+        languageServiceHost,
+        sourceFile,
+        effectReplaceSpan,
+        asNamespaceImport,
+        effectUnbarreledModulePath,
+        newModuleSpecifier
+      );
+      return {
+        ...applicableCompletionEntryDetails,
+        codeActions
+      };
     }
     return applicableCompletionEntryDetails;
   }