@miroir-framework/jzod-ts 0.6.0 → 0.6.2

package/dist/bundle.d.ts

@@ -35,6 +35,7 @@ type JzodAttributeDateWithValidations = {
     } | undefined;
     type: "simpleType";
     definition: "date";
+    coerce?: boolean | undefined;
     validations: JzodAttributeDateValidations[];
 };
 type JzodAttributeNumberValidations = {
@@ -52,6 +53,7 @@ type JzodAttributeNumberWithValidations = {
     } | undefined;
     type: "simpleType";
     definition: "number";
+    coerce?: boolean | undefined;
     validations: JzodAttributeNumberValidations[];
 };
 type JzodAttributeStringValidations = {
@@ -69,6 +71,7 @@ type JzodAttributeStringWithValidations = {
     } | undefined;
     type: "simpleType";
     definition: "string";
+    coerce?: boolean | undefined;
     validations: JzodAttributeStringValidations[];
 };
 type JzodElement = JzodArray | JzodAttribute | JzodAttributeDateWithValidations | JzodAttributeNumberWithValidations | JzodAttributeStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodObject | JzodPromise | JzodRecord | JzodReference | JzodSet | JzodTuple | JzodUnion;
@@ -111,7 +114,7 @@ type JzodLiteral = {
         [x: string]: any;
     } | undefined;
     type: "literal";
-    definition: string;
+    definition: string | number | bigint | boolean;
 };
 type JzodIntersection = {
     optional?: boolean | undefined;
@@ -146,6 +149,7 @@ type JzodObject = {
     extend?: (JzodReference | JzodObject) | undefined;
     type: "object";
     nonStrict?: boolean | undefined;
+    partial?: boolean | undefined;
     definition: {
         [x: string]: JzodElement;
     };
@@ -251,7 +255,7 @@ interface TsTypeAliasesAndZodText {
     mainZodText: string;
 }
 declare function jzodToTsTypeAliasesAndZodText(element: JzodElement, typeName?: string): TsTypeAliasesAndZodText;
-declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string, typeSchema?: boolean): string;
+declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string, typeAnotationForSchema?: string[]): string;
 
 declare function printTsTypeAlias(typeAlias: ts.TypeAliasDeclaration, exportPrefix?: boolean): string;
 declare function printTsTypeAliases(typeAliases: TsTypeAliases, exportPrefix?: boolean): string;

package/dist/bundle.js

@@ -17,7 +17,7 @@ function jzodToTsTypeAliasesAndZodText(element, typeName) {
     var _a, _b;
     const elementZodSchemaAndDescription = jzodElementSchemaToZodSchemaAndDescription(element, () => ({}), () => ({}), (innerReference, relativeReference) => withGetType(innerReference, (ts) => {
         const actualTypeName = relativeReference ? relativeReference.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
-        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(actualTypeName ? actualTypeName : "RELATIVEPATH_NOT_DEFINED"), undefined);
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(actualTypeName !== null && actualTypeName !== void 0 ? actualTypeName : "RELATIVEPATH_NOT_DEFINED"), undefined);
     }));
     const contextTsTypesString = Object.fromEntries(Object.entries((_a = elementZodSchemaAndDescription.contextZodSchema) !== null && _a !== void 0 ? _a : {}).map((curr) => {
         const actualTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
@@ -34,22 +34,23 @@ function jzodToTsTypeAliasesAndZodText(element, typeName) {
         mainTsTypeAlias: tsTypeStringTypeAlias,
     };
 }
-function jzodToTsCode(jzodElement, exportPrefix = true, typeName, typeSchema = false) {
+function jzodToTsCode(jzodElement, exportPrefix = true, typeName, typeAnotationForSchema = []) {
     const schemaName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c) : "";
     const actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
     const header = `import { ZodType, ZodTypeAny, z } from "zod";`;
     const typeAliasesAndZodText = jzodToTsTypeAliasesAndZodText(jzodElement, actualTypeName);
-    const bodyJsCode = typeSchema
+    const bodyJsCode = typeAnotationForSchema.includes(schemaName !== null && schemaName !== void 0 ? schemaName : "")
         ? `export const ${schemaName}: z.ZodType<${actualTypeName}> = ${typeAliasesAndZodText.mainZodText};`
         : `export const ${schemaName} = ${typeAliasesAndZodText.mainZodText};`;
     const contextTsTypesString = printTsTypeAliases(typeAliasesAndZodText.contextTsTypeAliases, exportPrefix);
     const contextJsCode = typeAliasesAndZodText.contextZodText
         ? Object.entries(typeAliasesAndZodText.contextZodText).reduce((acc, curr) => {
             const contextTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
-            return typeSchema ?
-                `${acc}
-export const ${curr[0]}: z.ZodType<${contextTypeName}> = ${curr[1]};` :
+            return typeAnotationForSchema.includes(curr[0]) ?
                 `${acc}
+export const ${curr[0]}: z.ZodType<${contextTypeName}> = ${curr[1]};`
+                :
+                    `${acc}
 export const ${curr[0]} = ${curr[1]};`;
         }, "")
         : "";
@@ -66,21 +67,21 @@ z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), e
 const jzodArray = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("array"), definition: z.lazy(() => jzodElement) }).strict();
 const jzodAttribute = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("simpleType"), coerce: z.boolean().optional(), definition: z.lazy(() => jzodEnumAttributeTypes) }).strict();
 const jzodAttributeDateValidations = z.object({ extra: z.record(z.string(), z.any()).optional(), type: z.enum(["min", "max"]), parameter: z.any() }).strict();
