fmt

Author: mathpirate

packages/ts-transformers/src/closures/transformer.ts

@@ -414,7 +414,8 @@ function buildCallbackParamTypeNode(
     const typeNode = checker.typeToTypeNode(
       exprType,
       context.sourceFile,
-      ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.UseStructuralFallback,
+      ts.NodeBuilderFlags.NoTruncation |
+        ts.NodeBuilderFlags.UseStructuralFallback,
     ) ?? factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
 
     // Register this property's TypeNode with its Type
@@ -495,12 +496,17 @@ function inferElementType(
       let elementType: ts.Type;
       if (checker.isArrayType(innerType)) {
         // It's T[], extract T
-        const extracted = checker.getIndexTypeOfType(innerType, ts.IndexKind.Number);
+        const extracted = checker.getIndexTypeOfType(
+          innerType,
+          ts.IndexKind.Number,
+        );
         if (extracted) {
           elementType = extracted;
         } else {
           return {
-            typeNode: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+            typeNode: factory.createKeywordTypeNode(
+              ts.SyntaxKind.UnknownKeyword,
+            ),
           };
         }
       } else {
@@ -512,7 +518,8 @@ function inferElementType(
       const typeNode = checker.typeToTypeNode(
         elementType,
         context.sourceFile,
-        ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.UseStructuralFallback,
+        ts.NodeBuilderFlags.NoTruncation |
+          ts.NodeBuilderFlags.UseStructuralFallback,
       ) ?? factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
 
       return { typeNode, type: elementType };
@@ -521,12 +528,16 @@ function inferElementType(
 
   // Fallback for plain Array<T>
   if (checker.isArrayType(arrayType)) {
-    const elementType = checker.getIndexTypeOfType(arrayType, ts.IndexKind.Number);
+    const elementType = checker.getIndexTypeOfType(
+      arrayType,
+      ts.IndexKind.Number,
+    );
     if (elementType) {
       const typeNode = checker.typeToTypeNode(
         elementType,
         context.sourceFile,
-        ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.UseStructuralFallback,
+        ts.NodeBuilderFlags.NoTruncation |
+          ts.NodeBuilderFlags.UseStructuralFallback,
       ) ?? factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
 
       return { typeNode, type: elementType };

packages/ts-transformers/src/transformers/schema-generator.ts

@@ -66,7 +66,12 @@ export class SchemaGeneratorTransformer extends Transformer {
         ) {
           // This is a synthetic TypeNode that didn't resolve to a proper Type
           // Analyze the TypeNode structure, checking typeRegistry for property Types
-          schema = analyzeTypeNodeStructure(typeArg, checker, context.factory, typeRegistry);
+          schema = analyzeTypeNodeStructure(
+            typeArg,
+            checker,
+            context.factory,
+            typeRegistry,
+          );
         } else {
           // Normal path: use Type-based schema generation
           schema = generateSchema!(type, checker, typeArg);
@@ -229,7 +234,12 @@ function analyzeTypeNodeStructure(
           propSchema = generateSchema(propType, checker, member.type);
         } else {
           // No Type available - recurse on TypeNode structure
-          propSchema = analyzeTypeNodeStructure(member.type, checker, factory, typeRegistry);
+          propSchema = analyzeTypeNodeStructure(
+            member.type,
+            checker,
+            factory,
+            typeRegistry,
+          );
         }
 
         properties[propName] = propSchema;

packages/ts-transformers/test/opaque-ref/map-callbacks.test.ts

@@ -52,7 +52,7 @@ describe("OpaqueRef map callbacks", () => {
     );
     assertStringIncludes(
       output,
-      '({ elem, index, params: { defaultName } }) =>',
+      "({ elem, index, params: { defaultName } }) =>",
     );
     assertStringIncludes(
       output,