@effect/language-service 0.23.3 → 0.23.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/language-service",
-  "version": "0.23.3",
+  "version": "0.23.5",
   "description": "A Language-Service Plugin to Refactor and Diagnostic effect-ts projects",
   "main": "index.cjs",
   "repository": {

package/transform.js

@@ -734,6 +734,9 @@ var isRight2 = isRight;
 var map = /* @__PURE__ */ dual(2, (self, f) => isRight2(self) ? right2(f(self.right)) : left2(self.left));
 var getOrElse = /* @__PURE__ */ dual(2, (self, onLeft) => isLeft2(self) ? onLeft(self.left) : self.right);
 
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/array.js
+var isNonEmptyArray = (self) => self.length > 0;
+
 // node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Order.js
 var make = (compare) => (self, that) => self === that ? 0 : compare(self, that);
 
@@ -754,6 +757,19 @@ var fromIterable = (collection) => Array.isArray(collection) ? collection : Arra
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
 var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
 var isArray = Array.isArray;
+var isEmptyArray = (self) => self.length === 0;
+var isEmptyReadonlyArray = isEmptyArray;
+var isNonEmptyReadonlyArray = isNonEmptyArray;
+var isOutOfBounds = (i, as) => i < 0 || i >= as.length;
+var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
+  const i = Math.floor(index);
+  if (isOutOfBounds(i, self)) {
+    throw new Error(`Index ${i} out of bounds`);
+  }
+  return self[i];
+});
+var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
+var tailNonEmpty = (self) => self.slice(1);
 var sort = /* @__PURE__ */ dual(2, (self, O) => {
   const out = Array.from(self);
   out.sort(O);
@@ -775,6 +791,20 @@ var intersectionWith = (isEquivalent) => {
 var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
 var empty = () => [];
 var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var flatMap = /* @__PURE__ */ dual(2, (self, f) => {
+  if (isEmptyReadonlyArray(self)) {
+    return [];
+  }
+  const out = [];
+  for (let i = 0; i < self.length; i++) {
+    const inner = f(self[i], i);
+    for (let j = 0; j < inner.length; j++) {
+      out.push(inner[j]);
+    }
+  }
+  return out;
+});
+var flatten = /* @__PURE__ */ flatMap(identity);
 var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   const as = fromIterable(self);
   const out = [];
@@ -785,6 +815,21 @@ var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   }
   return out;
 });
+var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
+  const input = fromIterable(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const out = [headNonEmpty(input)];
+    const rest = tailNonEmpty(input);
+    for (const r of rest) {
+      if (out.every((a) => !isEquivalent(r, a))) {
+        out.push(r);
+      }
+    }
+    return out;
+  }
+  return [];
+});
+var dedupe = (self) => dedupeWith(self, equivalence());
 
 // src/core/Nano.ts
 function makeInternalSuccess(value) {
@@ -861,7 +906,7 @@ var sync = (value) => {
   };
   return nano;
 };
-var flatMap = dual(2, (fa, f) => make2((ctx) => {
+var flatMap2 = dual(2, (fa, f) => make2((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
   return f(result.value).run(ctx);
@@ -1010,14 +1055,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,
+      map2((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;
@@ -1187,7 +1261,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       const fixByDisableNextLine = (_) => ({
         fixName: rule.name + "_skipNextLine",
         description: "Disable " + rule.name + " for this line",
-        apply: flatMap(
+        apply: flatMap2(
           service(ChangeTracker),
           (changeTracker) => sync(() => {
             const disableAtNode = findParentStatementForDisableNextLine(_.node);
@@ -1204,7 +1278,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       const fixByDisableEntireFile = {
         fixName: rule.name + "_skipFile",
         description: "Disable " + rule.name + " for this entire file",
-        apply: flatMap(
+        apply: flatMap2(
           service(ChangeTracker),
           (changeTracker) => sync(
             () => changeTracker.insertText(
@@ -2500,7 +2574,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;
@@ -2513,12 +2594,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));
@@ -2541,7 +2624,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) => {
@@ -2556,16 +2647,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(
@@ -2573,7 +2671,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)
               );
@@ -2694,7 +2792,7 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
       for (const [type, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type, node),
-          flatMap(
+          flatMap2(
             ({ Service }) => pipe(
               parseLeakedRequirements(Service, node),
               map3((requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeOrder)))
@@ -2722,7 +2820,7 @@ var missingEffectContext = createDiagnostic({
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      flatMap(
+      flatMap2(
         ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
           realEffect.R,
           expectedEffect.R
@@ -2770,7 +2868,7 @@ var missingEffectError = createDiagnostic({
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      flatMap(
+      flatMap2(
         ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
           realEffect.E,
           expectedEffect.E