-const jzodAttributeDateWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("simpleType"), definition: z.literal("date"), validations: z.array(z.lazy(() => jzodAttributeDateValidations)) }).strict();
+const jzodAttributeDateWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("simpleType"), definition: z.literal("date"), coerce: z.boolean().optional(), validations: z.array(z.lazy(() => jzodAttributeDateValidations)) }).strict();
 const jzodAttributeNumberValidations = z.object({ extra: z.record(z.string(), z.any()).optional(), type: z.enum(["gt", "gte", "lt", "lte", "int", "positive", "nonpositive", "negative", "nonnegative", "multipleOf", "finite", "safe"]), parameter: z.any() }).strict();
-const jzodAttributeNumberWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("simpleType"), definition: z.literal("number"), validations: z.array(z.lazy(() => jzodAttributeNumberValidations)) }).strict();
+const jzodAttributeNumberWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("simpleType"), definition: z.literal("number"), coerce: z.boolean().optional(), validations: z.array(z.lazy(() => jzodAttributeNumberValidations)) }).strict();
 const jzodAttributeStringValidations = z.object({ extra: z.record(z.string(), z.any()).optional(), type: z.enum(["max", "min", "length", "email", "url", "emoji", "uuid", "cuid", "cuid2", "ulid", "regex", "includes", "startsWith", "endsWith", "datetime", "ip"]), parameter: z.any() }).strict();
-const jzodAttributeStringWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("simpleType"), definition: z.literal("string"), validations: z.array(z.lazy(() => jzodAttributeStringValidations)) }).strict();
+const jzodAttributeStringWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("simpleType"), definition: z.literal("string"), coerce: z.boolean().optional(), validations: z.array(z.lazy(() => jzodAttributeStringValidations)) }).strict();
 const jzodElement = z.union([z.lazy(() => jzodArray), z.lazy(() => jzodAttribute), z.lazy(() => jzodAttributeDateWithValidations), z.lazy(() => jzodAttributeNumberWithValidations), z.lazy(() => jzodAttributeStringWithValidations), z.lazy(() => jzodEnum), z.lazy(() => jzodFunction), z.lazy(() => jzodLazy), z.lazy(() => jzodLiteral), z.lazy(() => jzodIntersection), z.lazy(() => jzodMap), z.lazy(() => jzodObject), z.lazy(() => jzodPromise), z.lazy(() => jzodRecord), z.lazy(() => jzodReference), z.lazy(() => jzodSet), z.lazy(() => jzodTuple), z.lazy(() => jzodUnion)]);
 const jzodEnum = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("enum"), definition: z.array(z.string()) }).strict();
 const jzodEnumAttributeTypes = z.enum(["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]);
 const jzodEnumElementTypes = z.enum(["array", "enum", "function", "lazy", "literal", "intersection", "map", "object", "promise", "record", "schemaReference", "set", "simpleType", "tuple", "union"]);
 const jzodFunction = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("function"), definition: z.object({ args: z.array(z.lazy(() => jzodElement)), returns: z.lazy(() => jzodElement).optional() }).strict() }).strict();
 const jzodLazy = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("lazy"), definition: z.lazy(() => jzodFunction) }).strict();
