generate schemas for injected map_with_pattern calls; update many fixtures accordingly. still one failing test

Author: mathpirate

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

@@ -336,6 +336,208 @@ function getCaptureName(expr: ts.Expression): string | undefined {
   return undefined;
 }
 
+/**
+ * Build a TypeNode for the callback parameter and register property TypeNodes in typeRegistry.
+ * Returns a TypeLiteral representing { elem: T, index?: number, params: {...} }
+ */
+function buildCallbackParamTypeNode(
+  mapCall: ts.CallExpression,
+  elemParam: ts.ParameterDeclaration | undefined,
+  indexParam: ts.ParameterDeclaration | undefined,
+  capturedVarNames: Set<string>,
+  captures: Map<string, ts.Expression>,
+  context: TransformationContext,
+): ts.TypeNode {
+  const { factory, checker } = context;
+  const typeRegistry = context.options.typeRegistry;
+
+  // 1. Build elem type property
+  let elemTypeNode: ts.TypeNode;
+  let elemType: ts.Type | undefined;
+
+  // Check if we have an explicit type annotation that's not 'any'
+  if (elemParam?.type) {
+    const annotationType = checker.getTypeFromTypeNode(elemParam.type);
+    if (!(annotationType.flags & ts.TypeFlags.Any)) {
+      // Use the explicit annotation
+      elemTypeNode = elemParam.type;
+      elemType = annotationType;
+    } else {
+      // Annotation is 'any', try to infer from array
+      const inferred = inferElementType(mapCall, context);
+      elemTypeNode = inferred.typeNode;
+      elemType = inferred.type;
+    }
+  } else {
+    // No annotation, infer from array
+    const inferred = inferElementType(mapCall, context);
+    elemTypeNode = inferred.typeNode;
+    elemType = inferred.type;
+  }
+
+  // Register elem TypeNode if we have a Type
+  if (typeRegistry && elemType) {
+    typeRegistry.set(elemTypeNode, elemType);
+  }
+
+  const callbackParamProperties: ts.TypeElement[] = [
+    factory.createPropertySignature(
+      undefined,
+      factory.createIdentifier("elem"),
+      undefined,
+      elemTypeNode,
+    ),
+  ];
+
+  // 2. Add index property if present
+  if (indexParam) {
+    callbackParamProperties.push(
+      factory.createPropertySignature(
+        undefined,
+        factory.createIdentifier("index"),
+        factory.createToken(ts.SyntaxKind.QuestionToken),
+        factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+      ),
+    );
+  }
+
+  // 3. Build params object type with captured variables
+  const paramsProperties: ts.TypeElement[] = [];
+  for (const varName of capturedVarNames) {
+    const expr = captures.get(varName);
+    if (!expr) continue;
+
+    // Get the Type of the captured expression
+    const exprType = checker.getTypeAtLocation(expr);
+
+    // Convert Type to TypeNode
+    const typeNode = checker.typeToTypeNode(
+      exprType,
+      context.sourceFile,
+      ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.UseStructuralFallback,
+    ) ?? factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+
+    // Register this property's TypeNode with its Type
+    if (typeRegistry) {
+      typeRegistry.set(typeNode, exprType);
+    }
+
+    paramsProperties.push(
+      factory.createPropertySignature(
+        undefined,
+        factory.createIdentifier(varName),
+        undefined,
+        typeNode,
+      ),
+    );
+  }
+
+  // Add params property
+  callbackParamProperties.push(
+    factory.createPropertySignature(
+      undefined,
+      factory.createIdentifier("params"),
+      undefined,
+      factory.createTypeLiteralNode(paramsProperties),
+    ),
+  );
+
+  return factory.createTypeLiteralNode(callbackParamProperties);
+}
+
+/**
+ * Infer the element type from an OpaqueRef<T[]> or Array<T> being mapped.
+ */
+function inferElementType(
+  mapCall: ts.CallExpression,
+  context: TransformationContext,
+): { typeNode: ts.TypeNode; type?: ts.Type } {
+  const { factory, checker } = context;
+
+  if (!ts.isPropertyAccessExpression(mapCall.expression)) {
+    return {
+      typeNode: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+    };
+  }
+
+  const arrayExpr = mapCall.expression.expression;
+  const arrayType = checker.getTypeAtLocation(arrayExpr);
+
+  // Handle OpaqueRef<T[]> which is an intersection type
+  let actualArrayType = arrayType;
+  if (arrayType.flags & ts.TypeFlags.Intersection) {
+    const intersectionType = arrayType as ts.IntersectionType;
+    // Look for the Reference type member (e.g., OpaqueRefMethods<T[]>)
+    for (const type of intersectionType.types) {
+      if (type.flags & ts.TypeFlags.Object) {
+        const objType = type as ts.ObjectType;
+        if (objType.objectFlags & ts.ObjectFlags.Reference) {
+          actualArrayType = type;
+          break;
+        }
+      }
+    }
+  }
+
+  // Get type arguments from the reference type
+  let typeArgs: readonly ts.Type[] | undefined;
+  if (actualArrayType.flags & ts.TypeFlags.Object) {
+    const objectType = actualArrayType as ts.ObjectType;
+    if (objectType.objectFlags & ts.ObjectFlags.Reference) {
+      typeArgs = checker.getTypeArguments(objectType as ts.TypeReference);
+    }
+  }
+
+  if (typeArgs && typeArgs.length > 0) {
+    const innerType = typeArgs[0];
+    if (innerType) {
+      // innerType is either T[] or T depending on the structure
+      let elementType: ts.Type;
+      if (checker.isArrayType(innerType)) {
+        // It's T[], extract T
+        const extracted = checker.getIndexTypeOfType(innerType, ts.IndexKind.Number);
+        if (extracted) {
+          elementType = extracted;
+        } else {
+          return {
+            typeNode: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+          };
+        }
+      } else {
+        // It's already T
+        elementType = innerType;
+      }
+
+      // Convert Type to TypeNode
+      const typeNode = checker.typeToTypeNode(
+        elementType,
+        context.sourceFile,
+        ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.UseStructuralFallback,
+      ) ?? factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+
+      return { typeNode, type: elementType };
+    }
+  }
+
+  // Fallback for plain Array<T>
+  if (checker.isArrayType(arrayType)) {
+    const elementType = checker.getIndexTypeOfType(arrayType, ts.IndexKind.Number);
+    if (elementType) {
+      const typeNode = checker.typeToTypeNode(
+        elementType,
+        context.sourceFile,
+        ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.UseStructuralFallback,
+      ) ?? factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+
+      return { typeNode, type: elementType };
+    }
+  }
+
+  return {
+    typeNode: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+  };
+}
+
 /**
  * Transform a map callback that captures variables.
  */
