@effect/language-service 0.23.3 → 0.23.5

package/README.md

@@ -87,7 +87,7 @@ Few options can be provided alongside the initialization of the Language Service
         "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: [])
         "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: [])
+        "namespaceImportPackages": [] // package names that should be preferred as imported with namespace imports e.g. ["effect", "@effect/*"] (default: [])
       }
     ]
   }

package/index.js

@@ -831,6 +831,7 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   }
   return [];
 });
+var dedupe = (self) => dedupeWith(self, equivalence());
 
 // src/core/Nano.ts
 function makeInternalSuccess(value) {
@@ -1029,14 +1030,43 @@ function parsePackageContentNameAndVersionFromScope(v) {
   if (!isString(name)) return;
   if (!isString(version)) return;
   const hasEffectInPeerDependencies = hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) && hasProperty(packageJsonContent.peerDependencies, "effect");
+  const referencedPackages = Object.keys({
+    ...hasProperty(packageJsonContent, "dependencies") && isObject(packageJsonContent.dependencies) ? packageJsonContent.dependencies : {},
+    ...hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) ? packageJsonContent.peerDependencies : {},
+    ...hasProperty(packageJsonContent, "devDependencies") && isObject(packageJsonContent.devDependencies) ? packageJsonContent.devDependencies : {}
+  });
   return {
     name: name.toLowerCase(),
     version: version.toLowerCase(),
     hasEffectInPeerDependencies,
     contents: packageJsonContent,
-    packageDirectory: packageJsonScope.packageDirectory
+    packageDirectory: packageJsonScope.packageDirectory,
+    referencedPackages
   };
 }