-const jzodLiteral = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("literal"), definition: z.string() }).strict();
+const jzodLiteral = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("literal"), definition: z.union([z.string(), z.number(), z.bigint(), z.boolean()]) }).strict();
 const jzodIntersection = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("intersection"), definition: z.object({ left: z.lazy(() => jzodElement), right: z.lazy(() => jzodElement) }).strict() }).strict();
 const jzodMap = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("map"), definition: z.tuple([z.lazy(() => jzodElement), z.lazy(() => jzodElement)]) }).strict();
-const jzodObject = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ extend: z.union([z.lazy(() => jzodReference), z.lazy(() => jzodObject)]).optional(), type: z.literal("object"), nonStrict: z.boolean().optional(), definition: z.record(z.string(), z.lazy(() => jzodElement)) }).strict();
+const jzodObject = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ extend: z.union([z.lazy(() => jzodReference), z.lazy(() => jzodObject)]).optional(), type: z.literal("object"), nonStrict: z.boolean().optional(), partial: z.boolean().optional(), definition: z.record(z.string(), z.lazy(() => jzodElement)) }).strict();
 const jzodPromise = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("promise"), definition: z.lazy(() => jzodElement) }).strict();
 const jzodRecord = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("record"), definition: z.lazy(() => jzodElement) }).strict();
 const jzodReference = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("schemaReference"), context: z.record(z.string(), z.lazy(() => jzodElement)).optional(), definition: z.object({ eager: z.boolean().optional(), relativePath: z.string().optional(), absolutePath: z.string().optional() }).strict() }).strict();

package/dist/out-tsc/dts/src/JzodToTs.d.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { JzodElement } from "./JzodTsInterface";
+import { JzodElement } from "./generated_jzodBootstrapElementSchema";
 export type TsTypeAliases = {
     [k: string]: ts.TypeAliasDeclaration;
 };
@@ -14,4 +14,4 @@ export interface TsTypeAliasesAndZodText {
     mainZodText: string;
 }
 export declare function jzodToTsTypeAliasesAndZodText(element: JzodElement, typeName?: string): TsTypeAliasesAndZodText;
-export declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string): string;
+export declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string, typeAnotationForSchema?: string[]): string;

package/dist/out-tsc/dts/src/generated_jzodBootstrapElementSchema.d.ts