@@ -562,19 +764,28 @@ function transformMapCallback(
     transformedBody,
   );
 
-  // Wrap in recipe() using the proper imported identifier
+  // Build a TypeNode for the callback parameter to pass as a type argument to recipe<T>()
+  // The callback signature is: ({ elem, index?, params: { captured1, captured2, ... } }) => ...
+  // Also register individual property TypeNodes in typeRegistry so SchemaGeneratorTransformer can resolve them
+  const callbackParamTypeNode = buildCallbackParamTypeNode(
+    mapCall,
+    elemParam,
+    indexParam,
+    capturedVarNames,
+    captures,
+    context,
+  );
+
+  // Wrap in recipe<T>() using type argument (SchemaInjectionTransformer will convert to toSchema<T>)
   const recipeIdentifier = getHelperIdentifier(
     factory,
     context.sourceFile,
     "recipe",
   );
   const recipeCall = factory.createCallExpression(
     recipeIdentifier,
-    undefined,
-    [
-      factory.createStringLiteral("map with pattern including captures"),
-      newCallback,
-    ],
+    [callbackParamTypeNode], // Type argument
+    [newCallback],
   );
 
   // Create the params object

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

@@ -57,12 +57,25 @@ export class SchemaGeneratorTransformer extends Transformer {
           optionsObj = evaluateObjectLiteral(arg0, checker);
         }
 
-        const schema = generateSchema!(type, checker, typeArg);
+        // If Type resolved to 'any' and we have a synthetic TypeNode, try analyzing its structure
+        let schema: unknown;
+        if (
+          (type.flags & ts.TypeFlags.Any) &&
+          typeArg.pos === -1 &&
+          typeArg.end === -1
+        ) {
+          // 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);
+        } else {
+          // Normal path: use Type-based schema generation
+          schema = generateSchema!(type, checker, typeArg);
+        }
 
         // Handle boolean schemas (true/false) - can't spread them
         const finalSchema = typeof schema === "boolean"
           ? schema
