@effect/language-service 0.22.2 → 0.22.3

package/index.js

@@ -3494,6 +3494,7 @@ var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(functi
   const namespaceByFileName = /* @__PURE__ */ new Map();
   const excludedByFileName = /* @__PURE__ */ new Map();
   const unbarreledModulePathByFileName = /* @__PURE__ */ new Map();
+  const barreledModulePathByFileName = /* @__PURE__ */ new Map();
   for (const packageName of languageServicePluginOptions.namespaceImportPackages) {
     const barrelModule = ts.resolveModuleName(packageName, sourceFile.fileName, program.getCompilerOptions(), host);
     if (barrelModule.resolvedModule) {
@@ -3516,8 +3517,15 @@ var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(functi
                 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]);
+                  existingUnbarreledModulePath.push({
+                    fileName: unbarreledModulePath,
+                    exportName: exportClause.name.text
+                  });
                   unbarreledModulePathByFileName.set(barrelSource.fileName, existingUnbarreledModulePath);
+                  barreledModulePathByFileName.set(unbarreledModulePath, {
+                    fileName: barrelSource.fileName,
+                    exportName: exportClause.name.text
+                  });
                 }
                 if (exportClause && ts.isNamedExports(exportClause)) {
                   for (const element of exportClause.elements) {
@@ -3538,48 +3546,26 @@ 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 (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;
@@ -3589,92 +3575,117 @@ 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"
+            };
+          }
+        }
+      }
+    );
     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) + "."
-                );
-              }
-            }
+    const result = yield* isAutoImportOnlyCodeActions(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 effectUnbarreledModulePath = packagesMetadata.getUnbarreledModulePath(
+      fileName,
+      exportName
+    );
+    const effectNamespaceName = 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 " + data.effectNamespaceName + " from " + data.effectUnbarreledModulePath,
-                changes
-              }
-            ]
-          };
         }
       }
-    }
-    return applicableCompletionEntryDetails;
+    );
+    return {
+      ...applicableCompletionEntryDetails,
+      codeActions: [
+        {
+          description: "Import * as " + effectNamespaceName + " from " + newModuleSpecifier,
+          changes
+        }
+      ]
+    };
   }
 );