@@ -0,0 +1,250 @@
+import { ZodType, z } from "zod";
+export type JzodBaseObject = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+};
+export type JzodArray = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "array";
+    definition: JzodElement;
+};
+export type JzodAttribute = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "simpleType";
+    coerce?: boolean | undefined;
+    definition: JzodEnumAttributeTypes;
+};
+export type JzodAttributeDateValidations = {
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "min" | "max";
+    parameter?: any;
+};
+export type JzodAttributeDateWithValidations = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "simpleType";
+    definition: "date";
+    coerce?: boolean | undefined;
+    validations: JzodAttributeDateValidations[];
+};
+export type JzodAttributeNumberValidations = {
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "multipleOf" | "finite" | "safe";
+    parameter?: any;
+};
+export type JzodAttributeNumberWithValidations = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "simpleType";
+    definition: "number";
+    coerce?: boolean | undefined;
+    validations: JzodAttributeNumberValidations[];
+};
+export type JzodAttributeStringValidations = {
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "max" | "min" | "length" | "email" | "url" | "emoji" | "uuid" | "cuid" | "cuid2" | "ulid" | "regex" | "includes" | "startsWith" | "endsWith" | "datetime" | "ip";
+    parameter?: any;
+};
+export type JzodAttributeStringWithValidations = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "simpleType";
+    definition: "string";
+    coerce?: boolean | undefined;
+    validations: JzodAttributeStringValidations[];
+};
+export type JzodElement = JzodArray | JzodAttribute | JzodAttributeDateWithValidations | JzodAttributeNumberWithValidations | JzodAttributeStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodObject | JzodPromise | JzodRecord | JzodReference | JzodSet | JzodTuple | JzodUnion;
+export type JzodEnum = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "enum";
+    definition: string[];
+};
+export type JzodEnumAttributeTypes = "any" | "bigint" | "boolean" | "date" | "never" | "null" | "number" | "string" | "uuid" | "undefined" | "unknown" | "void";
+export type JzodEnumElementTypes = "array" | "enum" | "function" | "lazy" | "literal" | "intersection" | "map" | "object" | "promise" | "record" | "schemaReference" | "set" | "simpleType" | "tuple" | "union";
+export type JzodFunction = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "function";
+    definition: {
+        args: JzodElement[];
+        returns?: JzodElement | undefined;
+    };
+};
+export type JzodLazy = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "lazy";
+    definition: JzodFunction;
+};
+export type JzodLiteral = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "literal";
+    definition: string | number | bigint | boolean;
+};
+export type JzodIntersection = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "intersection";
+    definition: {
+        left: JzodElement;
+        right: JzodElement;
+    };
+};
+export type JzodMap = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "map";
+    definition: [
+        JzodElement,
+        JzodElement
+    ];
+};
+export type JzodObject = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    extend?: (JzodReference | JzodObject) | undefined;
+    type: "object";
+    nonStrict?: boolean | undefined;
+    partial?: boolean | undefined;
+    definition: {
+        [x: string]: JzodElement;
+    };
+};
+export type JzodPromise = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "promise";
+    definition: JzodElement;
+};
+export type JzodRecord = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "record";
+    definition: JzodElement;
+};
+export type JzodReference = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "schemaReference";
+    context?: {
+        [x: string]: JzodElement;
+    } | undefined;
+    definition: {
+        eager?: boolean | undefined;
+        relativePath?: string | undefined;
+        absolutePath?: string | undefined;
+    };
+};
+export type JzodSet = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "set";
+    definition: JzodElement;
+};
+export type JzodTuple = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "tuple";
+    definition: JzodElement[];
+};
+export type JzodUnion = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "union";
+    discriminator?: string | undefined;
+    definition: JzodElement[];
+};
+export type JzodBootstrapElementSchema = JzodElement;
+export declare const jzodBaseObject: z.ZodType<JzodBaseObject>;
+export declare const jzodArray: z.ZodType<JzodArray>;
+export declare const jzodAttribute: z.ZodType<JzodAttribute>;
+export declare const jzodAttributeDateValidations: z.ZodType<JzodAttributeDateValidations>;
+export declare const jzodAttributeDateWithValidations: z.ZodType<JzodAttributeDateWithValidations>;
+export declare const jzodAttributeNumberValidations: z.ZodType<JzodAttributeNumberValidations>;
+export declare const jzodAttributeNumberWithValidations: z.ZodType<JzodAttributeNumberWithValidations>;
+export declare const jzodAttributeStringValidations: z.ZodType<JzodAttributeStringValidations>;
+export declare const jzodAttributeStringWithValidations: z.ZodType<JzodAttributeStringWithValidations>;
+export declare const jzodElement: z.ZodType<JzodElement>;
+export declare const jzodEnum: z.ZodType<JzodEnum>;
+export declare const jzodEnumAttributeTypes: z.ZodType<JzodEnumAttributeTypes>;
+export declare const jzodEnumElementTypes: z.ZodType<JzodEnumElementTypes>;
+export declare const jzodFunction: z.ZodType<JzodFunction>;
+export declare const jzodLazy: z.ZodType<JzodLazy>;
+export declare const jzodLiteral: z.ZodType<JzodLiteral>;
+export declare const jzodIntersection: z.ZodType<JzodIntersection>;
+export declare const jzodMap: z.ZodType<JzodMap>;
+export declare const jzodObject: z.ZodType<JzodObject>;
+export declare const jzodPromise: z.ZodType<JzodPromise>;
+export declare const jzodRecord: z.ZodType<JzodRecord>;
+export declare const jzodReference: z.ZodType<JzodReference>;
+export declare const jzodSet: z.ZodType<JzodSet>;
+export declare const jzodTuple: z.ZodType<JzodTuple>;
+export declare const jzodUnion: z.ZodType<JzodUnion>;
+export declare const jzodBootstrapElementSchema: z.ZodLazy<ZodType<JzodElement, z.ZodTypeDef, JzodElement>>;

package/dist/out-tsc/dts/src/index.d.ts

@@ -1,3 +1,3 @@
 export { jzodToTsCode, jzodToTsTypeAliasesAndZodText, TsTypeAliasesAndZodText as JzodTypeAliasesAndZodText, TsTypeAliases, } from "./JzodToTs";
 export { printTsTypeAlias, printTsTypeAliases } from "./tools";