-          : { ...schema, ...optionsObj };
+          : { ...(schema as Record<string, unknown>), ...optionsObj };
         const schemaAst = createSchemaAst(finalSchema, context.factory);
 
         const constAssertion = context.factory.createAsExpression(
@@ -172,3 +185,100 @@ function evaluateExpression(
   if (constantValue !== undefined) return constantValue;
   return undefined;
 }
+
+/**
+ * Analyze a synthetic TypeNode's structure to generate a schema when Type resolution fails.
+ * Checks typeRegistry for property Types before recursing.
+ */
+function analyzeTypeNodeStructure(
+  typeNode: ts.TypeNode,
+  checker: ts.TypeChecker,
+  factory: ts.NodeFactory,
+  typeRegistry?: import("../core/mod.ts").TypeRegistry,
+): unknown {
+  // Handle TypeLiteral nodes (object types)
+  if (ts.isTypeLiteralNode(typeNode)) {
+    const properties: Record<string, unknown> = {};
+    const required: string[] = [];
+
+    for (const member of typeNode.members) {
+      if (
+        ts.isPropertySignature(member) &&
+        member.name &&
+        ts.isIdentifier(member.name) &&
+        member.type
+      ) {
+        const propName = member.name.text;
+
+        // First, check if this property's TypeNode is in the typeRegistry
+        let propType: ts.Type | undefined;
+        if (typeRegistry && typeRegistry.has(member.type)) {
+          propType = typeRegistry.get(member.type);
+        } else {
+          // Try to get Type from the property's TypeNode
+          const resolvedType = checker.getTypeFromTypeNode(member.type);
+          if (!(resolvedType.flags & ts.TypeFlags.Any)) {
+            propType = resolvedType;
+          }
+        }
+
+        let propSchema: unknown;
+        if (propType) {
+          // We have a real Type - use normal schema generator
+          if (!generateSchema) generateSchema = createSchemaTransformerV2();
+          propSchema = generateSchema(propType, checker, member.type);
+        } else {
+          // No Type available - recurse on TypeNode structure
+          propSchema = analyzeTypeNodeStructure(member.type, checker, factory, typeRegistry);
+        }
+
+        properties[propName] = propSchema;
+
+        // Add to required if not optional
+        if (!member.questionToken) {
+          required.push(propName);
+        }
+      }
+    }
+
+    const schema: Record<string, unknown> = {
+      type: "object",
+      properties,
+    };
+
+    if (required.length > 0) {
+      schema.required = required;
+    }
+
+    return schema;
+  }
+
+  // Handle keyword types (string, number, boolean, etc.)
+  switch (typeNode.kind) {
+    case ts.SyntaxKind.StringKeyword:
+      return { type: "string" };
+    case ts.SyntaxKind.NumberKeyword:
+      return { type: "number" };
+    case ts.SyntaxKind.BooleanKeyword:
+      return { type: "boolean" };
+    case ts.SyntaxKind.NullKeyword:
+      return { type: "null" };
+    case ts.SyntaxKind.UndefinedKeyword:
+    case ts.SyntaxKind.VoidKeyword:
+    case ts.SyntaxKind.AnyKeyword:
+    case ts.SyntaxKind.UnknownKeyword:
+      // Accept any value
+      return true;
+  }
+
+  // For other TypeNode kinds, try to resolve as Type
+  const type = checker.getTypeFromTypeNode(typeNode);
+  if (!(type.flags & ts.TypeFlags.Any)) {
+    // Successfully resolved - use normal schema generator
+    if (!generateSchema) generateSchema = createSchemaTransformerV2();
+    return generateSchema(type, checker, typeNode);
+  }
+
+  // Fallback: accept any value
+  return true;
+}

packages/ts-transformers/test/fixtures/closures/cell-map-with-captures.expected.tsx

@@ -23,7 +23,25 @@ export default recipe({
     const typedValues: Cell<number[]> = cell(state.values);
     return {
         [UI]: (<div>
-        {typedValues.map_with_pattern(recipe("map with pattern including captures", ({ elem, params: { multiplier } }) => (<span>{elem * multiplier}</span>)), { multiplier: state.multiplier })}
+        {typedValues.map_with_pattern(recipe({
+                type: "object",
+                properties: {
+                    elem: {
+                        type: "number"
+                    },
+                    params: {
+                        type: "object",
+                        properties: {
+                            multiplier: {
+                                type: "number",
+                                asOpaque: true
+                            }
+                        },
+                        required: ["multiplier"]
+                    }
+                },
+                required: ["elem", "params"]
+            } as const satisfies JSONSchema, ({ elem, params: { multiplier } }) => (<span>{elem * multiplier}</span>)), { multiplier: state.multiplier })}
       </div>),
     };
 });