@effect/language-service 0.15.0 → 0.15.1

package/index.js

@@ -1004,23 +1004,27 @@ var contextGet = (context, tag) => {
   }
   return none2();
 };
-var Nano = class {
-  constructor(run2) {
-    this.run = run2;
-  }
+var Proto = {
+  run: () => {
+  },
   [Symbol.iterator]() {
     return new SingleShotGen(new YieldWrap(this));
   }
 };
+function make3(run2) {
+  const result = Object.create(Proto);
+  result.run = run2;
+  return result;
+}
 var unsafeRun = (fa) => {
   const result = fa.run(contextEmpty);
   switch (result._tag) {
     case "Left":
-      return left2(result.left);
+      return left2(result.value);
     case "Defect":
-      return left2(new NanoDefectException(result.defect));
+      return left2(new NanoDefectException(result.value));
     case "Right":
-      return right2(result.right);
+      return right2(result.value);
   }
 };
 var run = (fa) => {
@@ -1030,35 +1034,35 @@ var run = (fa) => {
     return left2(new NanoDefectException(e));
   }
 };
-var succeed = (value) => new Nano(() => ({ _tag: "Right", right: value }));
-var fail = (value) => new Nano(() => ({ _tag: "Left", left: value }));
-var sync = (value) => new Nano(() => ({ _tag: "Right", right: value() }));
-var flatMap3 = dual(2, (fa, f) => new Nano((ctx) => {
+var succeed = (value) => make3(() => ({ _tag: "Right", value }));
+var fail = (value) => make3(() => ({ _tag: "Left", value }));
+var sync = (value) => make3(() => ({ _tag: "Right", value: value() }));
+var flatMap3 = dual(2, (fa, f) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
-  return f(result.right).run(ctx);
+  return f(result.value).run(ctx);
 }));
-var map3 = dual(2, (fa, f) => new Nano((ctx) => {
+var map3 = dual(2, (fa, f) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
-  return { _tag: "Right", right: f(result.right) };
+  return { _tag: "Right", value: f(result.value) };
 }));
-var orElse3 = (f) => (fa) => new Nano((ctx) => {
+var orElse3 = (f) => (fa) => make3((ctx) => {
   const result = fa.run(ctx);
-  if (result._tag === "Left") return f(result.left).run(ctx);
+  if (result._tag === "Left") return f(result.value).run(ctx);
   return result;
 });
 var firstSuccessOf = (arr) => reduce(arr.slice(1), arr[0], (arr2, fa) => orElse3(() => fa)(arr2));
-var service = (tag) => new Nano(
+var service = (tag) => make3(
   (ctx) => contextGet(ctx, tag).pipe(match2({
-    onNone: () => ({ _tag: "Defect", defect: `Cannot find service ${tag.key}` }),
-    onSome: (value) => ({ _tag: "Right", right: value })
+    onNone: () => ({ _tag: "Defect", value: `Cannot find service ${tag.key}` }),
+    onSome: (value) => ({ _tag: "Right", value })
   }))
 );
-var provideService = (tag, value) => (fa) => new Nano((ctx) => {
+var provideService = (tag, value) => (fa) => make3((ctx) => {
   return fa.run(contextAdd(ctx, tag, value));
 });
-var gen2 = (...args) => new Nano((ctx) => {
+var gen2 = (...args) => make3((ctx) => {
   const iterator = args[0]();
   let state = iterator.next();
   while (!state.done) {
@@ -1067,11 +1071,11 @@ var gen2 = (...args) => new Nano((ctx) => {
     if (result._tag !== "Right") {
       return result;
     }
-    state = iterator.next(result.right);
+    state = iterator.next(result.value);
   }
-  return { _tag: "Right", right: state.value };
+  return { _tag: "Right", value: state.value };
 });
-var fn = (_) => (body) => (...args) => new Nano((ctx) => {
+var fn = (_) => (body) => (...args) => make3((ctx) => {
   const iterator = body(...args);
   let state = iterator.next();
   while (!state.done) {
@@ -1080,17 +1084,17 @@ var fn = (_) => (body) => (...args) => new Nano((ctx) => {
     if (result._tag !== "Right") {
       return result;
     }
-    state = iterator.next(result.right);
+    state = iterator.next(result.value);
   }
-  return { _tag: "Right", right: state.value };
+  return { _tag: "Right", value: state.value };
 });
-var option = (fa) => new Nano((ctx) => {
+var option = (fa) => make3((ctx) => {
   const result = fa.run(ctx);
   switch (result._tag) {
     case "Right":
-      return { _tag: "Right", right: some2(result.right) };
+      return { _tag: "Right", value: some2(result.value) };
     case "Left":
-      return { _tag: "Right", right: none2() };
+      return { _tag: "Right", value: none2() };
     case "Defect":
       return result;
   }
@@ -3595,6 +3599,7 @@ var makeSchemaGenContext = fn("SchemaGen.makeSchemaGenContext")(function* (sourc
           case "Date":
           case "Pick":
           case "Omit":
+          case "Record":
             return some2(name.text);
           case "ReadonlyArray":
           case "Array":
@@ -3631,8 +3636,17 @@ var parseAllLiterals = fn(
 )(
   function* (node) {
     const { ts } = yield* service(SchemaGenContext);
-    if (ts.isLiteralTypeNode(node) && node.literal.kind === ts.SyntaxKind.StringLiteral) {
-      return [ts.factory.createStringLiteral(node.literal.text)];
+    if (ts.isLiteralTypeNode(node)) {
+      switch (node.literal.kind) {
+        case ts.SyntaxKind.StringLiteral:
+          return [ts.factory.createStringLiteral(node.literal.text)];
+        case ts.SyntaxKind.NumericLiteral:
+          return [ts.factory.createNumericLiteral(node.literal.text)];
+        case ts.SyntaxKind.TrueKeyword:
+          return [ts.factory.createTrue()];
+        case ts.SyntaxKind.FalseKeyword:
+          return [ts.factory.createFalse()];
+      }
     }
     if (ts.isUnionTypeNode(node)) {
       return flatten(yield* all2(...node.types.map((_) => parseAllLiterals(_))));
@@ -3675,23 +3689,30 @@ var processNode = (node) => gen2(function* () {
       return createApiPropertyAccess("BigInt");
   }
   if (ts.isLiteralTypeNode(node)) {
-    switch (node.literal.kind) {
-      case ts.SyntaxKind.NullKeyword:
-        return createApiPropertyAccess("Null");
-      case ts.SyntaxKind.TrueKeyword:
-        return createApiCall("Literal", [ts.factory.createTrue()]);
-      case ts.SyntaxKind.FalseKeyword:
-        return createApiCall("Literal", [ts.factory.createFalse()]);
-      case ts.SyntaxKind.StringLiteral:
-        return createApiCall("Literal", [ts.factory.createStringLiteral(node.literal.text)]);
-      case ts.SyntaxKind.NumericLiteral:
-        return createApiCall("Literal", [ts.factory.createNumericLiteral(node.literal.text)]);
-    }
+    if (node.literal.kind === ts.SyntaxKind.NullKeyword) return createApiPropertyAccess("Null");
+    const literalMembers = yield* option(parseAllLiterals(node));
+    if (isSome2(literalMembers)) return createApiCall("Literal", literalMembers.value);
   }
   if (ts.isUnionTypeNode(node)) {
+    const allLiterals = yield* option(parseAllLiterals(node));
+    if (isSome2(allLiterals)) return createApiCall("Literal", allLiterals.value);
     const members = yield* all2(...node.types.map((_) => processNode(_)));
     return createApiCall("Union", members);
   }
+  if (ts.isIntersectionTypeNode(node)) {
+    const [firstSchema, ...otherSchemas] = yield* all2(
+      ...node.types.map((_) => processNode(_))
+    );
+    if (otherSchemas.length === 0) return firstSchema;
+    return ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        firstSchema,
+        "pipe"
+      ),
+      [],
+      otherSchemas.map((_) => createApiCall("extend", [_]))
+    );
+  }
   if (ts.isArrayTypeNode(node)) {
     const typeSchema = yield* processNode(node.elementType);
     return createApiCall("Array", [typeSchema]);
@@ -3718,6 +3739,20 @@ var processNode = (node) => gen2(function* () {
           );
           return createApiCall(parsedName.value, elements);
         }
+        case "Record": {
+          const elements = yield* all2(
+            ...node.typeArguments ? node.typeArguments.map(processNode) : []
+          );
+          if (elements.length >= 2) {
+            return createApiCall(parsedName.value, [
+              ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment("key", elements[0]),
+                ts.factory.createPropertyAssignment("value", elements[1])
+              ])
+            ]);
+          }
+          return createUnsupportedNodeComment(ts, sourceFile, node);
+        }
         case "Either": {
           const elements = yield* all2(
             ...node.typeArguments ? node.typeArguments.map(processNode) : []