-export { jzodArray, jzodAttribute, jzodAttributeDateValidations, jzodAttributeDateWithValidations, jzodAttributeNumberValidations, jzodAttributeNumberWithValidations, jzodAttributeStringValidations, jzodAttributeStringWithValidations, jzodElement, jzodEnumAttributeTypes, jzodEnumElementTypes, jzodEnum, jzodFunction, jzodIntersection, jzodLazy, jzodLiteral, jzodMapSchema, jzodObject, jzodPromise, jzodRecord, jzodReference, jzodSet, jzodTuple, jzodUnion, JzodArray, JzodAttribute, JzodAttributeDateValidations, JzodAttributeDateWithValidations, JzodAttributeNumberValidations, JzodAttributeNumberWithValidations, JzodAttributeStringValidations, JzodAttributeStringWithValidations, JzodElement, JzodEnum, JzodEnumTypes, JzodFunction, JzodEnumElementTypes, JzodIntersection, JzodLazy, JzodLiteral, JzodMap, JzodObject, JzodPromise, JzodRecord, JzodReference, JzodSet, JzodUnion, JzodTuple, } from "./JzodTsInterface";
+export { jzodArray, jzodAttribute, jzodAttributeDateValidations, jzodAttributeDateWithValidations, jzodAttributeNumberValidations, jzodAttributeNumberWithValidations, jzodAttributeStringValidations, jzodAttributeStringWithValidations, jzodElement, jzodEnumAttributeTypes, jzodEnumElementTypes, jzodEnum, jzodFunction, jzodIntersection, jzodLazy, jzodLiteral, jzodMap, jzodObject, jzodPromise, jzodRecord, jzodReference, jzodSet, jzodTuple, jzodUnion, JzodArray, JzodAttribute, JzodAttributeDateValidations, JzodAttributeDateWithValidations, JzodAttributeNumberValidations, JzodAttributeNumberWithValidations, JzodAttributeStringValidations, JzodAttributeStringWithValidations, JzodElement, JzodEnum, JzodEnumAttributeTypes, JzodFunction, JzodEnumElementTypes, JzodIntersection, JzodLazy, JzodLiteral, JzodMap, JzodObject, JzodPromise, JzodRecord, JzodReference, JzodSet, JzodUnion, JzodTuple, } from "./generated_jzodBootstrapElementSchema";

package/dist/src/JzodToTs.d.ts

@@ -14,4 +14,4 @@ export interface TsTypeAliasesAndZodText {
     mainZodText: string;
 }
 export declare function jzodToTsTypeAliasesAndZodText(element: JzodElement, typeName?: string): TsTypeAliasesAndZodText;
-export declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string, typeSchema?: boolean): string;
+export declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string, typeAnotationForSchema?: string[]): string;

package/dist/src/generated_jzodBootstrapElementSchema.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { ZodType, z } from "zod";
 export type JzodBaseObject = {
     optional?: boolean | undefined;
     nullable?: boolean | undefined;
@@ -40,6 +40,7 @@ export type JzodAttributeDateWithValidations = {
     } | undefined;
     type: "simpleType";
     definition: "date";
+    coerce?: boolean | undefined;
     validations: JzodAttributeDateValidations[];
 };
 export type JzodAttributeNumberValidations = {
@@ -57,6 +58,7 @@ export type JzodAttributeNumberWithValidations = {
     } | undefined;
     type: "simpleType";
     definition: "number";
+    coerce?: boolean | undefined;
     validations: JzodAttributeNumberValidations[];
 };
 export type JzodAttributeStringValidations = {
@@ -74,6 +76,7 @@ export type JzodAttributeStringWithValidations = {
     } | undefined;
     type: "simpleType";
     definition: "string";
+    coerce?: boolean | undefined;
     validations: JzodAttributeStringValidations[];
 };
 export type JzodElement = JzodArray | JzodAttribute | JzodAttributeDateWithValidations | JzodAttributeNumberWithValidations | JzodAttributeStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodObject | JzodPromise | JzodRecord | JzodReference | JzodSet | JzodTuple | JzodUnion;
@@ -116,7 +119,7 @@ export type JzodLiteral = {
         [x: string]: any;
     } | undefined;
     type: "literal";
