@effect/language-service 0.38.1 → 0.38.3

package/package.json

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

package/transform.js

@@ -1058,7 +1058,7 @@ var match = (fa, opts) => {
 var orElse2 = (f) => (fa) => {
   const nano = Object.create(MatchProto);
   nano[args] = fa;
-  nano[contE] = f;
+  nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : f(_);
   return nano;
 };
 var firstSuccessOf = (arr) => arr.slice(1).reduce((arr2, fa) => orElse2(() => fa)(arr2), arr[0]);
@@ -1229,10 +1229,10 @@ function makeTypeScriptUtils(ts) {
     if (!hasProperty(packageJsonScope.contents, "packageJsonContent")) return;
     const packageJsonContent = packageJsonScope.contents.packageJsonContent;
     if (!hasProperty(packageJsonContent, "name")) return;
-    if (!hasProperty(packageJsonContent, "version")) return;
     if (!hasProperty(packageJsonScope, "packageDirectory")) return;
     if (!isString(packageJsonScope.packageDirectory)) return;
-    const { name, version } = packageJsonContent;
+    const { name } = packageJsonContent;
+    const version = hasProperty(packageJsonScope, "version") ? packageJsonScope.version : "";
     if (!isString(name)) return;
     if (!isString(version)) return;
     const hasEffectInPeerDependencies = hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) && hasProperty(packageJsonContent.peerDependencies, "effect");
@@ -1254,9 +1254,20 @@ function makeTypeScriptUtils(ts) {
       exportsKeys
     };
   }
-  function resolveModulePattern(sourceFile, pattern) {
+  function resolveModulePattern(program, sourceFile, pattern) {
     if (pattern.indexOf("*") === -1) return [pattern.toLowerCase()];
-    const packageJsonScope = parsePackageContentNameAndVersionFromScope(sourceFile);
+    let packageJsonScope = parsePackageContentNameAndVersionFromScope(sourceFile);
+    if (!packageJsonScope && hasProperty(ts, "getPackageScopeForPath") && isFunction2(ts.getPackageScopeForPath) && hasProperty(ts, "getTemporaryModuleResolutionState") && isFunction2(ts.getTemporaryModuleResolutionState) && hasProperty(ts, "getPackageScopeForPath") && isFunction2(ts.getPackageScopeForPath)) {
+      const temporaryModuleResolutionState = ts.getTemporaryModuleResolutionState(
+        void 0,
+        program,
+        program.getCompilerOptions()
+      );
+      packageJsonScope = parsePackageContentNameAndVersionFromScope({
+        ...sourceFile,
+        packageJsonScope: ts.getPackageScopeForPath(sourceFile.fileName, temporaryModuleResolutionState)
+      });
+    }
     const referencedPackages = [];
     for (const statement of sourceFile.statements) {
       if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
@@ -1729,18 +1740,21 @@ var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refacto
   const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
   const effectRefactors = [];
   for (const refactor of refactors) {
-    const result = yield* option(refactor.apply(sourceFile, textRange));
-    if (isSome2(result)) {
-      effectRefactors.push({
-        name: refactorNameToFullyQualifiedName(refactor.name),
-        description: refactor.description,
-        actions: [{
+    yield* pipe(
+      refactor.apply(sourceFile, textRange),
+      map4(
+        (result) => effectRefactors.push({
           name: refactorNameToFullyQualifiedName(refactor.name),
-          description: result.value.description,
-          kind: result.value.kind
-        }]
-      });
-    }
+          description: refactor.description,
+          actions: [{
+            name: refactorNameToFullyQualifiedName(refactor.name),
+            description: result.description,
+            kind: result.kind
+          }]
+        })
+      ),
+      ignore
+    );
   }
   return effectRefactors;
 });
@@ -3140,6 +3154,55 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.extendsContextTag",
     (atLocation) => atLocation
   );
+  const extendsEffectTag = cachedBy(
+    fn("TypeParser.extendsEffectTag")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts.isExpressionWithTypeArguments(typeX)) {
+            const wholeCall = typeX.expression;
+            if (ts.isCallExpression(wholeCall)) {
+              const effectTagCall = wholeCall.expression;
+              if (ts.isCallExpression(effectTagCall) && wholeCall.typeArguments && wholeCall.typeArguments.length > 0) {
+                const effectTagIdentifier = effectTagCall.expression;
+                const selfTypeNode = wholeCall.typeArguments[0];
+                if (ts.isPropertyAccessExpression(effectTagIdentifier) && ts.isIdentifier(effectTagIdentifier.name) && ts.idText(effectTagIdentifier.name) === "Tag") {
+                  const parsedEffectModule = yield* pipe(
+                    importedEffectModule(effectTagIdentifier.expression),
+                    option
+                  );
+                  if (isSome2(parsedEffectModule)) {
+                    const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+                    if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+                    const type = typeChecker.getTypeOfSymbol(classSym);
+                    const tagType = yield* contextTag(type, atLocation);
+                    return {
+                      className: atLocation.name,
+                      selfTypeNode,
+                      keyStringLiteral: ts.isStringLiteral(effectTagCall.arguments[0]) ? effectTagCall.arguments[0] : void 0,
+                      args: effectTagCall.arguments,
+                      Identifier: tagType.Identifier,
+                      Service: tagType.Service,
+                      Tag: parsedEffectModule.value
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Effect.Tag", void 0, atLocation);
+    }),
+    "TypeParser.extendsEffectTag",
+    (atLocation) => atLocation
+  );
   const extendsEffectService = cachedBy(
     fn("TypeParser.extendsEffectService")(function* (atLocation) {
       if (!atLocation.name) {
@@ -3222,6 +3285,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
     pipeCall,
     scopeType,
     promiseLike,
+    extendsEffectTag,
     extendsEffectService,
     extendsContextTag,
     extendsSchemaClass,
@@ -3501,7 +3565,7 @@ var importFromBarrel = createDiagnostic({
     const program = yield* service(TypeScriptProgram);
     const packageNamesToCheck = flatten(
       languageServicePluginOptions.namespaceImportPackages.map(
-        (packageName) => tsUtils.resolveModulePattern(sourceFile, packageName)
+        (packageName) => tsUtils.resolveModulePattern(program, sourceFile, packageName)
       )
     );
     const isImportedFromBarrelExport = (element) => {
@@ -4464,6 +4528,7 @@ var parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
   if (!ts.isClassDeclaration(node)) return yield* fail("not a class declaration");
   const { Service, accessors: accessors2, className } = yield* pipe(
     typeParser.extendsEffectService(node),
+    orElse2(() => map4(typeParser.extendsEffectTag(node), (_) => ({ accessors: true, ..._ }))),
     orElse2(() => fail("not a class extending Effect.Service call"))
   );
   if (accessors2 !== true) return yield* fail("accessors are not enabled in the Effect.Service call");