zod-to-x 1.7.0 → 1.8.0

package/README.md

@@ -27,6 +27,7 @@
   <img src="https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white" alt="Python">
   <img src="https://img.shields.io/badge/C++-00599C?style=for-the-badge&logo=cplusplus&logoColor=white" alt="C++">
   <img src="https://img.shields.io/badge/Go-00ADD8?style=for-the-badge&logo=go&logoColor=white" alt="Go">
+  <img src="https://img.shields.io/badge/Dart-0175C2?style=for-the-badge&logo=dart&logoColor=white" alt="Dart">
   <img src="https://img.shields.io/badge/Protobuf-4285F4?style=for-the-badge&logo=google&logoColor=white" alt="Protobuf">
 </p>
 
@@ -52,6 +53,7 @@
   - [2) Python](#2-python)
   - [3) C++](#3-c)
   - [4) Go](#4-go)
+  - [5) Dart](#5-dart)
 - [Additional utils](#additional-utils)
   - [1) `zod2JsonSchemaDefinitions`](#1-zod2jsonschemadefinitions)
   - [2) `zod2ProtoV3`](#2-zod2protov3)
@@ -661,6 +663,14 @@ Generates idiomatic Go structs with `encoding/json` struct tags. Requires Go 1.1
   - **useJsonTags**: Whether to emit `json:"fieldName"` struct tags. Defaults to `true`.
 - [Examples](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2go)
 
+### 5) Dart
+`json_annotation` + `json_serializable` are used for JSON serialization/deserialization. The `.g.dart` part file is generated externally by `dart run build_runner build`.
+- Options:
+  - **keepKeys**: Specifies whether property names should follow the Dart naming convention (false) or remain as originally defined (true). The default is `false`.
+  - **useJsonSerialization**: When true (default), emits `@JsonSerializable()`, `@JsonEnum`, `@JsonKey` annotations and `fromJson`/`toJson` stubs. Requires `package:json_annotation`.
+  - **partFile**: Filename (without extension) for the `part '${partFile}.g.dart'` directive. Automatically set when using layered modeling. If omitted, no `part` directive is emitted.
+- [Examples](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2dart)
+
 
 
 ## Additional utils

package/dist/layered-modeling/model.d.ts

@@ -45,5 +45,6 @@ export declare class Zod2XModel {
     transpile(target: Target<"Zod2Ts">, opt?: TargetOpt<"Zod2Ts">, astOpt?: AstOpt): string;
     transpile(target: Target<"Zod2Py">, opt?: TargetOpt<"Zod2Py">, astOpt?: AstOpt): string;
     transpile(target: Target<"Zod2Go">, opt?: TargetOpt<"Zod2Go">, astOpt?: AstOpt): string;
+    transpile(target: Target<"Zod2Dart">, opt?: TargetOpt<"Zod2Dart">, astOpt?: AstOpt): string;
 }
 export {};

package/dist/layered-modeling/model.js

@@ -59,7 +59,7 @@ class Zod2XModel {
         return this.astNodes;
     }
     transpile(target, opt = {}, astOpt) {
-        const transpilerInstance = new target(Object.assign(Object.assign({}, opt), { namespace: this.getLayerMetadata().namespace }));
+        const transpilerInstance = new target(Object.assign(Object.assign({}, opt), { namespace: this.getLayerMetadata().namespace, partFile: this.getLayerMetadata().file }));
         return transpilerInstance.transpile(this.getAstNode(astOpt));
     }
 }

package/dist/transpilers/dart/libs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Dart package imports for json_annotation / json_serializable.
+ */
+export declare function getLibs(): {
+    jsonAnnotation: string;
+};

package/dist/transpilers/dart/libs.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLibs = getLibs;
+/**
+ * Dart package imports for json_annotation / json_serializable.
+ */
+function getLibs() {
+    return {
+        jsonAnnotation: "import 'package:json_annotation/json_annotation.dart';",
+    };
+}

package/dist/transpilers/dart/options.d.ts

@@ -0,0 +1,21 @@
+import { IZodToXOpt } from "../../core";
+export interface IZod2DartOpt extends IZodToXOpt {
+    /**
+     * By default (false), class property names are converted to camelCase following Dart
+     * conventions. If set to true, the original property names are preserved as-is.
+     */
+    keepKeys?: boolean;
+    /**
+     * When true (default), emits `@JsonSerializable()` annotations, `@JsonEnum`, `@JsonKey`,
+     * and `fromJson`/`toJson` delegation stubs. Requires `package:json_annotation`.
+     * The `.g.dart` part file is generated externally by `dart run build_runner build`.
+     */
+    useJsonSerialization?: boolean;
+    /**
+     * Filename (without extension) used for the `part '${partFile}.g.dart';` directive.
+     * When using layered modeling, this is automatically set to the layer's `file` metadata.
+     * If omitted, no `part` directive is emitted.
+     */
+    partFile?: string;
+}
+export declare const defaultOpts: IZod2DartOpt;

package/dist/transpilers/dart/options.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOpts = void 0;
+exports.defaultOpts = {
+    indent: 2,
+    includeComments: true,
+    useImports: true,
+    keepKeys: false,
+    useJsonSerialization: true,
+};

package/dist/transpilers/dart/runner.d.ts

@@ -0,0 +1,149 @@
+import { ASTAliasedTypes, ASTEnum, ASTIntersection, ASTNode, ASTNodes, ASTObject, ASTUnion, Zod2X } from "../../core";
+import { IZod2DartOpt } from "./options";
+/**
+ * Transpiler for Zod schemas to Dart classes using package:json_annotation.
+ *
+ * The `.g.dart` part file is NOT generated by this transpiler — it must be produced
+ * externally via `dart run build_runner build`.
+ */
+export declare class Zod2Dart extends Zod2X<IZod2DartOpt> {
+    protected readonly commentKey = "//";
+    protected lib: {
+        jsonAnnotation: string;
+    };
+    /**
+     * Maps a local struct/class name to the discriminated union names it participates in.
+     * Populated by a pre-scan of the AST before the normal transpile pass.
+     */
+    private _unionMembers;
+    /**
+     * Names of locally-defined discriminated union abstract classes.
+     * Used to emit @JsonKey(fromJson/toJson) when such a type appears as a field.
+     */
+    private _discriminatedUnionTypes;
+    /**
+     * Names of typedef-emitted types (alias, union typedef, struct extends).
+     * When these appear as field types in @JsonSerializable classes, we emit
+     * @JsonKey(fromJson: TypeName.fromJson) to prevent json_serializable from
+     * following the typedef chain and referencing transitive imports.
+     */
+    private _typedefNames;
+    /**
+     * Maps a disc union typedef name (e.g. "NewDiscriminatedUnionItem") to the
+     * fromJson function name of the underlying entity-level union
+     * (e.g. "discriminatedUnionItemFromJson").
+     * Populated during pre-scan when an ASTUnion node has aliasOf set.
+     */
+    private _discriminatedUnionDelegateFromJson;
+    /**
+     * Unified set of type names needing custom @JsonKey annotations.
+     * - Discriminated union types: fromJson = <camelName>FromJson (local function)
+     * - Typedef types: fromJson = _<camelName>FromJson (standalone wrapper)
+     * - TypedefList: list fromJson/toJson helpers
+     * _toJson helpers are emitted in runAfter() for all entries.
+     */
+    private _usedCustomFromJsonTypes;
+    /**
+     * Maps a type name (e.g. "GenericUserEntity") to its full Dart type with
+     * template args (e.g. "GenericUserEntity<SomeDtoResult>"). Used in runAfter()
+     * to generate helpers with correct generic return types and factory calls.
+     */
+    private _usedCustomFromJsonFullTypes;
+    /**
+     * Maps a typedef name to its full extended type (the right-hand side of the
+     * typedef). E.g. "AdminUserEntity" → "GenericUserEntity<AdminUserMetadata>".
+     * Populated in addExtendedType() when the extended type has generic args.
+     * Used in runAfter() to generate 2-arg fromJson calls for generic classes.
+     */
+    private _typedefToExtendedType;
+    constructor(opt?: IZod2DartOpt);
+    /**
+     * Overrides transpile() to pre-scan discriminated union memberships before the normal pass.
+     * This allows transpileStruct() to emit `implements UnionName` on member classes.
+     */
+    transpile(transpilerQueue: ASTNodes): string;
+    protected runBefore(): void;
+    protected runAfter(): void;
+    protected addImportFromFile(filename: string, _namespace: string): string;
+    protected getTypeFromExternalNamespace(_namespace: string, typeName: string): string;
+    protected getGenericTemplatesTranslation(data: ASTNode): string | undefined;
+    /**
+     * Emits an alias/extension declaration for cross-layer references.
+     */
+    protected checkExtendedTypeInclusion(data: ASTNode, type?: "union" | "alias"): boolean;
+    protected addExtendedType(name: string, parentNamespace: string, aliasOf: string, opt?: {
+        type?: "union" | "alias";
+        isInternal?: boolean;
+        templates?: string;
+        declaredTemplates?: string;
+    }): void;
+    protected getStringType: () => string;
+    protected getBooleanType: () => string;
+    protected getAnyType: () => string;
+    protected getDateType: () => string;
+    protected getNumberType(isInt: boolean, _range: {
+        min?: number;
+        max?: number;
+    }): string;
+    /**
+     * Returns the Dart type for a literal value.
+     * Dart has no structural literal types, so we return the underlying primitive type.
+     * When a parent enum is provided, returns the enum type name (not a member expression),
+     * since Dart enum members cannot be used as types.
+     */
+    protected getLiteralStringType(value: string | number | boolean, parentEnumNameKey?: [string, string]): string | number;
+    /** Ex: List<List<T>> for 2D array */
+    protected getArrayType(arrayType: string, arrayDeep: number): string;
+    /** Ex: Set<T> */
+    protected getSetType: (itemType: string) => string;
+    /** Ex: Map<K, V> */
+    protected getMapType: (keyType: string, valueType: string) => string;
+    /** Ex: Map<String, V> (record key is always String) */
+    protected getRecordType: (keyType: string, valueType: string) => string;
+    /** Ex: (T1, T2, T3) — Dart 3 positional record type */
+    protected getTupleType: (itemsType: string[]) => string;
+    /** Dart has no native union type; use Object */
+    protected getUnionType: (_itemsType: string[]) => string;
+    /** Dart has no native intersection type; use Object */
+    protected getIntersectionType: (_itemsType: string[]) => string;
+    protected transpileAliasedType(data: ASTAliasedTypes): void;
+    /**
+     * Emits a Dart enhanced enum with a typed `value` field and `@JsonEnum` annotation.
+     *
+     * All-string values:
+     *   @JsonEnum(valueField: 'value')
+     *   enum EnumItem {
+     *     enum1('Enum1'),
+     *     enum2('Enum2');
+     *
+     *     const EnumItem(this.value);
+     *     final String value;
+     *   }
+     *
+     * Mixed (int + string): typedef alias with comment.
+     */
+    protected transpileEnum(data: ASTEnum): void;
+    protected transpileStruct(data: ASTObject): void;
+    /**
+     * Dart intersection:
+     * - If the AST produced a merged `newObject`, emit it as a flat class.
+     * - Otherwise emit a typedef alias to Object with a comment.
+     */
+    protected transpileIntersection(data: ASTIntersection): void;
+    /**
+     * Dart union:
+     * - Non-discriminated: typedef alias to Object with a comment listing member types.
+     * - Discriminated: abstract base class + factory unmarshal function using Dart 3 switch.
+     */
+    protected transpileUnion(data: ASTUnion): void;
+    /** Renders the full body of a Dart class for an ASTObject. */
+    private _transpileStructBody;
+    /** Renders a single class field declaration with optional `@JsonKey` annotation. */
+    private _transpileMember;
+    /**
+     * Emits `fromJson` factory and `toJson` method delegation stubs.
+     * For generic classes, extra `fromJsonT` / `toJsonT` function parameters are added
+     * as required by `json_serializable` with `genericArgumentFactories: true`.
+     */
+    private _emitFromToJson;
+}

package/dist/transpilers/dart/runner.js

@@ -0,0 +1,624 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Zod2Dart = void 0;
+const case_1 = __importDefault(require("case"));
+const core_1 = require("../../core");
+const options_1 = require("./options");
+const libs_1 = require("./libs");
+/**
+ * Transpiler for Zod schemas to Dart classes using package:json_annotation.
+ *
+ * The `.g.dart` part file is NOT generated by this transpiler — it must be produced
+ * externally via `dart run build_runner build`.
+ */
+class Zod2Dart extends core_1.Zod2X {
+    constructor(opt = {}) {
+        super(Object.assign(Object.assign({}, options_1.defaultOpts), opt));
+        this.commentKey = "//";
+        /**
+         * Maps a local struct/class name to the discriminated union names it participates in.
+         * Populated by a pre-scan of the AST before the normal transpile pass.
+         */
+        this._unionMembers = new Map();
+        /**
+         * Names of locally-defined discriminated union abstract classes.
+         * Used to emit @JsonKey(fromJson/toJson) when such a type appears as a field.
+         */
+        this._discriminatedUnionTypes = new Set();
+        /**
+         * Names of typedef-emitted types (alias, union typedef, struct extends).
+         * When these appear as field types in @JsonSerializable classes, we emit
+         * @JsonKey(fromJson: TypeName.fromJson) to prevent json_serializable from
+         * following the typedef chain and referencing transitive imports.
+         */
+        this._typedefNames = new Set();
+        /**
+         * Maps a disc union typedef name (e.g. "NewDiscriminatedUnionItem") to the
+         * fromJson function name of the underlying entity-level union
+         * (e.g. "discriminatedUnionItemFromJson").
+         * Populated during pre-scan when an ASTUnion node has aliasOf set.
+         */
+        this._discriminatedUnionDelegateFromJson = new Map();
+        /**
+         * Unified set of type names needing custom @JsonKey annotations.
+         * - Discriminated union types: fromJson = <camelName>FromJson (local function)
+         * - Typedef types: fromJson = _<camelName>FromJson (standalone wrapper)
+         * - TypedefList: list fromJson/toJson helpers
+         * _toJson helpers are emitted in runAfter() for all entries.
+         */
+        this._usedCustomFromJsonTypes = new Map();
+        /**
+         * Maps a type name (e.g. "GenericUserEntity") to its full Dart type with
+         * template args (e.g. "GenericUserEntity<SomeDtoResult>"). Used in runAfter()
+         * to generate helpers with correct generic return types and factory calls.
+         */
+        this._usedCustomFromJsonFullTypes = new Map();
+        /**
+         * Maps a typedef name to its full extended type (the right-hand side of the
+         * typedef). E.g. "AdminUserEntity" → "GenericUserEntity<AdminUserMetadata>".
+         * Populated in addExtendedType() when the extended type has generic args.
+         * Used in runAfter() to generate 2-arg fromJson calls for generic classes.
+         */
+        this._typedefToExtendedType = new Map();
+        // ── Primitive type methods ──────────────────────────────────────────────
+        this.getStringType = () => "String";
+        this.getBooleanType = () => "bool";
+        this.getAnyType = () => "dynamic";
+        this.getDateType = () => "DateTime";
+        /** Ex: Set<T> */
+        this.getSetType = (itemType) => `Set<${itemType}>`;
+        /** Ex: Map<K, V> */
+        this.getMapType = (keyType, valueType) => `Map<${keyType}, ${valueType}>`;
+        /** Ex: Map<String, V> (record key is always String) */
+        this.getRecordType = (keyType, valueType) => `Map<${keyType}, ${valueType}>`;
+        /** Ex: (T1, T2, T3) — Dart 3 positional record type */
+        this.getTupleType = (itemsType) => `(${itemsType.join(", ")})`;
+        /** Dart has no native union type; use Object */
+        this.getUnionType = (_itemsType) => "Object";
+        /** Dart has no native intersection type; use Object */
+        this.getIntersectionType = (_itemsType) => "Object";
+        this.lib = (0, libs_1.getLibs)();
+    }
+    /**
+     * Overrides transpile() to pre-scan discriminated union memberships before the normal pass.
+     * This allows transpileStruct() to emit `implements UnionName` on member classes.
+     */
+    transpile(transpilerQueue) {
+        this._unionMembers.clear();
+        this._discriminatedUnionTypes.clear();
+        this._typedefNames.clear();
+        this._usedCustomFromJsonTypes.clear();
+        this._usedCustomFromJsonFullTypes.clear();
+        this._discriminatedUnionDelegateFromJson.clear();
+        this._typedefToExtendedType.clear();
+        transpilerQueue.nodes.forEach((node) => {
+            if (node instanceof core_1.ASTUnion && node.discriminantKey) {
+                // Track the union name for @JsonKey emission
+                this._discriminatedUnionTypes.add(node.name);
+                // If this is a typedef alias of another disc union (aliasOf set),
+                // record which entity-level fromJson function to delegate to.
+                const aliasOf = node.aliasOf;
+                if (aliasOf) {
+                    this._discriminatedUnionDelegateFromJson.set(node.name, `${case_1.default.camel(aliasOf)}FromJson`);
+                }
+                node.options.forEach((opt) => {
+                    var _a;
+                    const name = opt.name;
+                    // Only track types local to this file (no parentFile = not imported)
+                    if (name && !opt.parentFile) {
+                        const existing = (_a = this._unionMembers.get(name)) !== null && _a !== void 0 ? _a : [];
+                        existing.push(node.name);
+                        this._unionMembers.set(name, existing);
+                    }
+                });
+            }
+            // Detect cross-file nodes that are generic type instantiations:
+            // e.g. AdminUserEntity (parentFile=app, description="GenericUserEntity",
+            // templatesTranslation=[{aliasOf:"AdminUserMetadata"}])
+            // → store "AdminUserEntity" → "GenericUserEntity<AdminUserMetadata>" in
+            //   _typedefToExtendedType so runAfter() can generate 2-arg fromJson helpers.
+            const n = node;
+            if (n.parentFile &&
+                typeof n.description === "string" &&
+                n.description.length > 0 &&
+                Array.isArray(n.templatesTranslation) &&
+                n.templatesTranslation.length > 0) {
+                const typeArgs = n.templatesTranslation
+                    .map((t) => t.aliasOf || t.name || "")
+                    .filter(Boolean)
+                    .join(", ");
+                if (typeArgs && n.name) {
+                    this._typedefToExtendedType.set(n.name, `${n.description}<${typeArgs}>`);
+                }
+            }
+        });
+        return super.transpile(transpilerQueue);
+    }
+    runBefore() {
+        if (this.opt.useJsonSerialization !== false) {
+            this.preImports.add(this.lib.jsonAnnotation);
+            if (this.opt.partFile) {
+                this.postImports.add(`part '${this.opt.partFile}.g.dart';`);
+            }
+        }
+    }
+    runAfter() {
+        var _a, _b;
+        // Emit helper functions for field types that need custom @JsonKey annotations.
+        // These helpers prevent json_serializable from following typedef chains and generating
+        // code that references transitively-imported types not directly in scope.
+        if (this.opt.useJsonSerialization !== false) {
+            for (const [typeName, kind] of this._usedCustomFromJsonTypes) {
+                const fnBase = case_1.default.camel(typeName);
+                // Use full type (including generics) if available, e.g. GenericUserEntity<SomeDtoResult>
+                const fullType = (_a = this._usedCustomFromJsonFullTypes.get(typeName)) !== null && _a !== void 0 ? _a : typeName;
+                // Extract type argument for generic classes: "Foo<Bar>" → "Bar"
+                const genericArgMatch = fullType.match(/^([^<]+)<(.+)>$/);
+                const baseTypeName = genericArgMatch ? genericArgMatch[1] : fullType;
+                const typeArg = genericArgMatch ? genericArgMatch[2] : undefined;
+                const isGeneric = typeArg !== undefined;
+                if (kind === "discUnion") {
+                    // Abstract class: toJson helper only (fromJson is the named union function)
+                    this.push0(`Map<String, dynamic> _${fnBase}ToJson(${fullType} value) =>`);
+                    this.push1(`(value as dynamic).toJson() as Map<String, dynamic>;\n`);
+                }
+                else if (kind === "typedef") {
+                    // Use full extended type if it has generics (e.g. AdminUserEntity → GenericUserEntity<AdminUserMetadata>)
+                    const extendedType = (_b = this._usedCustomFromJsonFullTypes.get(typeName)) !== null && _b !== void 0 ? _b : this._typedefToExtendedType.get(typeName);
+                    const genericArgMatch = extendedType === null || extendedType === void 0 ? void 0 : extendedType.match(/^([^<]+)<(.+)>$/);
+                    const extBaseType = genericArgMatch ? genericArgMatch[1] : undefined;
+                    const extTypeArg = genericArgMatch ? genericArgMatch[2] : undefined;
+                    if (isGeneric) {
+                        // Direct generic field (e.g. GenericUserEntity<SomeDtoResult>): factory pattern
+                        this.push0(`${fullType} _${fnBase}FromJson(Object? json) =>`);
+                        this.push1(`${baseTypeName}.fromJson(json as Map<String, dynamic>, (j) => ${typeArg}.fromJson(j as Map<String, dynamic>));\n`);
+                        this.push0(`Map<String, dynamic> _${fnBase}ToJson(${fullType} value) =>`);
+                        this.push1(`value.toJson((v) => v.toJson());\n`);
+                    }
+                    else if (extBaseType && extTypeArg) {
+                        // Typedef of a generic class (e.g. AdminUserEntity = GenericUserEntity<AdminUserMetadata>)
+                        this.push0(`${typeName} _${fnBase}FromJson(Object? json) =>`);
+                        this.push1(`${extBaseType}.fromJson(json as Map<String, dynamic>, (j) => ${extTypeArg}.fromJson(j as Map<String, dynamic>));\n`);
+                        this.push0(`Map<String, dynamic> _${fnBase}ToJson(${typeName} value) =>`);
+                        this.push1(`value.toJson((v) => v.toJson());\n`);
+                    }
+                    else {
+                        // Non-generic class: simple fromJson + toJson helpers
+                        this.push0(`${typeName} _${fnBase}FromJson(Object? json) =>`);
+                        this.push1(`${typeName}.fromJson(json as Map<String, dynamic>);\n`);
+                        this.push0(`Map<String, dynamic> _${fnBase}ToJson(${typeName} value) =>`);
+                        this.push1(`(value as dynamic).toJson() as Map<String, dynamic>;\n`);
+                    }
+                }
+                else if (kind === "typedefList") {
+                    // List<typedef>: list fromJson + toJson helpers
+                    this.push0(`List<${typeName}> _${fnBase}ListFromJson(Object? json) =>`);
+                    this.push1(`(json as List<dynamic>).map((e) => ${typeName}.fromJson(e as Map<String, dynamic>)).toList();\n`);
+                    this.push0(`List<Map<String, dynamic>> _${fnBase}ListToJson(List<${typeName}> list) =>`);
+                    this.push1(`list.map((e) => (e as dynamic).toJson() as Map<String, dynamic>).toList();\n`);
+                }
+            }
+        }
+        this._usedCustomFromJsonTypes.clear();
+        this._usedCustomFromJsonFullTypes.clear();
+    }
+    // ── Import / namespace ──────────────────────────────────────────────────
+    addImportFromFile(filename, _namespace) {
+        const base = filename.endsWith(".dart") ? filename.slice(0, -5) : filename;
+        return `import './${base}.dart';`;
+    }
+    getTypeFromExternalNamespace(_namespace, typeName) {
+        return typeName;
+    }
+    // ── Generics ────────────────────────────────────────────────────────────
+    getGenericTemplatesTranslation(data) {
+        if ((data instanceof core_1.ASTObject || data instanceof core_1.ASTDefinition) &&
+            data.templatesTranslation.length > 0) {
+            return ("<" +
+                data.templatesTranslation
+                    .map((t) => {
+                    if (this.isExternalTypeImport(t)) {
+                        this.addExternalTypeImport(t);
+                        return this.getTypeFromExternalNamespace(t.parentNamespace, t.aliasOf);
+                    }
+                    else {
+                        return t.aliasOf;
+                    }
+                })
+                    .join(", ") +
+                ">");
+        }
+    }
+    // ── Layered modeling ────────────────────────────────────────────────────
+    /**
+     * Emits an alias/extension declaration for cross-layer references.
+     */
+    checkExtendedTypeInclusion(data, type) {
+        const isStruct = data instanceof core_1.ASTObject ||
+            (data instanceof core_1.ASTIntersection && data.newObject !== undefined);
+        const translatedTemplates = this.getGenericTemplatesTranslation(data);
+        const templates = translatedTemplates || undefined;
+        const declaredTemplates = !translatedTemplates && data instanceof core_1.ASTObject && data.templates.size > 0
+            ? `<${[...data.templates].join(", ")}>`
+            : undefined;
+        if (this.isExternalTypeImport(data)) {
+            if (data.aliasOf) {
+                this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
+                    type: isStruct ? undefined : type,
+                    templates,
+                    declaredTemplates,
+                });
+                this.addExternalTypeImport(data);
+            }
+            return true;
+        }
+        else if (data.aliasOf) {
+            this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, {
+                type: isStruct ? undefined : type,
+                isInternal: true,
+                templates,
+                declaredTemplates,
+            });
+            return true;
+        }
+        return false;
+    }
+    addExtendedType(name, parentNamespace, aliasOf, opt) {
+        var _a, _b;
+        const extendedType = (opt === null || opt === void 0 ? void 0 : opt.isInternal)
+            ? aliasOf
+            : this.getTypeFromExternalNamespace(parentNamespace, aliasOf);
+        const templates = (_a = opt === null || opt === void 0 ? void 0 : opt.templates) !== null && _a !== void 0 ? _a : "";
+        const declaredTemplates = (_b = opt === null || opt === void 0 ? void 0 : opt.declaredTemplates) !== null && _b !== void 0 ? _b : "";
+        if ((opt === null || opt === void 0 ? void 0 : opt.type) === "alias" || (opt === null || opt === void 0 ? void 0 : opt.type) === "union") {
+            this._typedefNames.add(name);
+            this.push0(`typedef ${name}${declaredTemplates} = ${extendedType}${templates};\n`);
+        }
+        else {
+            // Dart 3: use typedef for empty class extensions to keep json_serializable happy.
+            // `class B extends A {}` without @JsonSerializable is rejected by build_runner.
+            // A typedef is valid Dart 3 syntax and correctly aliases the type for serialization.
+            this._typedefNames.add(name);
+            this.push0(`typedef ${name}${declaredTemplates} = ${extendedType}${templates};\n`);
+        }
+        // Track generic extended types so runAfter() can generate 2-arg fromJson calls.
+        const fullExtended = `${extendedType}${templates !== null && templates !== void 0 ? templates : ""}`;
+        if (fullExtended.includes("<")) {
+            this._typedefToExtendedType.set(name, fullExtended);
+        }
+    }
+    getNumberType(isInt, _range) {
+        // Dart has a single `int` type regardless of range
+        return isInt ? "int" : "double";
+    }
+    /**
+     * Returns the Dart type for a literal value.
+     * Dart has no structural literal types, so we return the underlying primitive type.
+     * When a parent enum is provided, returns the enum type name (not a member expression),
+     * since Dart enum members cannot be used as types.
+     */
+    getLiteralStringType(value, parentEnumNameKey) {
+        if (parentEnumNameKey) {
+            // Return the enum type name only — member access is not a valid Dart type
+            return parentEnumNameKey[0];
+        }
+        if (typeof value === "boolean")
+            return "bool";
+        if (typeof value === "number") {
+            return Number.isInteger(value) ? "int" : "double";
+        }
+        return "String";
+    }
+    // ── Composite type methods ──────────────────────────────────────────────
+    /** Ex: List<List<T>> for 2D array */
+    getArrayType(arrayType, arrayDeep) {
+        let output = `List<${arrayType}>`;
+        for (let i = 0; i < arrayDeep - 1; i++) {
+            output = `List<${output}>`;
+        }
+        return output;
+    }
+    // ── Transpile methods ───────────────────────────────────────────────────
+    transpileAliasedType(data) {
+        if (this.checkExtendedTypeInclusion(data, "alias"))
+            return;
+        this.addComment(data.description);
+        let resolvedType;
+        if (data instanceof core_1.ASTArray) {
+            resolvedType = this.getAttributeType(data.item);
+        }
+        else {
+            resolvedType = this.getAttributeType(data);
+        }
+        this.push0(`typedef ${data.name} = ${resolvedType};\n`);
+    }
+    /**
+     * Emits a Dart enhanced enum with a typed `value` field and `@JsonEnum` annotation.
+     *
+     * All-string values:
+     *   @JsonEnum(valueField: 'value')
+     *   enum EnumItem {
+     *     enum1('Enum1'),
+     *     enum2('Enum2');
+     *
+     *     const EnumItem(this.value);
+     *     final String value;
+     *   }
+     *
+     * Mixed (int + string): typedef alias with comment.
+     */
+    transpileEnum(data) {
+        if (this.checkExtendedTypeInclusion(data, "alias"))
+            return;
+        this.addComment(data.description);
+        const allStrings = data.values.every(([, v]) => typeof v === "string");
+        const allInts = data.values.every(([, v]) => typeof v === "number");
+        if (allStrings || allInts) {
+            const valueType = allStrings ? "String" : "int";
+            const q = allStrings ? "'" : "";
+            if (this.opt.useJsonSerialization !== false) {
+                this.push0(`@JsonEnum(valueField: 'value')`);
+            }
+            this.push0(`enum ${data.name} {`);
+            data.values.forEach(([key, value], index) => {
+                const memberName = case_1.default.camel(key);
+                const comma = index < data.values.length - 1 ? "," : ";";
+                this.push1(`${memberName}(${q}${value}${q})${comma}`);
+            });
+            this.push0("");
+            this.push1(`const ${data.name}(this.value);`);
+            this.push1(`final ${valueType} value;`);
+            this.push0(`}\n`);
+        }
+        else {
+            // Mixed-type enum: fall back to typedef alias + comment
+            this.push0(`typedef ${data.name} = dynamic;`);
+            this.push0(`// ${data.name}: mixed-type enum — no single Dart base type`);
+            data.values.forEach(([key, value]) => {
+                const constName = case_1.default.camel(key);
+                const v = typeof value === "string" ? `'${value}'` : `${value}`;
+                this.push0(`// const ${constName} = ${v};`);
+            });
+            this.push0("");
+        }
+    }
+    transpileStruct(data) {
+        if (this.checkExtendedTypeInclusion(data))
+            return;
+        this.addComment(data.description);
+        this._transpileStructBody(data);
+    }
+    /**
+     * Dart intersection:
+     * - If the AST produced a merged `newObject`, emit it as a flat class.
+     * - Otherwise emit a typedef alias to Object with a comment.
+     */
+    transpileIntersection(data) {
+        if (this.checkExtendedTypeInclusion(data))
+            return;
+        this.addComment(data.description);
+        if (data.newObject) {
+            this._transpileStructBody(data.newObject);
+        }
+        else {
+            const leftType = this.getAttributeType(data.left);
+            const rightType = this.getAttributeType(data.right);
+            this.push0(`typedef ${data.name} = Object; // Intersection of: ${leftType}, ${rightType}\n`);
+        }
+    }
+    /**
+     * Dart union:
+     * - Non-discriminated: typedef alias to Object with a comment listing member types.
+     * - Discriminated: abstract base class + factory unmarshal function using Dart 3 switch.
+     */
+    transpileUnion(data) {
+        if (this.checkExtendedTypeInclusion(data, "union"))
+            return;
+        this.addComment(data.description);
+        const optionNames = data.options.map(this.getAttributeType.bind(this));
+        if (data.discriminantKey) {
+            this.push0(`// Discriminated union on '${data.discriminantKey}'.`);
+            this.push0(`// Possible types: ${optionNames.join(", ")}`);
+            this.push0(`abstract class ${data.name} {}\n`);
+            // Emit factory unmarshal function when all members have a discriminant value
+            const optionsData = data.options.map((opt, i) => {
+                var _a;
+                return ({
+                    typeName: optionNames[i],
+                    discriminantValue: (_a = opt.constraints) === null || _a === void 0 ? void 0 : _a.discriminantValue,
+                });
+            });
+            const allHaveDiscriminantValue = optionsData.every((o) => o.discriminantValue !== undefined);
+            if (allHaveDiscriminantValue && this.opt.useJsonSerialization !== false) {
+                const fnName = case_1.default.camel(data.name);
+                this.push0(`${data.name} ${fnName}FromJson(Map<String, dynamic> json) {`);
+                this.push1(`return switch (json['${data.discriminantKey}']) {`);
+                for (const opt of optionsData) {
+                    const dv = opt.discriminantValue;
+                    const isNumber = !isNaN(Number(dv));
+                    const isBool = dv === "true" || dv === "false";
+                    const caseVal = isNumber || isBool ? dv : `'${dv}'`;
+                    // For generic types like Foo<Bar>, use 2-arg factory fromJson(json, Bar.fromJson)
+                    const typeNameStr = opt.typeName;
+                    const genericMatch = typeNameStr.match(/^([^<]+)<(.+)>$/);
+                    if (genericMatch) {
+                        const baseType = genericMatch[1];
+                        const typeArgStr = genericMatch[2];
+                        this.push2(`${caseVal} => ${baseType}.fromJson(json, (j) => ${typeArgStr}.fromJson(j as Map<String, dynamic>)),`);
+                    }
+                    else {
+                        this.push2(`${caseVal} => ${typeNameStr}.fromJson(json),`);
+                    }
+                }
+                const escapedKey = data.discriminantKey.replace(/"/g, '\\"');
+                this.push2(`_ => throw Exception("Unknown ${data.name} discriminant: \${json['${escapedKey}']}")`);
+                this.push1(`};`);
+                this.push0(`}\n`);
+            }
+        }
+        else {
+            this.push0(`// ${data.name} is a union of: ${optionNames.join(", ")}`);
+            this.push0(`typedef ${data.name} = Object;\n`);
+        }
+    }
+    // ── Private helpers ─────────────────────────────────────────────────────
+    /** Renders the full body of a Dart class for an ASTObject. */
+    _transpileStructBody(data) {
+        var _a, _b;
+        const isGeneric = data.templates.size > 0;
+        const templateStr = isGeneric ? `<${[...data.templates].join(", ")}>` : "";
+        const unionNames = (_b = this._unionMembers.get((_a = data.name) !== null && _a !== void 0 ? _a : "")) !== null && _b !== void 0 ? _b : [];
+        const implementsClause = unionNames.length > 0 ? ` implements ${unionNames.join(", ")}` : "";
+        const useJson = this.opt.useJsonSerialization !== false;
+        if (useJson) {
+            if (isGeneric) {
+                this.push0(`@JsonSerializable(explicitToJson: true, genericArgumentFactories: true)`);
+            }
+            else {
+                this.push0(`@JsonSerializable(explicitToJson: true)`);
+            }
+        }
+        this.push0(`class ${data.name}${templateStr}${implementsClause} {`);
+        const properties = Object.entries(data.properties);
+        if (properties.length === 0) {
+            this.push0(`}`);
+            if (useJson) {
+                this._emitFromToJson(data);
+            }
+            this.push0("");
+            return;
+        }
+        // Field declarations
+        for (const [key, value] of properties) {
+            this._transpileMember(key, value);
+        }
+        // Constructor
+        this.push0("");
+        this.push1(`${data.name}({`);
+        for (const [key, value] of properties) {
+            const fieldName = this.opt.keepKeys === true ? key : case_1.default.camel(key);
+            const isOpt = value.isOptional || value.isNullable;
+            if (isOpt) {
+                this.push2(`this.${fieldName},`);
+            }
+            else {
+                this.push2(`required this.${fieldName},`);
+            }
+        }
+        this.push1(`});`);
+        if (useJson) {
+            this._emitFromToJson(data);
+        }
+        this.push0(`}\n`);
+    }
+    /** Renders a single class field declaration with optional `@JsonKey` annotation. */
+    _transpileMember(key, memberNode) {
+        var _a, _b;
+        const fieldName = this.opt.keepKeys === true ? key : case_1.default.camel(key);
+        const isOpt = memberNode.isOptional || memberNode.isNullable;
+        const varType = this.getAttributeType(memberNode);
+        if (memberNode.description && !memberNode.name && !this.isTranspilerable(memberNode)) {
+            this.addComment(memberNode.description, `\n${this.indent[1]}`);
+        }
+        const useJson = this.opt.useJsonSerialization !== false;
+        let annotationEmitted = false;
+        if (useJson) {
+            // Only @JsonSerializable classes (ASTObject) need @JsonKey to prevent json_serializable
+            // from following the typedef chain to a type not directly imported.
+            // Primitives (String, int, double, bool, DateTime), collections (List, Map, Set,
+            // Tuple), enums, and dynamic are all handled natively by json_serializable.
+            const instanceType = memberNode.instanceType;
+            const isClassLike = instanceType === "ASTObject";
+            // Cross-file reference that is a class-like type: needs @JsonKey wrapper.
+            const memberIsAlias = memberNode.parentFile !== undefined && isClassLike;
+            const isList = ((_a = memberNode.arrayDimension) !== null && _a !== void 0 ? _a : 0) > 0;
+            // Actual type name (before array/optional wrapping)
+            const nodeName = memberNode.name;
+            const baseType = varType.replace(/\?$/, "").replace(/^List<(.+)>$/, "$1");
+            const localTypeName = baseType.includes(".") ? baseType.split(".").pop() : baseType;
+            if (this._discriminatedUnionTypes.has(localTypeName) && !isList) {
+                // Abstract discriminated union — use local or delegate fromJson function.
+                // If this union is a typedef alias of another (aliasOf set), delegate to
+                // the entity-level fromJson so we don't define a duplicate dispatcher.
+                this._usedCustomFromJsonTypes.set(localTypeName, "discUnion");
+                const fnBase = case_1.default.camel(localTypeName);
+                const fromJsonFn = (_b = this._discriminatedUnionDelegateFromJson.get(localTypeName)) !== null && _b !== void 0 ? _b : `${fnBase}FromJson`;
+                const namePart = fieldName !== key ? `name: '${key}', ` : "";
+                this.push1(`@JsonKey(${namePart}fromJson: ${fromJsonFn}, toJson: _${fnBase}ToJson)`);
+                annotationEmitted = true;
+            }
+            else if (this._typedefNames.has(localTypeName) && !isList && isClassLike) {
+                // Locally-defined typedef of a class — use standalone fromJson helper to
+                // prevent json_serializable from following the chain to an un-imported type.
+                this._usedCustomFromJsonTypes.set(localTypeName, "typedef");
+                const fnBase = case_1.default.camel(localTypeName);
+                const namePart = fieldName !== key ? `name: '${key}', ` : "";
+                this.push1(`@JsonKey(${namePart}fromJson: _${fnBase}FromJson, toJson: _${fnBase}ToJson)`);
+                annotationEmitted = true;
+            }
+            else if (memberIsAlias) {
+                // Cross-file class alias not in _typedefNames — same treatment (including lists).
+                const typeName = nodeName || localTypeName;
+                const fnBase = case_1.default.camel(typeName);
+                const kind = isList ? "typedefList" : "typedef";
+                this._usedCustomFromJsonTypes.set(typeName, kind);
+                // Store full type (including generics) for helper generation in runAfter()
+                const fullType = varType.replace(/\?$/, "");
+                if (fullType !== typeName) {
+                    this._usedCustomFromJsonFullTypes.set(typeName, fullType);
+                }
+                const namePart = fieldName !== key ? `name: '${key}', ` : "";
+                if (isList) {
+                    this.push1(`@JsonKey(${namePart}fromJson: _${fnBase}ListFromJson, toJson: _${fnBase}ListToJson)`);
+                }
+                else {
+                    this.push1(`@JsonKey(${namePart}fromJson: _${fnBase}FromJson, toJson: _${fnBase}ToJson)`);
+                }
+                annotationEmitted = true;
+            }
+        }
+        if (!annotationEmitted && fieldName !== key) {
+            // @JsonKey is needed when the Dart field name differs from the original JSON key
+            this.push1(`@JsonKey(name: '${key}')`);
+        }
+        const typeStr = isOpt ? `${varType}?` : varType;
+        this.push1(`final ${typeStr} ${fieldName};`);
+    }
+    /**
+     * Emits `fromJson` factory and `toJson` method delegation stubs.
+     * For generic classes, extra `fromJsonT` / `toJsonT` function parameters are added
+     * as required by `json_serializable` with `genericArgumentFactories: true`.
+     */
+    _emitFromToJson(data) {
+        const className = data.name;
+        const templates = [...data.templates];
+        const isGeneric = templates.length > 0;
+        if (isGeneric) {
+            const fromParams = templates
+                .map((t) => `${t} Function(Object? json) fromJson${t}`)
+                .join(", ");
+            const toParams = templates
+                .map((t) => `Object? Function(${t} value) toJson${t}`)
+                .join(", ");
+            const fromArgs = templates.map((t) => `fromJson${t}`).join(", ");
+            const toArgs = templates.map((t) => `toJson${t}`).join(", ");
+            this.push0("");
+            this.push1(`factory ${className}.fromJson(Map<String, dynamic> json, ${fromParams}) =>`);
+            this.push2(`_\$${className}FromJson(json, ${fromArgs});`);
+            this.push0("");
+            this.push1(`Map<String, dynamic> toJson(${toParams}) =>`);
+            this.push2(`_\$${className}ToJson(this, ${toArgs});`);
+        }
+        else {
+            this.push0("");
+            this.push1(`factory ${className}.fromJson(Map<String, dynamic> json) =>`);
+            this.push2(`_\$${className}FromJson(json);`);
+            this.push0("");
+            this.push1(`Map<String, dynamic> toJson() => _\$${className}ToJson(this);`);
+        }
+    }
+}
+exports.Zod2Dart = Zod2Dart;

