@typra/emitter 0.2.0

package/dist/src/languages/typescript/emitter.js

@@ -0,0 +1,904 @@
+/**
+ * TypeScript code emitter — Declaration IR → TypeScript source code.
+ *
+ * Replaces `file.ts.njk` (~414 lines of Nunjucks templates)
+ * with a typed TypeScript function that walks the FileDecl tree.
+ *
+ * The emitter produces correctly-formatted TypeScript code using modern
+ * class patterns with `Partial<T>` constructors. Output is post-processed
+ * by prettier + eslint, so exact whitespace is not critical.
+ *
+ * Structural blocks emitted (in order):
+ *   1. Header comment (auto-generated warning)
+ *   2. Imports (LoadContext/SaveContext, referenced types)
+ *   3. For each type in the file:
+ *      a. [abstract] class definition with extends
+ *      b. shorthandProperty static ClassVar
+ *      c. Field declarations with type annotations + defaults
+ *      d. Constructor with Partial<T>
+ *      e. //#region Load Methods
+ *         - load() static method
+ *         - loadKind() for polymorphic dispatch (private static)
+ *         - Collection helpers (loadX / saveX)
+ *      f. //#endregion
+ *      g. //#region Save Methods
+ *         - save() instance method
+ *         - toYaml() / toJson()
+ *         - fromJson() / fromYaml() static methods
+ *      h. //#endregion
+ *      i. Factory static methods
+ *      j. Method stubs (as comments)
+ */
+import { toKebabCase } from "../../ir/utilities.js";
+/**
+ * Type mapping from TypeSpec scalar types to TypeScript types.
+ */
+const TYPE_MAP = {
+    string: "string",
+    boolean: "boolean",
+    int32: "number",
+    int64: "number",
+    float32: "number",
+    float64: "number",
+    number: "number",
+    integer: "number",
+    numeric: "number",
+    float: "number",
+    plainDate: "Date",
+    plainTime: "Date",
+    utcDateTime: "Date",
+    bytes: "Uint8Array",
+    url: "string",
+    unknown: "unknown",
+    any: "unknown",
+    dictionary: "Record<string, unknown>",
+};
+/**
+ * Map a TypeSpec scalar to its typeof check string for coercion guards.
+ */
+function typeofCheck(scalarType) {
+    switch (scalarType) {
+        case "string":
+            return "string";
+        case "boolean":
+            return "boolean";
+        case "int32":
+        case "int64":
+        case "float32":
+        case "float64":
+        case "number":
+        case "integer":
+        case "numeric":
+        case "float":
+            return "number";
+        default:
+            return null;
+    }
+}
+function paramType(typeStr) {
+    return TYPE_MAP[typeStr] || typeStr;
+}
+function returnType(typeStr) {
+    if (typeStr.endsWith("?")) {
+        const inner = typeStr.slice(0, -1);
+        return `${returnType(inner)} | null`;
+    }
+    if (typeStr === "Record<unknown>")
+        return "Record<string, unknown>";
+    return TYPE_MAP[typeStr] || typeStr;
+}
+// ============================================================================
+// Main entry point
+// ============================================================================
+/**
+ * Emit a complete TypeScript file from a FileDecl.
+ *
+ * @param decl - The file declaration to emit
+ * @param visitor - Expression visitor for rendering expressions
+ * @param namespace - Optional namespace override
+ * @param group - Semantic group folder this file lives in (e.g. "connection"). Empty string = root.
+ */
+export function emitTypeScriptFile(decl, visitor, namespace, group = "") {
+    const lines = [];
+    // 1. Header
+    lines.push("// Copyright (c) Microsoft. All rights reserved.");
+    lines.push("// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.");
+    lines.push("");
+    // 2. Imports
+    // Protocol-only files don't need LoadContext/SaveContext
+    const hasNonProtocol = decl.types.some(t => !t.isProtocol);
+    if (hasNonProtocol) {
+        // Context file is always at the model root — go up one level when inside a group subfolder
+        const contextPath = group ? "../context" : "./context";
+        lines.push(`import { LoadContext, SaveContext } from "${contextPath}";`);
+    }
+    for (const imp of decl.imports) {
+        const kebab = toKebabCase(imp.module);
+        if (imp.group === group) {
+            // Same group (or both root): relative sibling
+            lines.push(`import { ${imp.names.join(", ")} } from "./${kebab}";`);
+        }
+        else if (imp.group) {
+            // Different non-empty group: go up to model root, then into the group subfolder
+            lines.push(`import { ${imp.names.join(", ")} } from "../${imp.group}/${kebab}";`);
+        }
+        else {
+            // Root-level module: go up one level from group subfolder
+            lines.push(`import { ${imp.names.join(", ")} } from "../${kebab}";`);
+        }
+    }
+    lines.push("");
+    // 2.5. Enum type aliases
+    for (const enumDef of decl.enums) {
+        const values = enumDef.values.map(v => `"${v}"`).join(" | ");
+        if (enumDef.isOpen) {
+            // Open enum — known values + any string
+            lines.push(`export type ${enumDef.name} = ${values} | (string & {});`);
+        }
+        else {
+            lines.push(`export type ${enumDef.name} = ${values};`);
+        }
+    }
+    if (decl.enums.length > 0) {
+        lines.push("");
+    }
+    // 3. Emit each type
+    for (const type of decl.types) {
+        emitType(type, lines, visitor);
+        lines.push("");
+    }
+    return lines.join("\n") + "\n";
+}
+// ============================================================================
+// Type emission
+// ============================================================================
+function emitType(type, lines, visitor) {
+    const name = type.typeName.name;
+    // Protocol types → emit as interface with method signatures
+    if (type.isProtocol) {
+        emitProtocolInterface(type, lines);
+        return;
+    }
+    // Class definition
+    const abstractPrefix = type.isAbstract ? "abstract " : "";
+    const extendsClause = type.base ? ` extends ${type.base.name}` : "";
+    lines.push(`export ${abstractPrefix}class ${name}${extendsClause} {`);
+    // shorthandProperty static
+    const shorthand = type.coercionProperty ? `"${type.coercionProperty}"` : "undefined";
+    lines.push(`  static readonly shorthandProperty: string | undefined = ${shorthand};`);
+    lines.push("");
+    // Field declarations
+    for (const field of type.fields) {
+        const annotation = tsTypeAnnotation(field);
+        const defaultVal = tsDefaultValue(field);
+        if (field.isOptional) {
+            lines.push(`  ${field.name}?: ${annotation}${defaultVal};`);
+        }
+        else if (defaultVal === "" && field.category.kind === "complex") {
+            // Required complex types without defaults need definite assignment assertion
+            lines.push(`  ${field.name}!: ${annotation};`);
+        }
+        else {
+            lines.push(`  ${field.name}: ${annotation}${defaultVal};`);
+        }
+    }
+    lines.push("");
+    // Constructor
+    emitConstructor(type, lines);
+    // //#region Load Methods
+    lines.push("  //#region Load Methods");
+    lines.push("");
+    // load() static method
+    emitLoadMethod(type, lines);
+    // Polymorphic dispatch
+    if (type.polymorphicDispatch) {
+        emitPolymorphicDispatch(name, type.polymorphicDispatch, lines);
+    }
+    // Collection helpers
+    for (const helper of type.collectionHelpers) {
+        emitCollectionLoadHelper(name, helper, lines);
+        emitCollectionSaveHelper(name, helper, lines);
+    }
+    lines.push("  //#endregion");
+    lines.push("");
+    // //#region Save Methods
+    lines.push("  //#region Save Methods");
+    lines.push("");
+    // save() instance method
+    emitSaveMethod(type, lines);
+    // toWire() method (only if wire mappings exist)
+    if (type.wire !== null) {
+        emitToWireMethod(type, lines);
+    }
+    // toYaml / toJson
+    emitToYaml(name, lines);
+    emitToJson(name, lines);
+    // fromJson / fromYaml
+    emitFromJson(name, type, lines);
+    emitFromYaml(name, type, lines);
+    lines.push("  //#endregion");
+    // Factory methods
+    if (type.factories.length > 0) {
+        lines.push("");
+        for (const factory of type.factories) {
+            emitFactory(name, factory, visitor, lines);
+        }
+    }
+    // Method stubs — emitted as a sibling interface below the class
+    lines.push("}");
+    // Emit MessageHelpers-style interface after the class
+    if (type.methods.length > 0) {
+        emitMethodHelpersInterface(type, lines);
+    }
+}
+/**
+ * Emit a TypeScript interface named `<TypeName>Helpers` declaring the
+ * `@method` contract for a concrete type. The generated class does NOT
+ * implement this interface on its own — runtime code must provide an
+ * implementation. The type checker verifies conformance via structural typing.
+ */
+function emitMethodHelpersInterface(type, lines) {
+    const name = type.typeName.name;
+    lines.push("");
+    lines.push(`/**`);
+    lines.push(` * Helper contract for \`${name}\`.`);
+    lines.push(` *`);
+    lines.push(` * Runtime implementations must provide these methods on every ${name}`);
+    lines.push(` * instance (either on the generated class or on a wrapper type). The`);
+    lines.push(` * TypeScript compiler enforces conformance wherever a value is typed as`);
+    lines.push(` * \`${name}Helpers\`.`);
+    lines.push(` */`);
+    lines.push(`export interface ${name}Helpers {`);
+    for (const m of type.methods) {
+        if (m.description) {
+            lines.push(`  /** ${m.description} */`);
+        }
+        const params = Object.entries(m.params)
+            .map(([pName, pType]) => `${pName}: ${returnType(pType)}`)
+            .join(", ");
+        const ret = returnType(m.returns);
+        // Zero-param non-verb methods are emitted as getter-style readonly
+        // properties (matches C#/Python emitters). Callers access them without
+        // parens, e.g. ``msg.text``.
+        const isGetter = Object.keys(m.params).length === 0 && !isMethodStyle(m.name);
+        if (isGetter) {
+            lines.push(`  readonly ${m.name}: ${ret};`);
+        }
+        else {
+            lines.push(`  ${m.name}(${params}): ${ret};`);
+        }
+    }
+    lines.push("}");
+}
+/**
+ * Verbs that indicate an action — zero-param @methods whose name starts with
+ * one of these are emitted as regular TypeScript methods. Everything else
+ * becomes a ``readonly`` getter-style property. Mirrors the C#/Python emitter
+ * heuristic so that ``message.text`` stays a property and
+ * ``message.toTextContent()`` stays a method in every runtime.
+ */
+const TS_METHOD_VERB_PREFIXES = [
+    "to", "get", "set", "fetch", "compute", "make", "build", "create",
+    "load", "save", "convert", "parse", "format", "render", "serialize",
+    "deserialize", "find", "calculate", "invoke", "execute", "run",
+];
+function isMethodStyle(name) {
+    const lower = name.toLowerCase();
+    for (const prefix of TS_METHOD_VERB_PREFIXES) {
+        if (lower === prefix)
+            return true;
+        if (lower.startsWith(prefix) && name.length > prefix.length) {
+            const next = name[prefix.length];
+            if (next === next.toUpperCase() && next !== next.toLowerCase()) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+// ============================================================================
+// Protocol interface emission
+// ============================================================================
+/**
+ * Emit a TypeScript interface for a protocol type.
+ * Protocols have methods but no data fields, load/save, or serialization.
+ */
+function emitProtocolInterface(type, lines) {
+    const name = type.typeName.name;
+    if (type.description) {
+        lines.push(`/** ${type.description} */`);
+    }
+    lines.push(`export interface ${name} {`);
+    for (const method of type.methods) {
+        if (method.description) {
+            lines.push(`  /** ${method.description} */`);
+        }
+        const params = Object.entries(method.params)
+            .map(([pName, pType]) => `${pName}: ${returnType(pType)}`)
+            .join(", ");
+        const ret = returnType(method.returns);
+        const optMark = method.optional ? "?" : "";
+        if (method.sync) {
+            lines.push(`  ${method.name}${optMark}(${params}): ${ret};`);
+        }
+        else {
+            lines.push(`  ${method.name}${optMark}(${params}): Promise<${ret}>;`);
+        }
+    }
+    lines.push("}");
+}
+function tsTypeAnnotation(f) {
+    // Named enum field — use the enum type alias
+    if (f.enumName && f.allowedValues.length > 0) {
+        return f.isOptional ? `${f.enumName} | undefined` : f.enumName;
+    }
+    const cat = f.category;
+    switch (cat.kind) {
+        case "dict":
+            return f.isOptional ? "Record<string, unknown> | undefined" : "Record<string, unknown>";
+        case "collection_scalar":
+            return `${TYPE_MAP[cat.scalarType] || "unknown"}[]`;
+        case "collection_complex":
+            return `${cat.typeName}[]`;
+        case "scalar": {
+            const tsType = TYPE_MAP[cat.scalarType] || "unknown";
+            return f.isOptional ? `${tsType} | undefined` : tsType;
+        }
+        case "complex":
+            return f.isOptional ? `${cat.typeName} | undefined` : cat.typeName;
+    }
+}
+// ============================================================================
+// Default values
+// ============================================================================
+function tsDefaultValue(f) {
+    const cat = f.category;
+    if (cat.kind === "collection_scalar" || cat.kind === "collection_complex") {
+        return " = []";
+    }
+    if (f.isOptional) {
+        return "";
+    }
+    // Enum fields — use the field's default value or the first allowed value
+    if (f.enumName && f.allowedValues.length > 0) {
+        const dv = typeof f.defaultValue === "string" && f.allowedValues.includes(f.defaultValue)
+            ? f.defaultValue
+            : f.allowedValues[0];
+        return ` = "${dv}"`;
+    }
+    if (cat.kind === "dict") {
+        return " = {}";
+    }
+    if (cat.kind === "scalar") {
+        return tsScalarDefault(cat.scalarType, f.defaultValue);
+    }
+    // complex required types — no inline default, handled by constructor
+    return "";
+}
+function tsScalarDefault(scalarType, defaultValue) {
+    if (defaultValue !== undefined && defaultValue !== null) {
+        if (typeof defaultValue === "string") {
+            return ` = "${defaultValue}"`;
+        }
+        return ` = ${defaultValue}`;
+    }
+    switch (scalarType) {
+        case "string":
+            return ' = ""';
+        case "boolean":
+            return " = false";
+        case "number":
+        case "int32":
+        case "int64":
+        case "float32":
+        case "float64":
+        case "integer":
+        case "numeric":
+        case "float":
+            return " = 0";
+        default:
+            return "";
+    }
+}
+// ============================================================================
+// Constructor
+// ============================================================================
+function emitConstructor(type, lines) {
+    const name = type.typeName.name;
+    const hasBase = type.base !== null;
+    lines.push(`  constructor(init?: Partial<${name}>) {`);
+    if (hasBase) {
+        lines.push("    super(init);");
+    }
+    for (const field of type.fields) {
+        const cat = field.category;
+        if (field.isOptional) {
+            lines.push(`    if (init?.${field.name} !== undefined) {`);
+            lines.push(`      this.${field.name} = init.${field.name};`);
+            lines.push("    }");
+        }
+        else if (cat.kind === "collection_scalar" || cat.kind === "collection_complex") {
+            lines.push(`    this.${field.name} = init?.${field.name} ?? [];`);
+        }
+        else if (cat.kind === "dict") {
+            lines.push(`    this.${field.name} = init?.${field.name} ?? {};`);
+        }
+        else if (field.enumName && field.allowedValues.length > 0 && !field.isOptional) {
+            const dv = typeof field.defaultValue === "string" && field.allowedValues.includes(field.defaultValue)
+                ? field.defaultValue
+                : field.allowedValues[0];
+            lines.push(`    this.${field.name} = init?.${field.name} ?? "${dv}";`);
+        }
+        else if (cat.kind === "scalar") {
+            const def = tsConstructorDefault(cat.scalarType, field.defaultValue);
+            lines.push(`    this.${field.name} = init?.${field.name} ?? ${def};`);
+        }
+        else {
+            // complex required — use init value or construct a new default
+            lines.push(`    if (init?.${field.name} !== undefined) {`);
+            lines.push(`      this.${field.name} = init.${field.name};`);
+            lines.push("    }");
+        }
+    }
+    lines.push("  }");
+    lines.push("");
+}
+function tsConstructorDefault(scalarType, defaultValue) {
+    if (defaultValue !== undefined && defaultValue !== null) {
+        if (typeof defaultValue === "string") {
+            return `"${defaultValue}"`;
+        }
+        return String(defaultValue);
+    }
+    switch (scalarType) {
+        case "string":
+            return '""';
+        case "boolean":
+            return "false";
+        case "number":
+        case "int32":
+        case "int64":
+        case "float32":
+        case "float64":
+        case "integer":
+        case "numeric":
+        case "float":
+            return "0";
+        default:
+            return '""';
+    }
+}
+// ============================================================================
+// load() method
+// ============================================================================
+function emitLoadMethod(type, lines) {
+    const name = type.typeName.name;
+    lines.push(`  static load(data: Record<string, unknown>, context?: LoadContext): ${name} {`);
+    // Context pre-processing
+    lines.push("    if (context) {");
+    lines.push("      data = context.processInput(data) as Record<string, unknown>;");
+    lines.push("    }");
+    // Coercion checks — group by JS typeof to handle int/float distinction
+    if (type.load.coercions.length > 0) {
+        lines.push("");
+        lines.push("    // Handle alternate representations");
+        emitCoercionBranches(name, type.load.coercions, type, lines);
+    }
+    lines.push("");
+    // Create instance (polymorphic dispatch or direct)
+    if (type.load.hasPolymorphicDispatch && type.polymorphicDispatch) {
+        lines.push(`    // Load polymorphic ${name} instance`);
+        lines.push(`    const instance = ${name}.loadKind(data, context);`);
+    }
+    else {
+        lines.push(`    const instance = new ${name}();`);
+    }
+    lines.push("");
+    // Per-property assignments
+    for (const a of type.load.assignments) {
+        lines.push(`    if (data["${a.sourceName}"] !== undefined && data["${a.sourceName}"] !== null) {`);
+        lines.push(`      ${emitLoadAssignment(a)}`);
+        lines.push("    }");
+    }
+    // Context post-processing
+    lines.push("");
+    lines.push("    if (context) {");
+    lines.push(`      return context.processOutput(instance) as ${name};`);
+    lines.push("    }");
+    lines.push("    return instance;");
+    lines.push("  }");
+    lines.push("");
+}
+function emitLoadAssignment(a) {
+    // Named enum — cast string to enum type alias
+    if (a.enumName && a.allowedValues.length > 0) {
+        return `instance.${a.fieldName} = String(data["${a.sourceName}"]) as ${a.enumName};`;
+    }
+    const cat = a.category;
+    switch (cat.kind) {
+        case "scalar": {
+            const tsType = TYPE_MAP[cat.scalarType];
+            switch (tsType) {
+                case "string":
+                    return `instance.${a.fieldName} = String(data["${a.sourceName}"]);`;
+                case "number":
+                    return `instance.${a.fieldName} = Number(data["${a.sourceName}"]);`;
+                case "boolean":
+                    return `instance.${a.fieldName} = Boolean(data["${a.sourceName}"]);`;
+                default:
+                    return `instance.${a.fieldName} = data["${a.sourceName}"] as ${tsType};`;
+            }
+        }
+        case "complex":
+            return `instance.${a.fieldName} = ${cat.typeName}.load(data["${a.sourceName}"] as Record<string, unknown>, context);`;
+        case "collection_scalar": {
+            const tsType = TYPE_MAP[cat.scalarType];
+            switch (tsType) {
+                case "string":
+                    return `instance.${a.fieldName} = (data["${a.sourceName}"] as unknown[]).map(v => String(v));`;
+                case "number":
+                    return `instance.${a.fieldName} = (data["${a.sourceName}"] as unknown[]).map(v => Number(v));`;
+                case "boolean":
+                    return `instance.${a.fieldName} = (data["${a.sourceName}"] as unknown[]).map(v => Boolean(v));`;
+                default:
+                    return `instance.${a.fieldName} = data["${a.sourceName}"] as ${tsType}[];`;
+            }
+        }
+        case "collection_complex":
+            return `instance.${a.fieldName} = ${a.parentTypeName}.load${capitalize(a.fieldName)}(data["${a.sourceName}"] as unknown[], context);`;
+        case "dict":
+            return `instance.${a.fieldName} = data["${a.sourceName}"] as Record<string, unknown>;`;
+    }
+}
+/**
+ * Emit coercion branches, grouping coercions that share the same JS typeof.
+ *
+ * In TypeScript, int32 and float64 both map to `typeof data === "number"`.
+ * When multiple coercions share a typeof, we emit a single outer `if` with
+ * `Number.isInteger()` sub-branches to disambiguate.
+ */
+function emitCoercionBranches(typeName, coercions, type, lines) {
+    // Group coercions by JS typeof check
+    const groups = new Map();
+    for (const c of coercions) {
+        const jsType = typeofCheck(c.scalarType);
+        if (!jsType)
+            continue;
+        if (!groups.has(jsType))
+            groups.set(jsType, []);
+        groups.get(jsType).push(c);
+    }
+    for (const [jsType, group] of groups) {
+        if (group.length === 1) {
+            // Single coercion for this typeof — emit simple branch
+            emitCoercionBranch(typeName, group[0], type, lines);
+        }
+        else {
+            // Multiple coercions sharing the same typeof (e.g., int32 + float64 → "number")
+            lines.push(`    if (typeof data === "${jsType}") {`);
+            // Find integer and float coercions
+            const intCoercion = group.find(c => isIntegerScalar(c.scalarType));
+            const floatCoercion = group.find(c => !isIntegerScalar(c.scalarType));
+            if (intCoercion && floatCoercion) {
+                // Use Number.isInteger to disambiguate
+                lines.push("      if (Number.isInteger(data)) {");
+                emitCoercionBody(typeName, intCoercion, type, lines, "        ");
+                lines.push("      } else {");
+                emitCoercionBody(typeName, floatCoercion, type, lines, "        ");
+                lines.push("      }");
+            }
+            else {
+                // Fallback: just emit them sequentially (shouldn't happen)
+                for (const c of group) {
+                    emitCoercionBody(typeName, c, type, lines, "      ");
+                }
+            }
+            lines.push("    }");
+        }
+    }
+}
+function isIntegerScalar(scalarType) {
+    return scalarType === "int32" || scalarType === "int64" || scalarType === "integer";
+}
+/**
+ * Emit a single coercion branch — typeof check with early return.
+ */
+function emitCoercionBranch(typeName, c, type, lines) {
+    const jsType = typeofCheck(c.scalarType);
+    if (!jsType)
+        return;
+    lines.push(`    if (typeof data === "${jsType}") {`);
+    emitCoercionBody(typeName, c, type, lines, "      ");
+    lines.push("    }");
+}
+/**
+ * Emit the body of a coercion branch (instance creation + property assignment).
+ */
+function emitCoercionBody(typeName, c, type, lines, indent) {
+    if (c.needsDispatch && type.polymorphicDispatch) {
+        // Dynamic discriminator — must go through dispatch
+        const dictFields = c.assignments.map(a => {
+            const val = a.isInput ? "data" : `"${a.literalValue}"`;
+            return `"${a.fieldName}": ${val}`;
+        });
+        lines.push(`${indent}return ${typeName}.loadKind({ ${dictFields.join(", ")} } as Record<string, unknown>, context);`);
+    }
+    else {
+        // Direct property setting
+        lines.push(`${indent}const instance = new ${typeName}();`);
+        for (const a of c.assignments) {
+            if (a.isInput) {
+                // Check if the target field is an enum — cast to enum type instead of scalar
+                const targetField = type.fields.find(f => f.name === a.fieldName);
+                const castType = targetField?.enumName && targetField.allowedValues.length > 0
+                    ? targetField.enumName
+                    : (TYPE_MAP[c.scalarType] || "unknown");
+                lines.push(`${indent}instance.${a.fieldName} = data as ${castType};`);
+            }
+            else {
+                lines.push(`${indent}instance.${a.fieldName} = "${a.literalValue}";`);
+            }
+        }
+        lines.push(`${indent}if (context) {`);
+        lines.push(`${indent}  return context.processOutput(instance) as ${typeName};`);
+        lines.push(`${indent}}`);
+        lines.push(`${indent}return instance;`);
+    }
+}
+// ============================================================================
+// Polymorphic dispatch (loadKind)
+// ============================================================================
+function emitPolymorphicDispatch(parentName, dispatch, lines) {
+    lines.push(`  private static loadKind(data: Record<string, unknown>, context?: LoadContext): ${parentName} {`);
+    lines.push(`    const discriminatorValue = data["${dispatch.discriminatorField}"];`);
+    lines.push("    if (discriminatorValue !== undefined && discriminatorValue !== null) {");
+    lines.push("      const discriminator = String(discriminatorValue).toLowerCase();");
+    lines.push("      switch (discriminator) {");
+    for (const v of dispatch.variants) {
+        lines.push(`        case "${v.value}":`);
+        lines.push(`          return ${v.typeName.name}.load(data, context);`);
+    }
+    // Default handling
+    if (dispatch.defaultVariant) {
+        lines.push("        default:");
+        if (dispatch.defaultVariant.isSelfReference) {
+            lines.push(`          return new ${parentName}();`);
+        }
+        else {
+            lines.push(`          return ${dispatch.defaultVariant.typeName.name}.load(data, context);`);
+        }
+    }
+    else {
+        lines.push("        default:");
+        lines.push(`          throw new Error(\`Unknown ${parentName} discriminator value: \${discriminator}\`);`);
+    }
+    lines.push("      }");
+    lines.push("    }");
+    // Missing discriminator
+    if (dispatch.isAbstract) {
+        lines.push(`    throw new Error("Missing ${parentName} discriminator property: '${dispatch.discriminatorField}'");`);
+    }
+    else {
+        lines.push(`    return new ${parentName}();`);
+    }
+    lines.push("  }");
+    lines.push("");
+}
+// ============================================================================
+// Collection helpers (loadX / saveX)
+// ============================================================================
+function emitCollectionLoadHelper(parentName, helper, lines) {
+    const methodName = `load${capitalize(helper.propertyName)}`;
+    const elemName = helper.elementTypeName.name;
+    const firstInnerField = helper.innerFields[0] || "kind";
+    lines.push(`  static ${methodName}(data: Record<string, unknown>[] | unknown[], context?: LoadContext): ${elemName}[] {`);
+    lines.push("    if (!Array.isArray(data)) {");
+    lines.push("      // Convert dict/object format to array format");
+    lines.push("      const result: Record<string, unknown>[] = [];");
+    lines.push("      for (const [k, v] of Object.entries(data)) {");
+    lines.push("        if (typeof v === \"object\" && v !== null && !Array.isArray(v)) {");
+    lines.push(`          result.push({ name: k, ...(v as Record<string, unknown>) });`);
+    lines.push("        } else {");
+    lines.push(`          result.push({ name: k, "${firstInnerField}": v });`);
+    lines.push("        }");
+    lines.push("      }");
+    lines.push("      data = result;");
+    lines.push("    }");
+    lines.push(`    return data.map(item => ${elemName}.load(item as Record<string, unknown>, context));`);
+    lines.push("  }");
+    lines.push("");
+}
+function emitCollectionSaveHelper(parentName, helper, lines) {
+    const loadMethodName = `save${capitalize(helper.propertyName)}`;
+    const elemName = helper.elementTypeName.name;
+    lines.push(`  static ${loadMethodName}(items: ${elemName}[], context?: SaveContext): Record<string, unknown>[] | Record<string, unknown> {`);
+    lines.push("    if (!context) {");
+    lines.push("      context = new SaveContext();");
+    lines.push("    }");
+    if (helper.hasNameProperty) {
+        lines.push("");
+        lines.push('    if (context.collectionFormat === "array") {');
+        lines.push("      return items.map(item => item.save(context));");
+        lines.push("    }");
+        lines.push("");
+        lines.push("    // Object format: use name as key");
+        lines.push("    const result: Record<string, unknown> = {};");
+        lines.push("    for (const item of items) {");
+        lines.push("      const itemData = item.save(context) as Record<string, unknown>;");
+        lines.push('      const name = itemData["name"] as string | undefined;');
+        lines.push('      delete itemData["name"];');
+        lines.push("      if (name) {");
+        lines.push("        // Check if we can use shorthand (only primary property set)");
+        lines.push(`        const shorthand = (item.constructor as typeof ${elemName}).shorthandProperty;`);
+        lines.push("        if (context.useShorthand && shorthand && Object.keys(itemData).length === 1 && shorthand in itemData) {");
+        lines.push("          result[name] = itemData[shorthand];");
+        lines.push("          continue;");
+        lines.push("        }");
+        lines.push("        result[name] = itemData;");
+        lines.push("      } else {");
+        lines.push("        // No name, fall back to array format for this item");
+        lines.push('        if (!result["_unnamed"]) {');
+        lines.push('          result["_unnamed"] = [];');
+        lines.push("        }");
+        lines.push('        (result["_unnamed"] as unknown[]).push(itemData);');
+        lines.push("      }");
+        lines.push("    }");
+        lines.push("    return result;");
+    }
+    else {
+        lines.push("");
+        lines.push("    // This type doesn't have a 'name' property, so always use array format");
+        lines.push("    return items.map(item => item.save(context));");
+    }
+    lines.push("  }");
+    lines.push("");
+}
+// ============================================================================
+// save() method
+// ============================================================================
+function emitSaveMethod(type, lines) {
+    const name = type.typeName.name;
+    lines.push("  save(context?: SaveContext): Record<string, unknown> {");
+    lines.push("    let obj: this = this;");
+    lines.push("    if (context) {");
+    lines.push(`      obj = context.processObject(obj) as this;`);
+    lines.push("    }");
+    lines.push("");
+    if (type.save.hasBase) {
+        lines.push("    // Start with parent class properties");
+        lines.push("    const result = super.save(context);");
+    }
+    else {
+        lines.push("    const result: Record<string, unknown> = {};");
+    }
+    lines.push("");
+    // Per-property save assignments
+    for (const a of type.save.assignments) {
+        if (a.isOptional) {
+            lines.push(`    if (obj.${a.fieldName} !== undefined && obj.${a.fieldName} !== null) {`);
+            lines.push(`      ${emitSaveAssignment(a)}`);
+            lines.push("    }");
+        }
+        else {
+            lines.push(`    if (obj.${a.fieldName} !== undefined && obj.${a.fieldName} !== null) {`);
+            lines.push(`      ${emitSaveAssignment(a)}`);
+            lines.push("    }");
+        }
+    }
+    // Context post-processing (only for root types without base)
+    if (!type.save.hasBase) {
+        lines.push("");
+        lines.push("    if (context) {");
+        lines.push("      return context.processDict(result);");
+        lines.push("    }");
+    }
+    lines.push("    return result;");
+    lines.push("  }");
+    lines.push("");
+}
+function emitSaveAssignment(a) {
+    const cat = a.category;
+    switch (cat.kind) {
+        case "scalar":
+        case "dict":
+        case "collection_scalar":
+            return `result["${a.targetName}"] = obj.${a.fieldName};`;
+        case "collection_complex":
+            return `result["${a.targetName}"] = ${a.parentTypeName}.save${capitalize(a.fieldName)}(obj.${a.fieldName}, context);`;
+        case "complex":
+            return `result["${a.targetName}"] = obj.${a.fieldName}.save(context);`;
+    }
+}
+// ============================================================================
+// toWire() method
+// ============================================================================
+function emitToWireMethod(type, lines) {
+    const wire = type.wire;
+    lines.push("  toWire(provider: string): Record<string, unknown> {");
+    lines.push("    const data = this.save();");
+    lines.push("    const result: Record<string, unknown> = {};");
+    lines.push("    const wireMap: Record<string, Record<string, string>> = {");
+    for (const mapping of wire.mappings) {
+        const entries = Object.entries(mapping.wireNames)
+            .map(([prov, wireName]) => `"${prov}": "${wireName}"`)
+            .join(", ");
+        lines.push(`      "${mapping.fieldName}": { ${entries} },`);
+    }
+    lines.push("    };");
+    lines.push("    for (const [key, value] of Object.entries(data)) {");
+    lines.push("      const mapping = wireMap[key];");
+    lines.push("      if (mapping?.[provider]) {");
+    lines.push("        result[mapping[provider]] = value;");
+    lines.push("      }");
+    lines.push("    }");
+    lines.push("    return result;");
+    lines.push("  }");
+    lines.push("");
+}
+// ============================================================================
+// toYaml() / toJson()
+// ============================================================================
+function emitToYaml(name, lines) {
+    lines.push("  toYaml(context?: SaveContext): string {");
+    lines.push("    context = context ?? new SaveContext();");
+    lines.push("    return context.toYaml(this.save(context));");
+    lines.push("  }");
+    lines.push("");
+}
+function emitToJson(name, lines) {
+    lines.push("  toJson(context?: SaveContext, indent: number = 2): string {");
+    lines.push("    context = context ?? new SaveContext();");
+    lines.push("    return context.toJson(this.save(context), indent);");
+    lines.push("  }");
+    lines.push("");
+}
+// ============================================================================
+// fromJson() / fromYaml()
+// ============================================================================
+function emitFromJson(name, type, lines) {
+    lines.push(`  static fromJson(json: string, context?: LoadContext): ${name} {`);
+    lines.push("    const data = JSON.parse(json);");
+    if (type.load.coercions.length > 0) {
+        // Pass raw parsed value directly to load() — it handles typeof coercions
+        lines.push(`    return ${name}.load(data as Record<string, unknown>, context);`);
+    }
+    else {
+        lines.push(`    return ${name}.load(data as Record<string, unknown>, context);`);
+    }
+    lines.push("  }");
+    lines.push("");
+}
+function emitFromYaml(name, type, lines) {
+    lines.push(`  static fromYaml(yaml: string, context?: LoadContext): ${name} {`);
+    lines.push('    const { parse } = require("yaml");');
+    lines.push("    const data = parse(yaml);");
+    if (type.load.coercions.length > 0) {
+        // Pass raw parsed value directly to load() — it handles typeof coercions
+        lines.push(`    return ${name}.load(data as Record<string, unknown>, context);`);
+    }
+    else {
+        lines.push(`    return ${name}.load(data as Record<string, unknown>, context);`);
+    }
+    lines.push("  }");
+    lines.push("");
+}
+// ============================================================================
+// Factory methods
+// ============================================================================
+function emitFactory(parentName, factory, visitor, lines) {
+    const params = Object.entries(factory.params)
+        .map(([pName, pType]) => `${pName}: ${paramType(pType)}`)
+        .join(", ");
+    lines.push(`  static ${factory.name}(${params}): ${parentName} {`);
+    lines.push(`    return ${visitor.visitExpr(factory.body)};`);
+    lines.push("  }");
+    lines.push("");
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+/** Capitalize first letter (camelCase → PascalCase for method names). */
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+//# sourceMappingURL=emitter.js.map