@effect/language-service 0.16.6 → 0.16.7

package/index.js

@@ -3707,7 +3707,7 @@ var createUnsupportedNodeComment = (ts, sourceFile, node) => ts.addSyntheticTrai
   ts.SyntaxKind.MultiLineCommentTrivia,
   " Not supported conversion: " + node.getText(sourceFile) + " "
 );
-var processNode = (node) => gen2(function* () {
+var processNode = (node, isVirtualTypeNode) => gen2(function* () {
   const { createApiCall, createApiPropertyAccess, entityNameToDataTypeName, sourceFile, ts } = yield* service(
     SchemaGenContext
   );
@@ -3741,12 +3741,12 @@ var processNode = (node) => gen2(function* () {
   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(_)));
+    const members = yield* all2(...node.types.map((_) => processNode(_, isVirtualTypeNode)));
     return createApiCall("Union", members);
   }
   if (ts.isIntersectionTypeNode(node)) {
     const [firstSchema, ...otherSchemas] = yield* all2(
-      ...node.types.map((_) => processNode(_))
+      ...node.types.map((_) => processNode(_, isVirtualTypeNode))
     );
     if (otherSchemas.length === 0) return firstSchema;
     return ts.factory.createCallExpression(
@@ -3760,22 +3760,28 @@ var processNode = (node) => gen2(function* () {
   }
   if (ts.isTypeOperatorNode(node)) {
     if (node.operator === ts.SyntaxKind.KeyOfKeyword) {
-      return createApiCall("keyof", [yield* processNode(node.type)]);
+      return createApiCall("keyof", [yield* processNode(node.type, isVirtualTypeNode)]);
     } else if (node.operator === ts.SyntaxKind.ReadonlyKeyword) {
-      return yield* processNode(node.type);
+      return yield* processNode(node.type, isVirtualTypeNode);
     }
   }
   if (ts.isArrayTypeNode(node)) {
-    const typeSchema = yield* processNode(node.elementType);
+    const typeSchema = yield* processNode(node.elementType, isVirtualTypeNode);
     return createApiCall("Array", [typeSchema]);
   }
   if (ts.isTypeLiteralNode(node)) {
-    const { properties, records } = yield* processMembers(node.members);
+    const { properties, records } = yield* processMembers(node.members, isVirtualTypeNode);
     return createApiCall(
       "Struct",
       [ts.factory.createObjectLiteralExpression(properties, true)].concat(records)
     );
   }
+  if (ts.isTypeQueryNode(node)) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const type = typeChecker.getTypeAtLocation(node.exprName);
+    const typeNode = typeChecker.typeToTypeNode(type, void 0, ts.NodeBuilderFlags.NoTruncation);
+    if (typeNode) return yield* processNode(typeNode, true);
+  }
   if (ts.isTypeReferenceNode(node)) {
     const parsedName = entityNameToDataTypeName(node.typeName);
     if (isSome2(parsedName)) {
@@ -3787,13 +3793,13 @@ var processNode = (node) => gen2(function* () {
         case "Chunk":
         case "Array": {
           const elements = yield* all2(
-            ...node.typeArguments ? node.typeArguments.map(processNode) : []
+            ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           return createApiCall(parsedName.value, elements);
         }
         case "Record": {
           const elements = yield* all2(
-            ...node.typeArguments ? node.typeArguments.map(processNode) : []
+            ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           if (elements.length >= 2) {
             return createApiCall(parsedName.value, [
@@ -3807,7 +3813,7 @@ var processNode = (node) => gen2(function* () {
         }
         case "Either": {
           const elements = yield* all2(
-            ...node.typeArguments ? node.typeArguments.map(processNode) : []
+            ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           if (elements.length >= 2) {
             return createApiCall(parsedName.value, [
@@ -3825,7 +3831,7 @@ var processNode = (node) => gen2(function* () {
           if (typeArguments.length !== 2) {
             return createUnsupportedNodeComment(ts, sourceFile, node);
           }
-          const baseType = yield* processNode(typeArguments[0]);
+          const baseType = yield* processNode(typeArguments[0], isVirtualTypeNode);
           const stringLiteralArguments = yield* option(parseAllLiterals(typeArguments[1]));
           if (isNone2(stringLiteralArguments)) {
             return createUnsupportedNodeComment(ts, sourceFile, node);
@@ -3852,7 +3858,7 @@ var processNode = (node) => gen2(function* () {
 var processMembers = fn(
   "SchemaGen.processMembers"
 )(
-  function* (members) {
+  function* (members, isVirtualTypeNode) {
     const { createApiCall, ts } = yield* service(
       SchemaGenContext
     );
@@ -3866,7 +3872,7 @@ var processMembers = fn(
         return yield* fail(new RequiredExplicitTypesError(propertySignature));
       }
       const propertyAssignment = pipe(
-        yield* processNode(propertySignature.type),
+        yield* processNode(propertySignature.type, isVirtualTypeNode),
         propertySignature.questionToken ? (_) => createApiCall("optional", [_]) : identity,
         (_) => ts.factory.createPropertyAssignment(name, _)
       );
@@ -3880,8 +3886,8 @@ var processMembers = fn(
       const parameter = indexSignature.parameters[0];
       if (!parameter.type) return yield* fail(new RequiredExplicitTypesError(parameter));
       const parameterType = parameter.type;
-      const key = yield* processNode(parameterType);
-      const value = yield* processNode(indexSignature.type);
+      const key = yield* processNode(parameterType, isVirtualTypeNode);
+      const value = yield* processNode(indexSignature.type, isVirtualTypeNode);
       records.push(
         ts.factory.createObjectLiteralExpression([
           ts.factory.createPropertyAssignment("key", key),
@@ -3900,7 +3906,7 @@ var processInterfaceDeclaration = fn("SchemaGen.processInterfaceDeclaration")(
     const { createApiCall, ts } = yield* service(
       SchemaGenContext
     );
-    const { properties, records } = yield* processMembers(node.members);
+    const { properties, records } = yield* processMembers(node.members, false);
     if (preferClass && records.length === 0) {
       return yield* createExportSchemaClassDeclaration(node.name.text, properties);
     }
@@ -3918,12 +3924,12 @@ var processTypeAliasDeclaration = fn("SchemaGen.processInterfaceDeclaration")(
       return yield* fail(new TypeParametersNotSupportedError(node));
     }
     if (preferClass && ts.isTypeLiteralNode(node.type)) {
-      const { properties, records } = yield* processMembers(node.type.members);
+      const { properties, records } = yield* processMembers(node.type.members, false);
       if (records.length === 0) {
         return yield* createExportSchemaClassDeclaration(node.name.text, properties);
       }
     }
-    const effectSchema = yield* processNode(node.type);
+    const effectSchema = yield* processNode(node.type, false);
     return yield* createExportVariableDeclaration(node.name.text, effectSchema);
   }
 );
@@ -4026,6 +4032,7 @@ var typeToEffectSchema = createRefactor({
   description: "Refactor to Schema",
   apply: fn("typeToEffectSchema.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
     const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const node = maybeNode.value;
@@ -4034,6 +4041,7 @@ var typeToEffectSchema = createRefactor({
       description: "Refactor to Schema",
       apply: pipe(
         applyAtNode(sourceFile, node, false),
+        provideService(TypeCheckerApi, typeChecker),
         provideService(TypeScriptApi, ts)
       )
     };
@@ -4046,6 +4054,7 @@ var typeToEffectSchemaClass = createRefactor({
   description: "Refactor to Schema.Class",
   apply: fn("typeToEffectSchemaClass.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
     const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const node = maybeNode.value;
@@ -4054,6 +4063,7 @@ var typeToEffectSchemaClass = createRefactor({
       description: "Refactor to Schema.Class",
       apply: pipe(
         applyAtNode(sourceFile, node, true),
+        provideService(TypeCheckerApi, typeChecker),
         provideService(TypeScriptApi, ts)
       )
     };