-    definition: string;
+    definition: string | number | bigint | boolean;
 };
 export type JzodIntersection = {
     optional?: boolean | undefined;
@@ -151,6 +154,7 @@ export type JzodObject = {
     extend?: (JzodReference | JzodObject) | undefined;
     type: "object";
     nonStrict?: boolean | undefined;
+    partial?: boolean | undefined;
     definition: {
         [x: string]: JzodElement;
     };
@@ -243,4 +247,4 @@ export declare const jzodReference: z.ZodType<JzodReference>;
 export declare const jzodSet: z.ZodType<JzodSet>;
 export declare const jzodTuple: z.ZodType<JzodTuple>;
 export declare const jzodUnion: z.ZodType<JzodUnion>;
-export declare const jzodBootstrapElementSchema: z.ZodType<JzodBootstrapElementSchema>;
+export declare const jzodBootstrapElementSchema: z.ZodLazy<ZodType<JzodElement, z.ZodTypeDef, JzodElement>>;

package/package.json

@@ -1,23 +1,24 @@
 {
   "name": "@miroir-framework/jzod-ts",
   "private": false,
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "The Typescript-related functionalities of Jzod.",
   "main": "dist/bundle.js",
   "types": "dist/bundle.d.ts",
   "type": "module",
   "scripts": {
-    "preBuild": "npm run-script ./dist/out-tsc/src/preBuild.js",
+    "preBuild": "tsc --rootDir . --baseUrl . --module ESnext --target ES2017 --moduleResolution node --allowSyntheticDefaultImports --outdir ./tmp/ && node ./tmp/src/preBuild.js",
+    "preBuildRun": "node ./tmp/src/preBuild.js",
     "compile": "npx tsc",
     "build": "rollup --config",
     "test": "cross-env NODE_ENV=test jest --verbose --silent=false -t"
   },
-  "author": "Arnaud Bailly <miroir-framework@protonmail.com>",
+  "author": "Miroir Framework <miroir-framework@protonmail.com>",
   "homepage": "https://github.com/miroir-framework/jzod/#readme",
   "bugs": "https://github.com/miroir-framework/jzod/issues",
   "license": "MIT",
   "dependencies": {
-    "@miroir-framework/jzod": "0.6.0",
+    "@miroir-framework/jzod": "0.6.2",
     "zod": "^3.22.2",
     "zod-to-ts": "^1.2.0"
   },

package/src/JzodToTs.ts

@@ -27,14 +27,14 @@ export function jzodToTsTypeAliasesAndZodText(
 ): TsTypeAliasesAndZodText
 {
   const elementZodSchemaAndDescription = jzodElementSchemaToZodSchemaAndDescription(
-    element,
+    element as any,
     () => ({}),
     () => ({}),
     (innerReference: ZodTypeAny & GetType, relativeReference: string | undefined) =>
       withGetType(innerReference, (ts:any) => {
         const actualTypeName = relativeReference?relativeReference.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
         return ts.factory.createTypeReferenceNode(
-          ts.factory.createIdentifier(actualTypeName ? actualTypeName : "RELATIVEPATH_NOT_DEFINED"),
+          ts.factory.createIdentifier(actualTypeName ?? "RELATIVEPATH_NOT_DEFINED"),
           undefined
         );
       }
@@ -67,7 +67,8 @@ export function jzodToTsCode (
   jzodElement: JzodElement,
   exportPrefix: boolean = true,
   typeName?: string,
-  typeSchema: boolean = false,
+  // typeSchema: boolean = false,
+  typeAnotationForSchema: string[] = [],
 ): string {
   // console.log(
   //   "################################### jzodToTsCode ",
@@ -77,13 +78,14 @@ export function jzodToTsCode (
   
   const schemaName = typeName?typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c):"";
   const actualTypeName = typeName?typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
-  // console.log("jzodToTsCode convertedJsonZodSchema", bodyJsCode);
+
+  // console.log("jzodToTsCode typeAnotationForSchema", typeAnotationForSchema);
 
   const header = `import { ZodType, ZodTypeAny, z } from "zod";`;
 
   const typeAliasesAndZodText = jzodToTsTypeAliasesAndZodText(jzodElement, actualTypeName);
 
-  const bodyJsCode = typeSchema
+  const bodyJsCode = typeAnotationForSchema.includes(schemaName??"")
     ? `export const ${schemaName}: z.ZodType<${actualTypeName}> = ${typeAliasesAndZodText.mainZodText};`
     : `export const ${schemaName} = ${typeAliasesAndZodText.mainZodText};`;
 
@@ -93,12 +95,14 @@ export function jzodToTsCode (
   const contextJsCode = typeAliasesAndZodText.contextZodText
     ? Object.entries(typeAliasesAndZodText.contextZodText).reduce((acc, curr) => {
       const contextTypeName = curr[0]?curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
-      return typeSchema?
+      return typeAnotationForSchema.includes(curr[0])?
         `${acc}
-export const ${curr[0]}: z.ZodType<${contextTypeName}> = ${curr[1]};`:
+export const ${curr[0]}: z.ZodType<${contextTypeName}> = ${curr[1]};`
+      :
         `${acc}
-export const ${curr[0]} = ${curr[1]};`;
-      }, "")
+export const ${curr[0]} = ${curr[1]};`
+      ;
+    }, "")
     : ""
   ;