package/dist/transpilers/index.d.ts

@@ -2,3 +2,4 @@ export { Zod2Ts } from "./typescript/runner";
 export { Zod2Cpp, Zod2Cpp17 } from "./cpp/runner";
 export { Zod2Py } from "./python/runner";
 export { Zod2Go } from "./go/runner";
+export { Zod2Dart } from "./dart/runner";

package/dist/transpilers/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Zod2Go = exports.Zod2Py = exports.Zod2Cpp17 = exports.Zod2Cpp = exports.Zod2Ts = void 0;
+exports.Zod2Dart = exports.Zod2Go = exports.Zod2Py = exports.Zod2Cpp17 = exports.Zod2Cpp = exports.Zod2Ts = void 0;
 var runner_1 = require("./typescript/runner");
 Object.defineProperty(exports, "Zod2Ts", { enumerable: true, get: function () { return runner_1.Zod2Ts; } });
 var runner_2 = require("./cpp/runner");
@@ -10,3 +10,5 @@ var runner_3 = require("./python/runner");
 Object.defineProperty(exports, "Zod2Py", { enumerable: true, get: function () { return runner_3.Zod2Py; } });
 var runner_4 = require("./go/runner");
 Object.defineProperty(exports, "Zod2Go", { enumerable: true, get: function () { return runner_4.Zod2Go; } });
+var runner_5 = require("./dart/runner");
+Object.defineProperty(exports, "Zod2Dart", { enumerable: true, get: function () { return runner_5.Zod2Dart; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-to-x",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Multi language types generation from Zod schemas.",
   "main": "dist/index.js",
   "files": [
@@ -16,7 +16,8 @@
     "test:cpp": "bash ./test/test_zod2cpp/test_cpp.sh",
     "test:py": "bash ./test/test_zod2py/test_py.sh",
     "test:go": "bash ./test/test_zod2go/test_go.sh",
-    "test:all": "npm run test:cpp && npm run test:py && npm run test:go",
+    "test:dart": "bash ./test/test_zod2dart/test_dart.sh",
+    "test:all": "npm run test:cpp && npm run test:py && npm run test:go && npm run test:dart",
     "ts-run": "ts-node -r tsconfig-paths/register",
     "prepare": "husky"
   },
@@ -61,7 +62,7 @@
     "husky": "^9.1.7",
     "lint-staged": "^15.2.11",
     "prettier": "^3.4.2",
-    "protobufjs": "7.5.5",
+    "protobufjs": "7.6.5",
     "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.10",
     "tsconfig-paths": "4.2.0",