@effect/language-service 0.22.3 → 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);
@@ -3495,7 +3496,17 @@ var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(functi
   const excludedByFileName = /* @__PURE__ */ new Map();
   const unbarreledModulePathByFileName = /* @__PURE__ */ new Map();
   const barreledModulePathByFileName = /* @__PURE__ */ new Map();
-  for (const packageName of languageServicePluginOptions.namespaceImportPackages) {
+  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;
@@ -3515,25 +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({
-                    fileName: unbarreledModulePath,
-                    exportName: exportClause.name.text
-                  });
-                  unbarreledModulePathByFileName.set(barrelSource.fileName, existingUnbarreledModulePath);
-                  barreledModulePathByFileName.set(unbarreledModulePath, {
-                    fileName: barrelSource.fileName,
-                    exportName: exportClause.name.text
-                  });
+                  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);
+                    }
                   }
                 }
               }
@@ -3553,7 +3571,7 @@ var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(functi
 var appendEffectCompletionEntryData = fn("appendEffectCompletionEntryData")(
   function* (_sourceFile, applicableCompletions) {
     const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
-    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return applicableCompletions;
+    if (languageServicePluginOptions.namespaceImportPackages.length === 0 && languageServicePluginOptions.barrelImportPackages.length === 0) return applicableCompletions;
     if (applicableCompletions) {
       return {
         ...applicableCompletions,
@@ -3571,41 +3589,157 @@ var appendEffectCompletionEntryData = fn("appendEffectCompletionEntryData")(
     return applicableCompletions;
   }
 );
-var postprocessCompletionEntryDetails = fn("postprocessCompletionEntryDetails")(
-  function* (sourceFile, data, applicableCompletionEntryDetails, formatOptions, preferences, languageServiceHost) {
-    const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
-    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return applicableCompletionEntryDetails;
-    const isAutoImportOnlyCodeActions = fn("isAutoImportOnlyCodeActions")(
-      function* (codeActions, exportName2) {
-        if (!codeActions) return;
-        if (codeActions.length !== 1) return;
-        const action = codeActions[0];
-        const changes2 = action.changes;
-        if (changes2.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(exportName2) > -1) {
-          return {
-            type: "create"
-          };
-        }
-        if (change.newText.indexOf(exportName2) > -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 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 && languageServicePluginOptions.barrelImportPackages.length === 0) return applicableCompletionEntryDetails;
     const ts = yield* service(TypeScriptApi);
     const program = yield* service(TypeScriptProgram);
     const getModuleSpecifier = makeGetModuleSpecifier(ts);
@@ -3618,74 +3752,66 @@ var postprocessCompletionEntryDetails = fn("postprocessCompletionEntryDetails")(
     if (!moduleSpecifier) return applicableCompletionEntryDetails;
     if (!("effectReplaceSpan" in data)) return applicableCompletionEntryDetails;
     const effectReplaceSpan = data.effectReplaceSpan;
-    const result = yield* isAutoImportOnlyCodeActions(applicableCompletionEntryDetails.codeActions, exportName);
+    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 formatContext = ts.formatting.getFormatContext(
-      formatOptions || {},
-      languageServiceHost
-    );
     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 effectNamespaceName = packagesMetadata.getImportNamespaceByFileName(
+    const asNamespaceImport = packagesMetadata.getImportNamespaceByFileName(
       effectUnbarreledModulePath || fileName
     );
-    if (!effectNamespaceName) return applicableCompletionEntryDetails;
-    const newModuleSpecifier = effectUnbarreledModulePath ? getModuleSpecifier(
-      program.getCompilerOptions(),
-      sourceFile,
-      sourceFile.fileName,
-      String(effectUnbarreledModulePath || fileName),
-      program
-    ) : moduleSpecifier;
-    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 {
-      ...applicableCompletionEntryDetails,
-      codeActions: [
-        {
-          description: "Import * as " + effectNamespaceName + " from " + newModuleSpecifier,
-          changes
-        }
-      ]
-    };
+    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;
   }
 );