@effect/language-service 0.5.0 → 0.6.0

package/index.js

@@ -64,6 +64,8 @@ var dual = function(arity, body) {
   }
 };
 var identity = (a) => a;
+var constant = (value) => () => value;
+var constUndefined = /* @__PURE__ */ constant(void 0);
 function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
     case 1:
@@ -113,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);
@@ -649,6 +652,7 @@ var isSome2 = isSome;
 var getOrElse = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNone() : self.value);
 var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
 var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
+var getOrUndefined = /* @__PURE__ */ getOrElse(constUndefined);
 var map = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 var flatMap = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : f(self.value));
 var all = (input) => {
@@ -811,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) {
@@ -829,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) {
@@ -848,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) {
@@ -955,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]);
@@ -976,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);
@@ -1541,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)
@@ -1587,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)
@@ -1657,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",
@@ -1894,10 +2016,19 @@ var toggleTypeAnnotation = createRefactor({
           }
           const initializer = node.initializer;
           const initializerType = typeChecker.getTypeAtLocation(initializer);
-          const initializerTypeNode = typeChecker.typeToTypeNode(
+          const initializerTypeNode = fromNullable(typeChecker.typeToTypeNode(
             initializerType,
             node,
             ts.NodeBuilderFlags.NoTruncation
+          )).pipe(
+            orElse(
+              () => fromNullable(typeChecker.typeToTypeNode(
+                initializerType,
+                void 0,
+                ts.NodeBuilderFlags.NoTruncation
+              ))
+            ),
+            getOrUndefined
           );
           if (initializerTypeNode) {
             changeTracker.insertNodeAt(
@@ -1941,7 +2072,8 @@ var refactors = {
   toggleLazyConst,
   toggleReturnTypeAnnotation,
   toggleTypeAnnotation,
-  wrapWithPipe
+  wrapWithPipe,
+  effectGenToFn
 };
 
 // src/index.ts