@effect/language-service 0.5.1 → 0.6.0

package/index.js

@@ -115,6 +115,7 @@ var globalValue = (id, compute) => {
 };
 
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Predicate.js
+var isBoolean = (input) => typeof input === "boolean";
 var isFunction2 = isFunction;
 var isRecordOrArray = (input) => typeof input === "object" && input !== null;
 var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
@@ -814,12 +815,14 @@ function effectGen(ts, typeChecker) {
     if (!ts.isPropertyAccessExpression(node.expression)) return yield* none2();
     const propertyAccess = node.expression;
     if (propertyAccess.name.text !== "gen") return yield* none2();
-    return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
-      map(() => ({
-        body: generatorFunction.body,
-        functionStar: generatorFunction.getFirstToken()
-      }))
-    );
+    const effectModule = yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression);
+    return {
+      node,
+      effectModule,
+      generatorFunction,
+      body: generatorFunction.body,
+      functionStar: generatorFunction.getFirstToken()
+    };
   });
 }
 function effectFnUntracedGen(ts, typeChecker) {
@@ -832,12 +835,14 @@ function effectFnUntracedGen(ts, typeChecker) {
     if (!ts.isPropertyAccessExpression(node.expression)) return yield* none2();
     const propertyAccess = node.expression;
     if (propertyAccess.name.text !== "fnUntraced") return yield* none2();
-    return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
-      map(() => ({
-        body: generatorFunction.body,
-        functionStar: generatorFunction.getFirstToken()
-      }))
-    );
+    const effectModule = yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression);
+    return {
+      node,
+      effectModule,
+      generatorFunction,
+      body: generatorFunction.body,
+      functionStar: generatorFunction.getFirstToken()
+    };
   });
 }
 function effectFnGen(ts, typeChecker) {
@@ -851,12 +856,14 @@ function effectFnGen(ts, typeChecker) {
     if (!ts.isPropertyAccessExpression(expressionToTest)) return yield* none2();
     const propertyAccess = expressionToTest;
     if (propertyAccess.name.text !== "fn") return yield* none2();
-    return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
-      map(() => ({
-        body: generatorFunction.body,
-        functionStar: generatorFunction.getFirstToken()
-      }))
-    );
+    const effectModule = yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression);
+    return {
+      node,
+      generatorFunction,
+      effectModule,
+      body: generatorFunction.body,
+      functionStar: generatorFunction.getFirstToken()
+    };
   });
 }
 function expectedAndRealType(ts, typeChecker) {
@@ -958,6 +965,25 @@ var floatingEffect = createDiagnostic({
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/array.js
 var isNonEmptyArray = (self) => self.length > 0;
 
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Iterable.js
+var findFirst = /* @__PURE__ */ dual(2, (self, f) => {
+  let i = 0;
+  for (const a of self) {
+    const o = f(a, i);
+    if (isBoolean(o)) {
+      if (o) {
+        return some2(a);
+      }
+    } else {
+      if (isSome2(o)) {
+        return o;
+      }
+    }
+    i++;
+  }
+  return none2();
+});
+
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Array.js
 var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
@@ -979,6 +1005,7 @@ var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
 var head = /* @__PURE__ */ get(0);
 var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
 var tailNonEmpty = (self) => self.slice(1);
+var findFirst2 = findFirst;
 var sort = /* @__PURE__ */ dual(2, (self, O) => {
   const out = Array.from(self);
   out.sort(O);
@@ -1544,7 +1571,9 @@ var asyncAwaitToGen = createRefactor({
   description: "Convert to Effect.gen",
   apply: (ts, program) => (sourceFile, textRange) => pipe(
     getNodesContainingRange(ts)(sourceFile, textRange),
-    filter(ts.isFunctionDeclaration),
+    filter(
+      (node) => ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)
+    ),
     filter((node) => !!node.body),
     filter(
       (node) => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async)
@@ -1590,7 +1619,9 @@ var asyncAwaitToGenTryPromise = createRefactor({
   description: "Convert to Effect.gen with failures",
   apply: (ts, program) => (sourceFile, textRange) => pipe(
     getNodesContainingRange(ts)(sourceFile, textRange),
-    filter(ts.isFunctionDeclaration),
+    filter(
+      (node) => ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)
+    ),
     filter((node) => !!node.body),
     filter(
       (node) => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async)
@@ -1660,6 +1691,94 @@ var asyncAwaitToGenTryPromise = createRefactor({
   )
 });
 
+// src/refactors/effectGenToFn.ts
+var effectGenToFn = createRefactor({
+  name: "effect/effectGenToFn",
+  description: "Convert to Effect.fn",
+  apply: (ts, program) => (sourceFile, textRange) => pipe(
+    getNodesContainingRange(ts)(sourceFile, textRange),
+    findFirst2(
+      (node) => gen(function* () {
+        const effectGen2 = yield* effectGen(ts, program.getTypeChecker())(node);
+        let pipeArgs = ts.factory.createNodeArray([]);
+        let nodeToReplace = node.parent;
+        if (ts.isPropertyAccessExpression(node.parent) && node.parent.name.text === "pipe" && ts.isCallExpression(node.parent.parent)) {
+          pipeArgs = node.parent.parent.arguments;
+          nodeToReplace = node.parent.parent.parent;
+        }
+        while (nodeToReplace) {
+          if (ts.isArrowFunction(nodeToReplace) || ts.isFunctionDeclaration(nodeToReplace)) {
+            return { ...effectGen2, pipeArgs, nodeToReplace };
+          }
+          if (ts.isConciseBody(nodeToReplace) || ts.isReturnStatement(nodeToReplace)) {
+            nodeToReplace = nodeToReplace.parent;
+            continue;
+          }
+          if (ts.isBlock(nodeToReplace) && nodeToReplace.statements.length === 1) {
+            nodeToReplace = nodeToReplace.parent;
+            continue;
+          }
+          break;
+        }
+        return yield* none2();
+      })
+    ),
+    map(
+      ({ effectModule, generatorFunction, nodeToReplace, pipeArgs }) => ({
+        kind: "refactor.rewrite.effect.effectGenToFn",
+        description: "Convert to Effect.fn",
+        apply: (changeTracker) => {
+          const effectFn = nodeToReplace.name ? ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(
+              effectModule,
+              "fn"
+            ),
+            void 0,
+            [ts.factory.createStringLiteral(nodeToReplace.name.text)]
+          ) : ts.factory.createPropertyAccessExpression(
+            effectModule,
+            "fn"
+          );
+          const effectFnCallWithGenerator = ts.factory.createCallExpression(
+            effectFn,
+            void 0,
+            [ts.factory.createFunctionExpression(
+              void 0,
+              ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+              void 0,
+              nodeToReplace.typeParameters,
+              nodeToReplace.parameters,
+              nodeToReplace.type,
+              generatorFunction.body
+            )].concat(pipeArgs)
+          );
+          if (!ts.isArrowFunction(nodeToReplace) && nodeToReplace.name) {
+            const variableDeclaration = ts.factory.createVariableStatement(
+              nodeToReplace.modifiers,
+              ts.factory.createVariableDeclarationList(
+                [ts.factory.createVariableDeclaration(
+                  nodeToReplace.name,
+                  void 0,
+                  void 0,
+                  effectFnCallWithGenerator
+                )],
+                ts.NodeFlags.Const
+              )
+            );
+            changeTracker.replaceNode(
+              sourceFile,
+              nodeToReplace,
+              variableDeclaration
+            );
+          } else {
+            changeTracker.replaceNode(sourceFile, nodeToReplace, effectFnCallWithGenerator);
+          }
+        }
+      })
+    )
+  )
+});
+
 // src/refactors/functionToArrow.ts
 var functionToArrow = createRefactor({
   name: "effect/functionToArrow",
@@ -1953,7 +2072,8 @@ var refactors = {
   toggleLazyConst,
   toggleReturnTypeAnnotation,
   toggleTypeAnnotation,
-  wrapWithPipe
+  wrapWithPipe,
+  effectGenToFn
 };
 
 // src/index.ts