@kurotako/gen-angular 0.1.0

package/dist/index.js

@@ -0,0 +1,847 @@
+// src/errors.ts
+var AngularGenError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = new.target.name;
+    this.code = code;
+  }
+};
+var MissingZodSymbolError = class extends AngularGenError {
+  entityKey;
+  role;
+  constructor(entityKey2, role) {
+    super(
+      "angular_missing_zod_symbol",
+      `Zod artifact for '${entityKey2}' has no '${role}' symbol; regenerate with a gen-zod version that exposes it`
+    );
+    this.entityKey = entityKey2;
+    this.role = role;
+  }
+};
+var MissingZodNamespaceError = class extends AngularGenError {
+  namespace;
+  constructor(namespace) {
+    super(
+      "angular_missing_zod_namespace",
+      `Zod artifact has no 'extra.perNamespace[${JSON.stringify(namespace)}]' entry`
+    );
+    this.namespace = namespace;
+  }
+};
+
+// src/generator.ts
+import { defineGenerator } from "@kurotako/config";
+
+// src/artifact.ts
+import { iterEntities } from "@kurotako/ir";
+
+// src/names.ts
+function lowerFirst(s) {
+  return s.length === 0 ? s : s.charAt(0).toLowerCase() + s.slice(1);
+}
+function controlsTypeName(entity, variant, family = "") {
+  return `${entity}${variant}${family}FormControls`;
+}
+function formTypeName(entity, variant, family = "") {
+  return `${entity}${variant}${family}Form`;
+}
+function factoryName(entity) {
+  return `${entity}FormFactory`;
+}
+function factoryMethod(variant) {
+  return `create${variant}Form`;
+}
+function relationBuilderMethod(relationName, variant) {
+  const cap = `${relationName.charAt(0).toUpperCase()}${relationName.slice(1)}`;
+  return `add${cap}${variant}`;
+}
+function signalSchemaName(entity, variant) {
+  return `${lowerFirst(entity)}${variant}FormSchema`;
+}
+function modelFactoryName(entity, variant) {
+  return `create${entity}${variant}Model`;
+}
+function signalFormFactoryName(entity, variant) {
+  return `create${entity}${variant}Form`;
+}
+function entityModule(namespace, entity) {
+  return `${namespace}/angular/${entity}.form`;
+}
+function runtimeModule(namespace) {
+  return `${namespace}/angular/zod-forms.runtime`;
+}
+function barrelModule(namespace) {
+  return `${namespace}/angular`;
+}
+
+// src/zod-artifact.ts
+function entityKey(namespace, entity) {
+  return `${namespace}.${entity}`;
+}
+function zodEntity(zod, namespace, entity) {
+  const key = entityKey(namespace, entity);
+  const entry = zod.entities[key];
+  if (entry === void 0) {
+    throw new MissingZodSymbolError(key, "<entity>");
+  }
+  return entry;
+}
+function zodSymbol(zod, namespace, entity, role) {
+  const key = entityKey(namespace, entity);
+  const entry = zodEntity(zod, namespace, entity);
+  const id = entry.symbols[role];
+  if (id === void 0) {
+    throw new MissingZodSymbolError(key, role);
+  }
+  return id;
+}
+function zodModule(zod, namespace, entity) {
+  return zodEntity(zod, namespace, entity).module;
+}
+function zodExtra(zod) {
+  return zod.extra;
+}
+function zodNamespaceExtra(zod, namespace) {
+  const per = zodExtra(zod).perNamespace[namespace];
+  if (per === void 0) {
+    throw new MissingZodNamespaceError(namespace);
+  }
+  return per;
+}
+function zodEnum(zod, namespace, ref) {
+  const per = zodNamespaceExtra(zod, namespace);
+  const def = per.enums[ref];
+  if (def === void 0) {
+    throw new MissingZodSymbolError(`${namespace}.<enum>`, ref);
+  }
+  return { typeName: def.typeName, module: def.module };
+}
+
+// src/artifact.ts
+function entitySymbols(entityName, options) {
+  const symbols = {};
+  const deep = options.relations === "deep";
+  const family = deep ? "Deep" : "";
+  if (options.forms.includes("reactive")) {
+    const createControls = controlsTypeName(entityName, "Create", family);
+    const createForm = formTypeName(entityName, "Create", family);
+    const updateControls = controlsTypeName(entityName, "Update", family);
+    const updateForm = formTypeName(entityName, "Update", family);
+    symbols.createControls = createControls;
+    symbols.createForm = createForm;
+    symbols.updateControls = updateControls;
+    symbols.updateForm = updateForm;
+    symbols.factory = factoryName(entityName);
+    if (deep) {
+      symbols.createDeepControls = createControls;
+      symbols.createDeepForm = createForm;
+      symbols.updateDeepControls = updateControls;
+      symbols.updateDeepForm = updateForm;
+    }
+  }
+  if (options.forms.includes("signal")) {
+    symbols.createSchema = signalSchemaName(entityName, "Create");
+    symbols.updateSchema = signalSchemaName(entityName, "Update");
+    symbols.createModel = modelFactoryName(entityName, "Create");
+    symbols.updateModel = modelFactoryName(entityName, "Update");
+    symbols.createSignalForm = signalFormFactoryName(entityName, "Create");
+    symbols.updateSignalForm = signalFormFactoryName(entityName, "Update");
+  }
+  return symbols;
+}
+function buildArtifact(ir, zod, options) {
+  const entities = {};
+  for (const { namespace, entity } of iterEntities(ir)) {
+    entities[`${namespace}.${entity.name}`] = {
+      module: entityModule(namespace, entity.name),
+      symbols: entitySymbols(entity.name, options)
+    };
+  }
+  const perNamespace = {};
+  for (const namespace of Object.keys(ir.sources)) {
+    perNamespace[namespace] = {
+      runtimeModule: runtimeModule(namespace),
+      barrelModule: barrelModule(namespace)
+    };
+  }
+  const extra = {
+    forms: options.forms,
+    relations: options.relations,
+    zodVersion: zodExtra(zod).zodVersion,
+    perNamespace
+  };
+  const peerDependencies = options.forms.includes("signal") ? { "@angular/core": ">=22", "@angular/forms": ">=22" } : { "@angular/core": ">=17", "@angular/forms": ">=17" };
+  return { entities, peerDependencies, extra };
+}
+
+// src/emit/barrel.ts
+function emitBarrel(source, options) {
+  const lines = [];
+  const entities = Object.values(source.entities);
+  if (entities.length > 0 && options.forms.length > 0) {
+    lines.push("export * from './zod-forms.runtime';");
+  }
+  for (const entity of entities) {
+    lines.push(`export * from './${entity.name}.form';`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/render/imports.ts
+var ImportsRecorder = class {
+  values = /* @__PURE__ */ new Map();
+  types = /* @__PURE__ */ new Map();
+  value(module, name) {
+    add(this.values, module, name);
+  }
+  type(module, name) {
+    add(this.types, module, name);
+  }
+  /** The full `import ...` block text, one statement per line, no trailing blank line. */
+  render() {
+    const lines = [];
+    for (const [spec, names] of this.values) {
+      lines.push({ spec, rank: 0, stmt: importStmt(spec, [...names], false) });
+    }
+    for (const [spec, names] of this.types) {
+      lines.push({ spec, rank: 1, stmt: importStmt(spec, [...names], true) });
+    }
+    lines.sort((a, b) => a.spec.localeCompare(b.spec) || a.rank - b.rank);
+    return lines.map((l) => l.stmt).join("\n");
+  }
+};
+function add(map, module, name) {
+  const set = map.get(module) ?? /* @__PURE__ */ new Set();
+  set.add(name);
+  map.set(module, set);
+}
+function importStmt(spec, names, typeOnly) {
+  const sorted = [...names].sort((a, b) => a.localeCompare(b)).join(", ");
+  const kw = typeOnly ? "import type" : "import";
+  return `${kw} { ${sorted} } from '${spec}';`;
+}
+
+// src/render/controls.ts
+import { resolveEnum } from "@kurotako/ir";
+var SCALAR_BASE = {
+  string: "string",
+  uuid: "string",
+  decimal: "string",
+  bytes: "string",
+  int: "number",
+  float: "number",
+  bigint: "bigint",
+  boolean: "boolean",
+  date: "Date",
+  datetime: "Date",
+  json: "unknown"
+};
+function baseType(field, zodEnumTypeName) {
+  switch (field.type.kind) {
+    case "scalar":
+      return SCALAR_BASE[field.type.scalar];
+    case "enum":
+      return zodEnumTypeName(field.type.ref);
+    case "unknown":
+      return "unknown";
+  }
+}
+function controlType(field, zodEnumTypeName) {
+  let t = baseType(field, zodEnumTypeName);
+  if (field.list) {
+    t = `${t}[]`;
+  }
+  if (field.nullable) {
+    t = `${t} | null`;
+  }
+  return t;
+}
+function enumZeroFromSource(source, entity) {
+  return (ref) => resolveEnum(source, entity, ref)?.values[0]?.name;
+}
+function zeroValue(field, enumZero) {
+  if (field.type.kind === "scalar") {
+    switch (field.type.scalar) {
+      case "string":
+      case "uuid":
+      case "decimal":
+      case "bytes":
+        return "''";
+      case "int":
+      case "float":
+        return "0";
+      case "bigint":
+        return "0n";
+      case "boolean":
+        return "false";
+      case "date":
+      case "datetime":
+        return "new Date(0)";
+      case "json":
+        return "undefined";
+    }
+  }
+  if (field.type.kind === "enum") {
+    const value = enumZero?.(field.type.ref);
+    return value === void 0 ? "undefined" : JSON.stringify(value);
+  }
+  return "undefined";
+}
+function initExpr(field, enumZero) {
+  if (field.list) {
+    return field.default?.kind === "value" ? JSON.stringify(field.default.value) : "[]";
+  }
+  if (field.default?.kind === "value") {
+    return JSON.stringify(field.default.value);
+  }
+  if (field.nullable) {
+    return "null";
+  }
+  return zeroValue(field, enumZero);
+}
+function controlExpr(field, typeArg, sourceExpr) {
+  if (field.nullable) {
+    return `new FormControl<${typeArg}>(${sourceExpr})`;
+  }
+  return `new FormControl(${sourceExpr}, { nonNullable: true })`;
+}
+function fieldControlEntry(field, zodEnumTypeName) {
+  return {
+    name: field.name,
+    fullType: `FormControl<${controlType(field, zodEnumTypeName)}>`
+  };
+}
+function controlsInterface(interfaceName, entries) {
+  if (entries.length === 0) {
+    return `export interface ${interfaceName} {}`;
+  }
+  const body = entries.map((e) => `  ${e.name}: ${e.fullType};`).join("\n");
+  return `export interface ${interfaceName} {
+${body}
+}`;
+}
+
+// src/render/relations.ts
+import { isCrossSource } from "@kurotako/ir";
+function deepRelations(entity, variant, namespace, logger) {
+  const out = [];
+  for (const relation of entity.relations) {
+    if (isCrossSource(namespace, relation)) {
+      logger?.debug(
+        `gen-angular: relation '${relation.name}' targets another source ('${relation.target.namespace}.${relation.target.entity}'); degrading to the flat FK scalar in deep mode`
+      );
+      continue;
+    }
+    const many = relation.cardinality === "many";
+    const targetControls = controlsTypeName(
+      relation.target.entity,
+      variant,
+      "Deep"
+    );
+    const targetFormType = formTypeName(
+      relation.target.entity,
+      variant,
+      "Deep"
+    );
+    const groupType = `FormGroup<${targetControls}>`;
+    const fullType = many ? `FormArray<${groupType}>` : groupType;
+    out.push({
+      relation,
+      many,
+      entry: { name: relation.name, fullType },
+      targetFormType,
+      builderMethod: relationBuilderMethod(relation.name, variant)
+    });
+  }
+  return out;
+}
+
+// src/render/variants.ts
+import { createFields, updateFields } from "@kurotako/ir";
+function variantFields(entity, variant) {
+  return variant === "Create" ? createFields(entity) : updateFields(entity);
+}
+
+// src/render/reactive.ts
+function lowerFirst2(s) {
+  return s.length === 0 ? s : s.charAt(0).toLowerCase() + s.slice(1);
+}
+function reactiveEntity(entity, namespace, source, options, zod, imports, logger) {
+  const deep = options.relations === "deep";
+  const enumZero = enumZeroFromSource(source, entity);
+  imports.value("@angular/core", "Injectable");
+  imports.value("@angular/forms", "FormControl");
+  imports.value("@angular/forms", "FormGroup");
+  const zodEnumTypeName = (ref) => {
+    const e = zodEnum(zod, namespace, ref);
+    imports.type(e.module, e.typeName);
+    return e.typeName;
+  };
+  const blocks = [];
+  const injectedFactories = /* @__PURE__ */ new Map();
+  for (const variant of ["Create", "Update"]) {
+    const family = deep ? "Deep" : "";
+    const schemaRole = deep ? variant === "Create" ? "createDeepSchema" : "updateDeepSchema" : variant === "Create" ? "createSchema" : "updateSchema";
+    const typeRole = deep ? variant === "Create" ? "createDeepType" : "updateDeepType" : variant === "Create" ? "createType" : "updateType";
+    const module = zodModule(zod, namespace, entity.name);
+    const schemaId = zodSymbol(zod, namespace, entity.name, schemaRole);
+    const typeId = zodSymbol(zod, namespace, entity.name, typeRole);
+    imports.value(module, schemaId);
+    imports.type(module, typeId);
+    imports.value(`${namespace}/angular/zod-forms.runtime`, "zodValidator");
+    const interfaceName = controlsTypeName(entity.name, variant, family);
+    const formType = formTypeName(entity.name, variant, family);
+    const fieldEntries = variantFields(entity, variant).map(
+      (field) => fieldControlEntry(field, zodEnumTypeName)
+    );
+    const relations = deep ? deepRelations(entity, variant, namespace, logger) : [];
+    const manyRelations = relations.filter((r) => r.many);
+    if (manyRelations.length > 0) {
+      imports.value("@angular/forms", "FormArray");
+    }
+    for (const rel of relations) {
+      const targetModule = `${namespace}/angular/${rel.relation.target.entity}.form`;
+      imports.type(
+        targetModule,
+        controlsTypeName(rel.relation.target.entity, variant, "Deep")
+      );
+      imports.type(targetModule, rel.targetFormType);
+      if (!injectedFactories.has(rel.relation.target.entity)) {
+        const paramName = `${lowerFirst2(rel.relation.target.entity)}FormFactory`;
+        injectedFactories.set(rel.relation.target.entity, paramName);
+        imports.value(targetModule, factoryName(rel.relation.target.entity));
+      }
+      if (rel.many) {
+        const targetTypeRole = deep && variant === "Create" ? "createDeepType" : deep && variant === "Update" ? "updateDeepType" : variant === "Create" ? "createType" : "updateType";
+        const targetZodModule = zodModule(
+          zod,
+          namespace,
+          rel.relation.target.entity
+        );
+        const targetTypeId = zodSymbol(
+          zod,
+          namespace,
+          rel.relation.target.entity,
+          targetTypeRole
+        );
+        imports.type(targetZodModule, targetTypeId);
+      }
+    }
+    blocks.push(
+      controlsInterface(interfaceName, [
+        ...fieldEntries,
+        ...relations.map((r) => r.entry)
+      ])
+    );
+    blocks.push(`export type ${formType} = FormGroup<${interfaceName}>;`);
+  }
+  blocks.push(
+    renderFactoryClass(
+      entity,
+      namespace,
+      options,
+      zod,
+      injectedFactories,
+      enumZero
+    )
+  );
+  return blocks.join("\n\n");
+}
+function renderFactoryClass(entity, namespace, options, zod, injectedFactories, enumZero) {
+  const deep = options.relations === "deep";
+  const className = factoryName(entity.name);
+  const ctorParams = [...injectedFactories.entries()].map(
+    ([target, param]) => `private readonly ${param}: ${factoryName(target)}`
+  ).join(", ");
+  const ctor = ctorParams.length > 0 ? `
+  constructor(${ctorParams}) {}
+` : "";
+  const methods = [];
+  for (const variant of ["Create", "Update"]) {
+    methods.push(
+      renderFactoryMethod(
+        entity,
+        namespace,
+        variant,
+        options,
+        zod,
+        injectedFactories,
+        enumZero
+      )
+    );
+  }
+  if (deep) {
+    for (const variant of ["Create", "Update"]) {
+      const relations = deepRelations(
+        entity,
+        variant,
+        namespace,
+        void 0
+      ).filter((r) => r.many);
+      for (const rel of relations) {
+        methods.push(
+          renderBuilderMethod(
+            entity,
+            namespace,
+            variant,
+            options,
+            zod,
+            rel,
+            injectedFactories
+          )
+        );
+      }
+    }
+  }
+  const body = [
+    ctor,
+    ...methods.map((m) => `
+  ${m.split("\n").join("\n  ")}
+`)
+  ].join("").trimEnd();
+  return `@Injectable({ providedIn: 'root' })
+export class ${className} {
+${body}
+}`;
+}
+function renderFactoryMethod(entity, namespace, variant, options, zod, injectedFactories, enumZero) {
+  const deep = options.relations === "deep";
+  const family = deep ? "Deep" : "";
+  const typeRole = deep && variant === "Create" ? "createDeepType" : deep && variant === "Update" ? "updateDeepType" : variant === "Create" ? "createType" : "updateType";
+  const schemaRole = deep && variant === "Create" ? "createDeepSchema" : deep && variant === "Update" ? "updateDeepSchema" : variant === "Create" ? "createSchema" : "updateSchema";
+  const typeId = zodSymbol(zod, namespace, entity.name, typeRole);
+  const schemaId = zodSymbol(zod, namespace, entity.name, schemaRole);
+  const interfaceName = controlsTypeName(entity.name, variant, family);
+  const formType = formTypeName(entity.name, variant, family);
+  const methodName = factoryMethod(variant);
+  const zodEnumTypeName = (ref) => ref;
+  const fields = variantFields(entity, variant);
+  const lines = fields.map((field) => {
+    const typeArg = controlType(field, zodEnumTypeName);
+    const accessor = variant === "Create" ? `init?.${field.name}` : `value.${field.name}`;
+    const source = `${accessor} ?? ${initExpr(field, enumZero)}`;
+    return `    ${field.name}: ${controlExpr(field, typeArg, source)},`;
+  });
+  const relations = deep ? deepRelations(entity, variant, namespace, void 0) : [];
+  const relationLines = relations.map((r) => {
+    if (r.many) {
+      const targetControls = controlsTypeName(
+        r.relation.target.entity,
+        variant,
+        "Deep"
+      );
+      return `    ${r.entry.name}: new FormArray<FormGroup<${targetControls}>>([]),`;
+    }
+    const factoryParam = injectedFactories.get(r.relation.target.entity) ?? `${lowerFirst2(r.relation.target.entity)}FormFactory`;
+    const nestedArg = variant === "Create" ? `init?.${r.relation.name}` : `value.${r.relation.name}!`;
+    return `    ${r.entry.name}: this.${factoryParam}.${factoryMethod(variant)}(${nestedArg}),`;
+  });
+  const groupBody = [...lines, ...relationLines].join("\n");
+  const paramList = variant === "Create" ? `init?: Partial<${typeId}>` : `value: ${typeId}`;
+  return `${methodName}(${paramList}): ${formType} {
+  return new FormGroup<${interfaceName}>({
+${groupBody}
+  }, { validators: [zodValidator(${schemaId})] });
+}`;
+}
+function renderBuilderMethod(entity, namespace, variant, options, zod, rel, injectedFactories) {
+  const deep = options.relations === "deep";
+  const target = rel.relation.target.entity;
+  const factoryParam = injectedFactories.get(target) ?? `${lowerFirst2(target)}FormFactory`;
+  const formType = formTypeName(entity.name, variant, "Deep");
+  const targetFormType = rel.targetFormType;
+  const method = rel.builderMethod;
+  const targetTypeRole = deep && variant === "Create" ? "createDeepType" : deep && variant === "Update" ? "updateDeepType" : variant === "Create" ? "createType" : "updateType";
+  const targetTypeId = zodSymbol(zod, namespace, target, targetTypeRole);
+  const param = variant === "Create" ? `init?: Partial<${targetTypeId}>` : `value: ${targetTypeId}`;
+  const createCall = `this.${factoryParam}.${factoryMethod(variant)}(${variant === "Create" ? "init" : "value"})`;
+  return `${method}(form: ${formType}, ${param}): ${targetFormType} {
+  const group = ${createCall};
+  form.controls.${rel.relation.name}.push(group);
+  return group;
+}`;
+}
+
+// src/render/signal.ts
+function signalEntity(entity, namespace, source, options, zod, imports, logger) {
+  const deep = options.relations === "deep";
+  const enumZero = enumZeroFromSource(source, entity);
+  imports.value("@angular/forms/signals", "schema");
+  imports.value("@angular/forms/signals", "form");
+  imports.type("@angular/forms/signals", "FieldTree");
+  imports.value("@angular/core", "signal");
+  const blocks = [];
+  for (const variant of ["Create", "Update"]) {
+    const typeRole = deep && variant === "Create" ? "createDeepType" : deep && variant === "Update" ? "updateDeepType" : variant === "Create" ? "createType" : "updateType";
+    const schemaRole = deep && variant === "Create" ? "createDeepSchema" : deep && variant === "Update" ? "updateDeepSchema" : variant === "Create" ? "createSchema" : "updateSchema";
+    const module = zodModule(zod, namespace, entity.name);
+    const typeId = zodSymbol(zod, namespace, entity.name, typeRole);
+    const schemaId = zodSymbol(zod, namespace, entity.name, schemaRole);
+    imports.type(module, typeId);
+    imports.value(module, schemaId);
+    imports.value(`${namespace}/angular/zod-forms.runtime`, "zodTreeValidate");
+    const fields = variantFields(entity, variant);
+    const fieldLines = fields.map(
+      (field) => `    ${field.name}: init?.${field.name} ?? ${initExpr(field, enumZero)},`
+    );
+    const relations = deep ? deepRelations(entity, variant, namespace, logger) : [];
+    const relationLines = relations.map((rel) => {
+      if (rel.many) {
+        return `    ${rel.relation.name}: [],`;
+      }
+      const targetModule = `${namespace}/angular/${rel.relation.target.entity}.form`;
+      const targetModelFactory = modelFactoryName(
+        rel.relation.target.entity,
+        variant
+      );
+      imports.value(targetModule, targetModelFactory);
+      return `    ${rel.relation.name}: ${targetModelFactory}(init?.${rel.relation.name}),`;
+    });
+    const modelBody = [...fieldLines, ...relationLines].join("\n");
+    const modelName = modelFactoryName(entity.name, variant);
+    blocks.push(
+      `export function ${modelName}(init?: Partial<${typeId}>): ${typeId} {
+  return {
+${modelBody}
+  };
+}`
+    );
+    const schemaConst = signalSchemaName(entity.name, variant);
+    blocks.push(
+      `export const ${schemaConst} = schema<${typeId}>((path) => {
+  zodTreeValidate(path, ${schemaId});
+});`
+    );
+    const formFactoryName = signalFormFactoryName(entity.name, variant);
+    blocks.push(
+      `export function ${formFactoryName}(init?: Partial<${typeId}>): FieldTree<${typeId}> {
+  return form(signal(${modelName}(init)), ${schemaConst});
+}`
+    );
+  }
+  return blocks.join("\n\n");
+}
+
+// src/emit/entity.ts
+function emitEntity(entity, namespace, source, options, zod, logger) {
+  const imports = new ImportsRecorder();
+  const blocks = [];
+  if (options.forms.includes("reactive")) {
+    blocks.push(
+      reactiveEntity(entity, namespace, source, options, zod, imports, logger)
+    );
+  }
+  if (options.forms.includes("signal")) {
+    blocks.push(
+      signalEntity(entity, namespace, source, options, zod, imports, logger)
+    );
+  }
+  const importBlock = imports.render();
+  return `${[importBlock, "", ...blocks].join("\n").trimEnd()}
+`;
+}
+
+// src/emit/runtime.ts
+var ZOD_VALIDATOR = `export function zodValidator(schema: ZodType): ValidatorFn {
+  return (group: AbstractControl) => {
+    const result = schema.safeParse(group.getRawValue());
+    const touched = new Set<AbstractControl>();
+    const rootIssues: { path: (string | number)[]; message: string }[] = [];
+
+    if (!result.success) {
+      for (const issue of result.error.issues) {
+        const path = issue.path.map(String).join('.');
+        const control = path === '' ? null : group.get(path);
+        if (control !== null && control !== undefined) {
+          setZodError(control, issue.message);
+          touched.add(control);
+        } else {
+          rootIssues.push({ path: issue.path as (string | number)[], message: issue.message });
+        }
+      }
+    }
+
+    for (const control of collectControls(group)) {
+      if (control !== group && !touched.has(control)) {
+        clearZodError(control);
+      }
+    }
+
+    if (rootIssues.length === 0) {
+      clearZodError(group);
+      return null;
+    }
+
+    const formErrors: string[] = [];
+    const fieldErrors: Record<string, string[]> = {};
+    for (const issue of rootIssues) {
+      if (issue.path.length === 0) {
+        formErrors.push(issue.message);
+      } else {
+        const key = String(issue.path[0]);
+        (fieldErrors[key] ??= []).push(issue.message);
+      }
+    }
+
+    const zodError = { formErrors, fieldErrors };
+    setZodError(group, zodError);
+    return { zod: zodError };
+  };
+}
+
+function setZodError(control: AbstractControl, message: unknown): void {
+  const current = control.errors;
+  if (current !== null && sameZodError(current.zod, message)) {
+    return;
+  }
+  control.setErrors({ ...current, zod: message }, { emitEvent: false });
+}
+
+function clearZodError(control: AbstractControl): void {
+  const current = control.errors;
+  if (current === null || current === undefined || !('zod' in current)) {
+    return;
+  }
+  const { zod: _discard, ...rest } = current;
+  control.setErrors(Object.keys(rest).length > 0 ? rest : null, {
+    emitEvent: false,
+  });
+}
+
+function sameZodError(a: unknown, b: unknown): boolean {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+function collectControls(control: AbstractControl): AbstractControl[] {
+  const out: AbstractControl[] = [control];
+  const children = (control as { controls?: unknown }).controls;
+  if (children !== null && typeof children === 'object') {
+    for (const child of Object.values(children as Record<string, AbstractControl>)) {
+      out.push(...collectControls(child));
+    }
+  }
+  return out;
+}`;
+var ZOD_TREE_VALIDATE = `export function zodTreeValidate<T>(
+  path: SchemaPath<T>,
+  schema: ZodType<T>,
+): void {
+  validateTree(path, (ctx) => {
+    const result = schema.safeParse(ctx.value());
+    if (result.success) {
+      return undefined;
+    }
+    return result.error.issues.map((issue) => ({
+      kind: 'custom' as const,
+      message: issue.message,
+      // Dynamically walked from the Zod issue path against the field tree's
+      // runtime shape; ValidationError.fieldTree accepts undefined for a
+      // pathless issue, so a same-shaped object (rather than branching on
+      // whether one was found) keeps this a single, uniform return type.
+      fieldTree: resolveFieldTree(ctx.fieldTree, issue.path) as
+        | ReadonlyFieldTree<unknown>
+        | undefined,
+    }));
+  });
+}
+
+function resolveFieldTree(root: unknown, path: readonly PropertyKey[]): unknown {
+  return path.reduce<unknown>((node, key) => {
+    if (node === null || typeof node !== 'object') {
+      return undefined;
+    }
+    return (node as Record<PropertyKey, unknown>)[key];
+  }, root);
+}`;
+function emitRuntime(_source, options) {
+  const reactive = options.forms.includes("reactive");
+  const signal = options.forms.includes("signal");
+  const imports = [];
+  if (reactive) {
+    imports.push(
+      "import type { AbstractControl, ValidatorFn } from '@angular/forms';"
+    );
+  }
+  if (signal) {
+    imports.push(
+      "import type { ReadonlyFieldTree, SchemaPath } from '@angular/forms/signals';",
+      "import { validateTree } from '@angular/forms/signals';"
+    );
+  }
+  imports.push("import type { ZodType } from 'zod';");
+  const blocks = [];
+  if (reactive) {
+    blocks.push(ZOD_VALIDATOR);
+  }
+  if (signal) {
+    blocks.push(ZOD_TREE_VALIDATE);
+  }
+  return `${[imports.join("\n"), "", ...blocks].join("\n").trimEnd()}
+`;
+}
+
+// src/options.ts
+import * as v from "valibot";
+var AngularGeneratorOptions = v.object({
+  /** Which form surfaces to emit. Default: both. */
+  forms: v.optional(v.array(v.picklist(["reactive", "signal"])), [
+    "reactive",
+    "signal"
+  ]),
+  /** Relation handling: flat (FK scalars only) or deep (nested FormGroup / FormArray). */
+  relations: v.optional(v.picklist(["flat", "deep"]), "flat")
+});
+
+// src/generator.ts
+var angularGenerator = defineGenerator({
+  name: "angular",
+  dependsOn: ["zod"],
+  optionsSchema: AngularGeneratorOptions,
+  generate(ctx, options) {
+    const zod = ctx.dependencies.zod;
+    if (zod === void 0) {
+      throw new Error(
+        "gen-angular: 'zod' dependency artifact is missing at runtime despite dependsOn: ['zod']"
+      );
+    }
+    const files = [];
+    for (const [namespace, source] of Object.entries(ctx.ir.sources)) {
+      const prefix = `${namespace}/angular`;
+      const entities = Object.values(source.entities);
+      if (entities.length > 0 && options.forms.length > 0) {
+        files.push({
+          path: `${prefix}/zod-forms.runtime.ts`,
+          content: emitRuntime(source, options)
+        });
+      }
+      for (const entity of entities) {
+        files.push({
+          path: `${prefix}/${entity.name}.form.ts`,
+          content: emitEntity(
+            entity,
+            namespace,
+            source,
+            options,
+            zod,
+            ctx.logger
+          )
+        });
+      }
+      files.push({
+        path: `${prefix}/index.ts`,
+        content: emitBarrel(source, options)
+      });
+    }
+    return { files, artifact: buildArtifact(ctx.ir, zod, options) };
+  }
+});
+export {
+  AngularGenError,
+  AngularGeneratorOptions,
+  MissingZodNamespaceError,
+  MissingZodSymbolError,
+  angularGenerator
+};
+//# sourceMappingURL=index.js.map