@effect/language-service 0.27.2 → 0.28.1

package/package.json

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

package/transform.js

@@ -1158,13 +1158,17 @@ function parsePackageContentNameAndVersionFromScope(v) {
     ...hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) ? packageJsonContent.peerDependencies : {},
     ...hasProperty(packageJsonContent, "devDependencies") && isObject(packageJsonContent.devDependencies) ? packageJsonContent.devDependencies : {}
   });
+  const exportsKeys = Object.keys(
+    hasProperty(packageJsonContent, "exports") && isObject(packageJsonContent.exports) ? packageJsonContent.exports : {}
+  );
   return {
     name: name.toLowerCase(),
     version: version.toLowerCase(),
     hasEffectInPeerDependencies,
     contents: packageJsonContent,
     packageDirectory: packageJsonScope.packageDirectory,
-    referencedPackages
+    referencedPackages,
+    exportsKeys
   };
 }
 var resolveModulePattern = fn("resolveModulePattern")(
@@ -2538,6 +2542,47 @@ function make2(ts, typeChecker) {
     "TypeParser.scopeType",
     (type) => type
   );
+  const promiseLike = cachedBy(
+    function(type, atLocation) {
+      const thenProperty = type.getProperty("then");
+      if (!thenProperty) return typeParserIssue("not a promise - missing then property", type, atLocation);
+      const thenType = typeChecker.getTypeOfSymbolAtLocation(thenProperty, atLocation);
+      if (!thenType) return typeParserIssue("not a promise - missing then property", type, atLocation);
+      for (const callSignature of thenType.getCallSignatures()) {
+        const parameter = callSignature.parameters[0];
+        if (!parameter) continue;
+        const parameterType = callSignature.getTypeParameterAtPosition(0);
+        if (!parameterType) continue;
+        let callbackCallSignatures = [];
+        let toTest = [parameterType];
+        while (toTest.length > 0) {
+          const type2 = toTest.shift();
+          if (!type2) continue;
+          const callSignatures = type2.getCallSignatures();
+          callbackCallSignatures = callbackCallSignatures.concat(callSignatures);
+          if (type2.isUnion()) {
+            toTest = toTest.concat(type2.types);
+          }
+        }
+        for (const callableType of callbackCallSignatures) {
+          const callbackParameter = callableType.parameters[0];
+          if (!callbackParameter) {
+            continue;
+          }
+          const callbackParameterType = callableType.getTypeParameterAtPosition(0);
+          if (!callbackParameterType) {
+            continue;
+          }
+          return succeed({
+            type: callbackParameterType
+          });
+        }
+      }
+      return typeParserIssue("not a promise", type, atLocation);
+    },
+    "TypeParser.promiseLike",
+    (type) => type
+  );
   return {
     effectType,
     strictEffectType,
@@ -2553,7 +2598,8 @@ function make2(ts, typeChecker) {
     contextTag,
     pipeableType,
     pipeCall,
-    scopeType
+    scopeType,
+    promiseLike
   };
 }