+var resolveModulePattern = fn("resolveModulePattern")(
+  function* (sourceFile, pattern) {
+    if (pattern.indexOf("*") === -1) return [pattern.toLowerCase()];
+    const ts = yield* service(TypeScriptApi);
+    const packageJsonScope = parsePackageContentNameAndVersionFromScope(sourceFile);
+    const referencedPackages = [];
+    for (const statement of sourceFile.statements) {
+      if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+        const moduleSpecifier = statement.moduleSpecifier.text.toLowerCase();
+        const packageName = moduleSpecifier.startsWith("@") ? moduleSpecifier.split("/", 2).join("/") : moduleSpecifier.split("/", 1).join("/");
+        referencedPackages.push(packageName);
+      }
+    }
+    return pipe(
+      referencedPackages.concat(packageJsonScope?.referencedPackages || []),
+      dedupe,
+      map3((packageName) => packageName.toLowerCase()),
+      filter(
+        (packageName) => pattern.endsWith("*") && packageName.startsWith(pattern.toLowerCase().substring(0, pattern.length - 1))
+      )
+    );
+  }
+);
 function makeGetModuleSpecifier(ts) {
   if (!(hasProperty(ts, "moduleSpecifiers") && hasProperty(ts.moduleSpecifiers, "getModuleSpecifier") && isFunction2(ts.moduleSpecifiers.getModuleSpecifier))) return;
   const _internal = ts.moduleSpecifiers.getModuleSpecifier;
@@ -2631,7 +2661,14 @@ var importFromBarrel = createDiagnostic({
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const program = yield* service(TypeScriptProgram);
-    const isImportedFromBarrelExport = (element, languageServicePluginOptions2) => {
+    const packageNamesToCheck = flatten(
+      yield* all(
+        ...languageServicePluginOptions.namespaceImportPackages.map(
+          (packageName) => resolveModulePattern(sourceFile, packageName)
+        )
+      )
+    );
+    const isImportedFromBarrelExport = (element) => {
       const getModuleSpecifier = makeGetModuleSpecifier(ts);
       const resolveExternalModuleName = makeResolveExternalModuleName(typeChecker);
       if (!(getModuleSpecifier && resolveExternalModuleName)) return;
@@ -2644,12 +2681,14 @@ var importFromBarrel = createDiagnostic({
       if (!namedBindings) return;
       if (!ts.isNamedImports(namedBindings)) return;
       const barrelModuleName = importDeclaration.moduleSpecifier.text;
-      if (languageServicePluginOptions2.namespaceImportPackages.indexOf(barrelModuleName.toLowerCase()) === -1) return;
+      if (packageNamesToCheck.indexOf(barrelModuleName.toLowerCase()) === -1) return;
       const moduleSymbol = resolveExternalModuleName(importDeclaration.moduleSpecifier);
       if (!moduleSymbol) return;
       if (!moduleSymbol.exports) return;
       const sourceFile2 = importDeclaration.getSourceFile();
       const nodeForSymbol = element.propertyName || element.name;
+      const aliasSymbol = element.name || element.propertyName;
+      const aliasedName = aliasSymbol.text;
       if (!ts.isIdentifier(nodeForSymbol)) return;
       const importedName = nodeForSymbol.text;
       const reexportedSymbol = moduleSymbol.exports.get(ts.escapeLeadingUnderscores(importedName));
@@ -2672,7 +2711,15 @@ var importFromBarrel = createDiagnostic({
         program
       );
       if (unbarrelledFileName.toLowerCase().indexOf(barrelModuleName.toLowerCase() + "/") === -1) return;
-      return { unbarrelledFileName, importedName, barrelModuleName, importClause, namedBindings, importDeclaration };
+      return {
+        unbarrelledFileName,
+        importedName,
+        barrelModuleName,
+        importClause,
+        namedBindings,
+        importDeclaration,
+        aliasedName
+      };
     };
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
@@ -2687,16 +2734,23 @@ var importFromBarrel = createDiagnostic({
         ts.forEachChild(node, appendNodeToVisit);
         continue;
       }
-      const result = isImportedFromBarrelExport(node, languageServicePluginOptions);
+      const result = isImportedFromBarrelExport(node);
       if (!result) continue;
-      const { barrelModuleName, importClause, importDeclaration, importedName, namedBindings, unbarrelledFileName } = result;
+      const {
+        aliasedName,
+        barrelModuleName,
+        importClause,
+        importDeclaration,
+        namedBindings,
+        unbarrelledFileName
+      } = result;
       report({
         node,
         messageText: `Importing from barrel module ${barrelModuleName} is not allowed.`,
         fixes: [
           {
             fixName: "replaceWithUnbarrelledImport",
-            description: `Import * as ${importedName} from ${unbarrelledFileName}`,
+            description: `Import * as ${aliasedName} from ${unbarrelledFileName}`,
             apply: gen(function* () {
               const changeTracker = yield* service(ChangeTracker);
               const newImport = ts.factory.createImportDeclaration(
@@ -2704,7 +2758,7 @@ var importFromBarrel = createDiagnostic({
                 ts.factory.createImportClause(
                   importClause.isTypeOnly || node.isTypeOnly,
                   void 0,
-                  ts.factory.createNamespaceImport(ts.factory.createIdentifier(importedName))
+                  ts.factory.createNamespaceImport(ts.factory.createIdentifier(aliasedName))
                 ),
                 ts.factory.createStringLiteral(unbarrelledFileName)
               );
@@ -3498,69 +3552,71 @@ var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(functi
   const barreledModulePathByFileName = /* @__PURE__ */ new Map();
   const barreledFunctionPathByFileName = /* @__PURE__ */ new Map();
   const packages = [
-    ...languageServicePluginOptions.namespaceImportPackages.map((packageName) => ({
-      packageName,
+    ...languageServicePluginOptions.namespaceImportPackages.map((packagePattern) => ({
+      packagePattern,
       kind: "namespace"
     })),
-    ...languageServicePluginOptions.barrelImportPackages.map((packageName) => ({
-      packageName,
+    ...languageServicePluginOptions.barrelImportPackages.map((packagePattern) => ({
+      packagePattern,
       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;
-      const barrelSource = program.getSourceFile(barrelPath) || ts.createSourceFile(barrelPath, host.readFile(barrelPath) || "", sourceFile.languageVersion, true);
-      if (barrelSource) {
-        for (const statement of barrelSource.statements) {
-          if (ts.isExportDeclaration(statement)) {
-            const exportClause = statement.exportClause;
-            const moduleSpecifier = statement.moduleSpecifier;
-            if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
-              const unbarreledModulePathResolved = ts.resolveModuleName(
-                moduleSpecifier.text,
-                barrelSource.fileName,
-                program.getCompilerOptions(),
-                host
-              );
-              if (unbarreledModulePathResolved.resolvedModule) {
-                const unbarreledModulePath = unbarreledModulePathResolved.resolvedModule.resolvedFileName;
-                if (exportClause && ts.isNamespaceExport(exportClause) && ts.isIdentifier(exportClause.name)) {
-                  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;
+  for (const { kind, packagePattern } of packages) {
+    for (const packageName of yield* resolveModulePattern(sourceFile, packagePattern)) {
+      const barrelModule = ts.resolveModuleName(packageName, sourceFile.fileName, program.getCompilerOptions(), host);
+      if (barrelModule.resolvedModule) {
+        const barrelPath = barrelModule.resolvedModule.resolvedFileName;
+        const barrelSource = program.getSourceFile(barrelPath) || ts.createSourceFile(barrelPath, host.readFile(barrelPath) || "", sourceFile.languageVersion, true);
+        if (barrelSource) {
+          for (const statement of barrelSource.statements) {
+            if (ts.isExportDeclaration(statement)) {
+              const exportClause = statement.exportClause;
+              const moduleSpecifier = statement.moduleSpecifier;
+              if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+                const unbarreledModulePathResolved = ts.resolveModuleName(
+                  moduleSpecifier.text,
+                  barrelSource.fileName,
+                  program.getCompilerOptions(),
+                  host
+                );
+                if (unbarreledModulePathResolved.resolvedModule) {
+                  const unbarreledModulePath = unbarreledModulePathResolved.resolvedModule.resolvedFileName;
+                  if (exportClause && ts.isNamespaceExport(exportClause) && ts.isIdentifier(exportClause.name)) {
                     if (kind === "namespace") {
-                      const excludedMethods = excludedByFileName.get(methodName) || [];
-                      excludedMethods.push(unbarreledModulePath);
-                      excludedByFileName.set(methodName, excludedMethods);
+                      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") {
-                      const previousBarreledFunctionPath = barreledFunctionPathByFileName.get(unbarreledModulePath) || [];
-                      previousBarreledFunctionPath.push({
+                      barreledModulePathByFileName.set(unbarreledModulePath, {
                         fileName: barrelSource.fileName,
-                        exportName: methodName,
+                        exportName: exportClause.name.text,
                         packageName
                       });
-                      barreledFunctionPathByFileName.set(unbarreledModulePath, previousBarreledFunctionPath);
+                    }
+                  }
+                  if (exportClause && ts.isNamedExports(exportClause)) {
+                    for (const element of exportClause.elements) {
+                      if (!ts.isIdentifier(element.name)) continue;
+                      const methodName = element.name.text;
+                      if (kind === "namespace") {
+                        const excludedMethods = excludedByFileName.get(methodName) || [];
+                        excludedMethods.push(unbarreledModulePath);
+                        excludedByFileName.set(methodName, excludedMethods);
+                      }
+                      if (kind === "barrel") {
+                        const previousBarreledFunctionPath = barreledFunctionPathByFileName.get(unbarreledModulePath) || [];
+                        previousBarreledFunctionPath.push({
+                          fileName: barrelSource.fileName,
+                          exportName: methodName,
+                          packageName
+                        });
+                        barreledFunctionPathByFileName.set(unbarreledModulePath, previousBarreledFunctionPath);
+                      }
                     }
                   }
                 }