@miroir-framework/jzod-ts 0.7.0 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/dist/index.cjs +221 -0
  2. package/dist/index.d.ts +404 -0
  3. package/dist/index.js +177 -0
  4. package/package.json +34 -13
  5. package/dist/bundle.d.ts +0 -303
  6. package/dist/bundle.js +0 -97
package/dist/index.cjs ADDED
@@ -0,0 +1,221 @@
1
+ "use strict";
2
+ var __defProp = Object.defineProperty;
3
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
+ var __getOwnPropNames = Object.getOwnPropertyNames;
5
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
6
+ var __export = (target, all) => {
7
+ for (var name in all)
8
+ __defProp(target, name, { get: all[name], enumerable: true });
9
+ };
10
+ var __copyProps = (to, from, except, desc) => {
11
+ if (from && typeof from === "object" || typeof from === "function") {
12
+ for (let key of __getOwnPropNames(from))
13
+ if (!__hasOwnProp.call(to, key) && key !== except)
14
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
15
+ }
16
+ return to;
17
+ };
18
+ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
19
+
20
+ // src/index.ts
21
+ var index_exports = {};
22
+ __export(index_exports, {
23
+ jzodArray: () => jzodArray,
24
+ jzodAttributeDateValidations: () => jzodAttributeDateValidations,
25
+ jzodAttributeNumberValidations: () => jzodAttributeNumberValidations,
26
+ jzodAttributePlainDateWithValidations: () => jzodAttributePlainDateWithValidations,
27
+ jzodAttributePlainNumberWithValidations: () => jzodAttributePlainNumberWithValidations,
28
+ jzodAttributePlainStringWithValidations: () => jzodAttributePlainStringWithValidations,
29
+ jzodAttributeStringValidations: () => jzodAttributeStringValidations,
30
+ jzodElement: () => jzodElement,
31
+ jzodEnum: () => jzodEnum,
32
+ jzodEnumAttributeTypes: () => jzodEnumAttributeTypes,
33
+ jzodEnumElementTypes: () => jzodEnumElementTypes,
34
+ jzodFunction: () => jzodFunction,
35
+ jzodIntersection: () => jzodIntersection,
36
+ jzodLazy: () => jzodLazy,
37
+ jzodLiteral: () => jzodLiteral,
38
+ jzodMap: () => jzodMap,
39
+ jzodObject: () => jzodObject,
40
+ jzodPlainAttribute: () => jzodPlainAttribute,
41
+ jzodPromise: () => jzodPromise,
42
+ jzodRecord: () => jzodRecord,
43
+ jzodReference: () => jzodReference,
44
+ jzodSet: () => jzodSet,
45
+ jzodToTsCode: () => jzodToTsCode,
46
+ jzodToZodTextAndTsTypeAliases: () => jzodToZodTextAndTsTypeAliases,
47
+ jzodToZodTextAndZodSchemaForTsGeneration: () => jzodToZodTextAndZodSchemaForTsGeneration,
48
+ jzodTuple: () => jzodTuple,
49
+ jzodUnion: () => jzodUnion
50
+ });
51
+ module.exports = __toCommonJS(index_exports);
52
+
53
+ // src/JzodToTs.ts
54
+ var import_zod_to_ts = require("zod-to-ts");
55
+ var import_jzod = require("@miroir-framework/jzod");
56
+ function jzodToZodTextAndZodSchemaForTsGeneration(element, context = {}) {
57
+ const contextFunction = () => context;
58
+ const elementZodSchemaAndDescription = (0, import_jzod.jzodToZodTextAndZodSchema)(
59
+ element,
60
+ contextFunction,
61
+ contextFunction,
62
+ true
63
+ // typeScriptGeneration
64
+ );
65
+ return elementZodSchemaAndDescription;
66
+ }
67
+ function jzodToZodTextAndTsTypeText(element, context = {}, typeName) {
68
+ const elementZodSchemaAndDescription = jzodToZodTextAndZodSchemaForTsGeneration(
69
+ element,
70
+ context
71
+ );
72
+ const contextTsTypesStringObject = Object.fromEntries(
73
+ Object.entries(elementZodSchemaAndDescription.contextZodSchema ?? {}).map((curr) => {
74
+ const actualTypeName2 = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
75
+ const tsNode = (0, import_zod_to_ts.zodToTs)(curr[1], typeName).node;
76
+ const typeAlias = (0, import_zod_to_ts.createTypeAlias)(tsNode, actualTypeName2);
77
+ const tsTypeString2 = (0, import_zod_to_ts.printNode)(typeAlias);
78
+ console.log("jzodToZodTextAndTsTypeText producing TS type for contextElement", curr[0]);
79
+ return [curr[0], tsTypeString2];
80
+ })
81
+ );
82
+ const actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
83
+ const tsTypeStringNode = (0, import_zod_to_ts.zodToTs)(elementZodSchemaAndDescription.zodSchema, typeName).node;
84
+ const tsTypeAlias = (0, import_zod_to_ts.createTypeAlias)(tsTypeStringNode, actualTypeName);
85
+ const tsTypeString = (0, import_zod_to_ts.printNode)(tsTypeAlias);
86
+ return {
87
+ contextTsTypeText: contextTsTypesStringObject,
88
+ contextZodText: elementZodSchemaAndDescription.contextZodText ?? {},
89
+ zodText: elementZodSchemaAndDescription.zodText,
90
+ tsTypeText: tsTypeString
91
+ };
92
+ }
93
+ function jzodToZodTextAndTsTypeAliases(element, context = {}, typeName) {
94
+ const jzodToTsTypeAliasesAndZodTextStartTime = Date.now();
95
+ console.log("@@@@@@@@@@@@@@@@@ jzodToZodTextAndTsTypeAliases start!", Object.keys(context).length);
96
+ console.log("jzodToZodTextAndTsTypeAliases context:", JSON.stringify(Object.keys(context)));
97
+ const elementZodSchemaAndDescription = jzodToZodTextAndZodSchemaForTsGeneration(
98
+ element,
99
+ context
100
+ );
101
+ console.log(
102
+ "jzodToZodTextAndTsTypeAliases jzodToZodTextAndZodSchemaForTsGeneration duration",
103
+ Date.now() - jzodToTsTypeAliasesAndZodTextStartTime,
104
+ "ms"
105
+ );
106
+ const contextTsTypesStringStartTime = Date.now();
107
+ const contextTsTypesString = Object.fromEntries(
108
+ Object.entries(elementZodSchemaAndDescription.contextZodSchema ?? {}).map((curr) => {
109
+ console.log("jzodToZodTextAndTsTypeAliases converting elementZodSchemaAndDescription entry", curr[0]);
110
+ const actualTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
111
+ const tsNode = (0, import_zod_to_ts.zodToTs)(curr[1], typeName).node;
112
+ const typeAlias = (0, import_zod_to_ts.createTypeAlias)(tsNode, actualTypeName);
113
+ return [curr[0], typeAlias];
114
+ })
115
+ );
116
+ console.log(
117
+ "jzodToZodTextAndTsTypeAliases contextTsTypesString duration",
118
+ Date.now() - contextTsTypesStringStartTime,
119
+ "ms"
120
+ );
121
+ const tsTypeStringNodeStartTime = Date.now();
122
+ const tsTypeStringNode = (0, import_zod_to_ts.zodToTs)(elementZodSchemaAndDescription.zodSchema, typeName).node;
123
+ const tsTypeStringTypeAlias = (0, import_zod_to_ts.createTypeAlias)(tsTypeStringNode, typeName ?? "");
124
+ console.log(
125
+ "jzodToZodTextAndTsTypeAliases tsTypeStringNode duration",
126
+ Date.now() - tsTypeStringNodeStartTime,
127
+ "ms"
128
+ );
129
+ console.log("@@@@@@@@@@@@@@@@@ jzodToZodTextAndTsTypeAliases end in:", Date.now() - jzodToTsTypeAliasesAndZodTextStartTime, "ms");
130
+ return {
131
+ contextTsTypeAliases: contextTsTypesString,
132
+ contextZodText: elementZodSchemaAndDescription.contextZodText ?? {},
133
+ zodText: elementZodSchemaAndDescription.zodText,
134
+ mainTsTypeAlias: tsTypeStringTypeAlias
135
+ };
136
+ }
137
+ function jzodToTsCode(typeName, jzodElement2, context = {}, exportPrefix = true, headerForZodImports = true, typeAnotationForSchema = [], extendedTsTypesText = "") {
138
+ const schemaName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c) : "";
139
+ const actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
140
+ const header = headerForZodImports ? `import { ZodType, ZodTypeAny, z } from "zod";` : "";
141
+ const tsTypeStringsAndZodText = jzodToZodTextAndTsTypeText(jzodElement2, context, actualTypeName);
142
+ const contextTsTypesString = tsTypeStringsAndZodText.contextTsTypeText ? Object.entries(tsTypeStringsAndZodText.contextTsTypeText).reduce((acc, curr) => {
143
+ return exportPrefix ? `${acc}
144
+ export ${curr[1]}` : `${acc}
145
+ ${curr[1]}`;
146
+ }, "") : "";
147
+ const contextJsCode = tsTypeStringsAndZodText.contextZodText ? Object.entries(tsTypeStringsAndZodText.contextZodText).reduce((acc, curr) => {
148
+ const contextTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
149
+ return typeAnotationForSchema.includes(curr[0]) ? `${acc}
150
+ export const ${curr[0]}: z.ZodType<${contextTypeName}> = ${curr[1]};` : `${acc}
151
+ export const ${curr[0]} = ${curr[1]};`;
152
+ }, "") : "";
153
+ const bodyTsCode = (exportPrefix ? "export " : "") + tsTypeStringsAndZodText.tsTypeText;
154
+ const bodyJsCode = typeAnotationForSchema.includes(schemaName ?? "") ? `export const ${schemaName}: z.ZodType<${actualTypeName}> = ${tsTypeStringsAndZodText.zodText};` : `export const ${schemaName} = ${tsTypeStringsAndZodText.zodText};`;
155
+ return `${header}
156
+ ${extendedTsTypesText ?? ""}
157
+ ${contextTsTypesString}
158
+ ${bodyTsCode}
159
+ ${contextJsCode}
160
+ ${bodyJsCode}
161
+ `;
162
+ }
163
+
164
+ // src/generated_jzodBootstrapElementSchema.ts
165
+ var import_zod = require("zod");
166
+ var jzodBaseObject = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional() }).strict();
167
+ var jzodArray = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("array"), definition: import_zod.z.lazy(() => jzodElement) }).strict();
168
+ var jzodPlainAttribute = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.lazy(() => jzodEnumAttributeTypes), coerce: import_zod.z.boolean().optional() }).strict();
169
+ var jzodAttributeDateValidations = import_zod.z.object({ extra: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional(), type: import_zod.z.enum(["min", "max"]), parameter: import_zod.z.any() }).strict();
170
+ var jzodAttributePlainDateWithValidations = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("date"), coerce: import_zod.z.boolean().optional(), validations: import_zod.z.array(import_zod.z.lazy(() => jzodAttributeDateValidations)) }).strict();
171
+ var jzodAttributeNumberValidations = import_zod.z.object({ extra: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional(), type: import_zod.z.enum(["gt", "gte", "lt", "lte", "int", "positive", "nonpositive", "negative", "nonnegative", "multipleOf", "finite", "safe"]), parameter: import_zod.z.any() }).strict();
172
+ var jzodAttributePlainNumberWithValidations = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("number"), coerce: import_zod.z.boolean().optional(), validations: import_zod.z.array(import_zod.z.lazy(() => jzodAttributeNumberValidations)) }).strict();
173
+ var jzodAttributeStringValidations = import_zod.z.object({ extra: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional(), type: import_zod.z.enum(["max", "min", "length", "email", "url", "emoji", "uuid", "cuid", "cuid2", "ulid", "regex", "includes", "startsWith", "endsWith", "datetime", "ip"]), parameter: import_zod.z.any() }).strict();
174
+ var jzodAttributePlainStringWithValidations = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("string"), coerce: import_zod.z.boolean().optional(), validations: import_zod.z.array(import_zod.z.lazy(() => jzodAttributeStringValidations)) }).strict();
175
+ var jzodElement = import_zod.z.union([import_zod.z.lazy(() => jzodArray), import_zod.z.lazy(() => jzodPlainAttribute), import_zod.z.lazy(() => jzodAttributePlainDateWithValidations), import_zod.z.lazy(() => jzodAttributePlainNumberWithValidations), import_zod.z.lazy(() => jzodAttributePlainStringWithValidations), import_zod.z.lazy(() => jzodEnum), import_zod.z.lazy(() => jzodFunction), import_zod.z.lazy(() => jzodLazy), import_zod.z.lazy(() => jzodLiteral), import_zod.z.lazy(() => jzodIntersection), import_zod.z.lazy(() => jzodMap), import_zod.z.lazy(() => jzodObject), import_zod.z.lazy(() => jzodPromise), import_zod.z.lazy(() => jzodRecord), import_zod.z.lazy(() => jzodReference), import_zod.z.lazy(() => jzodSet), import_zod.z.lazy(() => jzodTuple), import_zod.z.lazy(() => jzodUnion)]);
176
+ var jzodEnum = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("enum"), definition: import_zod.z.array(import_zod.z.string()) }).strict();
177
+ var jzodEnumAttributeTypes = import_zod.z.enum(["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]);
178
+ var jzodEnumElementTypes = import_zod.z.enum(["array", "date", "enum", "function", "lazy", "literal", "intersection", "map", "number", "object", "promise", "record", "schemaReference", "set", "string", "tuple", "union"]);
179
+ var jzodFunction = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("function"), definition: import_zod.z.object({ args: import_zod.z.array(import_zod.z.lazy(() => jzodElement)), returns: import_zod.z.lazy(() => jzodElement).optional() }).strict() }).strict();
180
+ var jzodLazy = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("lazy"), definition: import_zod.z.lazy(() => jzodReference) }).strict();
181
+ var jzodLiteral = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("literal"), definition: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.bigint(), import_zod.z.boolean()]) }).strict();
182
+ var jzodIntersection = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("intersection"), definition: import_zod.z.object({ left: import_zod.z.lazy(() => jzodElement), right: import_zod.z.lazy(() => jzodElement) }).strict() }).strict();
183
+ var jzodMap = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("map"), definition: import_zod.z.tuple([import_zod.z.lazy(() => jzodElement), import_zod.z.lazy(() => jzodElement)]) }).strict();
184
+ var jzodObject = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), extend: import_zod.z.union([import_zod.z.union([import_zod.z.lazy(() => jzodReference), import_zod.z.lazy(() => jzodObject)]).optional(), import_zod.z.array(import_zod.z.union([import_zod.z.lazy(() => jzodReference), import_zod.z.lazy(() => jzodObject)]).optional())]).optional(), type: import_zod.z.literal("object"), nonStrict: import_zod.z.boolean().optional(), partial: import_zod.z.boolean().optional(), carryOn: import_zod.z.union([import_zod.z.lazy(() => jzodObject), import_zod.z.lazy(() => jzodUnion)]).optional(), definition: import_zod.z.record(import_zod.z.string(), import_zod.z.lazy(() => jzodElement)) }).strict();
185
+ var jzodPromise = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("promise"), definition: import_zod.z.lazy(() => jzodElement) }).strict();
186
+ var jzodRecord = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("record"), definition: import_zod.z.lazy(() => jzodElement) }).strict();
187
+ var jzodReference = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("schemaReference"), context: import_zod.z.record(import_zod.z.string(), import_zod.z.lazy(() => jzodElement)).optional(), carryOn: import_zod.z.union([import_zod.z.lazy(() => jzodObject), import_zod.z.lazy(() => jzodUnion)]).optional(), definition: import_zod.z.object({ eager: import_zod.z.boolean().optional(), partial: import_zod.z.boolean().optional(), relativePath: import_zod.z.string().optional(), absolutePath: import_zod.z.string().optional() }).strict() }).strict();
188
+ var jzodSet = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("set"), definition: import_zod.z.lazy(() => jzodElement) }).strict();
189
+ var jzodTuple = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("tuple"), definition: import_zod.z.array(import_zod.z.lazy(() => jzodElement)) }).strict();
190
+ var jzodUnion = import_zod.z.object({ optional: import_zod.z.boolean().optional(), nullable: import_zod.z.boolean().optional(), extra: import_zod.z.any().optional(), tag: import_zod.z.object({ value: import_zod.z.any(), schema: import_zod.z.object({ optional: import_zod.z.boolean().optional(), metaSchema: import_zod.z.lazy(() => jzodElement).optional(), valueSchema: import_zod.z.lazy(() => jzodElement).optional() }).strict().optional(), optional: import_zod.z.boolean().optional() }).strict().optional(), type: import_zod.z.literal("union"), discriminator: import_zod.z.union([import_zod.z.object({ discriminatorType: import_zod.z.literal("string"), value: import_zod.z.string() }).strict(), import_zod.z.object({ discriminatorType: import_zod.z.literal("array"), value: import_zod.z.array(import_zod.z.string()) }).strict()]).optional(), carryOn: import_zod.z.union([import_zod.z.lazy(() => jzodObject), import_zod.z.lazy(() => jzodUnion)]).optional(), definition: import_zod.z.array(import_zod.z.lazy(() => jzodElement)) }).strict();
191
+ var jzodBootstrapElementSchema = import_zod.z.lazy(() => jzodElement);
192
+ // Annotate the CommonJS export names for ESM import in node:
193
+ 0 && (module.exports = {
194
+ jzodArray,
195
+ jzodAttributeDateValidations,
196
+ jzodAttributeNumberValidations,
197
+ jzodAttributePlainDateWithValidations,
198
+ jzodAttributePlainNumberWithValidations,
199
+ jzodAttributePlainStringWithValidations,
200
+ jzodAttributeStringValidations,
201
+ jzodElement,
202
+ jzodEnum,
203
+ jzodEnumAttributeTypes,
204
+ jzodEnumElementTypes,
205
+ jzodFunction,
206
+ jzodIntersection,
207
+ jzodLazy,
208
+ jzodLiteral,
209
+ jzodMap,
210
+ jzodObject,
211
+ jzodPlainAttribute,
212
+ jzodPromise,
213
+ jzodRecord,
214
+ jzodReference,
215
+ jzodSet,
216
+ jzodToTsCode,
217
+ jzodToZodTextAndTsTypeAliases,
218
+ jzodToZodTextAndZodSchemaForTsGeneration,
219
+ jzodTuple,
220
+ jzodUnion
221
+ });
package/dist/index.d.ts ADDED
@@ -0,0 +1,404 @@
1
+ import ts from 'typescript';
2
+ import { ZodTextAndZodSchemaRecord, ZodTextAndZodSchema } from '@miroir-framework/jzod';
3
+ import { z } from 'zod';
4
+
5
+ interface TsTypeAliasesAndZodText {
6
+ contextTsTypeAliases: {
7
+ [k: string]: ts.TypeAliasDeclaration;
8
+ };
9
+ contextZodText: {
10
+ [k: string]: string;
11
+ };
12
+ mainTsTypeAlias: ts.TypeAliasDeclaration;
13
+ zodText: string;
14
+ }
15
+ declare function jzodToZodTextAndZodSchemaForTsGeneration(element: any, // to avoid circularity on JzodElement
16
+ context?: ZodTextAndZodSchemaRecord): ZodTextAndZodSchema;
17
+ declare function jzodToZodTextAndTsTypeAliases(element: any, // to avoid circularity on JzodElement
18
+ context?: ZodTextAndZodSchemaRecord, typeName?: string): TsTypeAliasesAndZodText;
19
+ /**
20
+ *
21
+ * @param typeName the name given to the resulting TS type definition
22
+ * @param jzodElement the JzodElement to convert to TS code
23
+ * @param context the context of the JzodElement, to be used for recursive types, for example.
24
+ * @param exportPrefix true if the resulting TS code should be prefixed with "export "
25
+ * @param typeAnotationForSchema adds a type annotation for the resulting TS type definition, in the form of ZodType<typeName>. This is useful for the linter, to precisely define the type, instead of relying on potentially coarser type inference mechanism. Recursive types cannot use this feature.
26
+ * @param extendedTsTypesText a string containing additional TS types to be included in the resulting TS code, for example, types that are used in the context of the JzodElement, but are not defined in the JzodElement itself.
27
+ * @returns a string containing the resulting TS code
28
+ */
29
+ declare function jzodToTsCode(typeName: string, jzodElement: any, // to avoid circulatity on JzodElement
30
+ context?: ZodTextAndZodSchemaRecord, exportPrefix?: boolean, headerForZodImports?: boolean, typeAnotationForSchema?: string[], extendedTsTypesText?: string): string;
31
+
32
+ type JzodArray = {
33
+ optional?: boolean | undefined;
34
+ nullable?: boolean | undefined;
35
+ extra?: any | undefined;
36
+ tag?: {
37
+ value?: any;
38
+ schema?: {
39
+ optional?: boolean | undefined;
40
+ metaSchema?: JzodElement | undefined;
41
+ valueSchema?: JzodElement | undefined;
42
+ } | undefined;
43
+ optional?: boolean | undefined;
44
+ } | undefined;
45
+ type: "array";
46
+ definition: JzodElement;
47
+ };
48
+ type JzodPlainAttribute = {
49
+ optional?: boolean | undefined;
50
+ nullable?: boolean | undefined;
51
+ extra?: any | undefined;
52
+ tag?: {
53
+ value?: any;
54
+ schema?: {
55
+ optional?: boolean | undefined;
56
+ metaSchema?: JzodElement | undefined;
57
+ valueSchema?: JzodElement | undefined;
58
+ } | undefined;
59
+ optional?: boolean | undefined;
60
+ } | undefined;
61
+ type: JzodEnumAttributeTypes;
62
+ coerce?: boolean | undefined;
63
+ };
64
+ type JzodAttributeDateValidations = {
65
+ extra?: {
66
+ [x: string]: any;
67
+ } | undefined;
68
+ type: "min" | "max";
69
+ parameter?: any;
70
+ };
71
+ type JzodAttributePlainDateWithValidations = {
72
+ optional?: boolean | undefined;
73
+ nullable?: boolean | undefined;
74
+ extra?: any | undefined;
75
+ tag?: {
76
+ value?: any;
77
+ schema?: {
78
+ optional?: boolean | undefined;
79
+ metaSchema?: JzodElement | undefined;
80
+ valueSchema?: JzodElement | undefined;
81
+ } | undefined;
82
+ optional?: boolean | undefined;
83
+ } | undefined;
84
+ type: "date";
85
+ coerce?: boolean | undefined;
86
+ validations: JzodAttributeDateValidations[];
87
+ };
88
+ type JzodAttributeNumberValidations = {
89
+ extra?: {
90
+ [x: string]: any;
91
+ } | undefined;
92
+ type: "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "multipleOf" | "finite" | "safe";
93
+ parameter?: any;
94
+ };
95
+ type JzodAttributePlainNumberWithValidations = {
96
+ optional?: boolean | undefined;
97
+ nullable?: boolean | undefined;
98
+ extra?: any | undefined;
99
+ tag?: {
100
+ value?: any;
101
+ schema?: {
102
+ optional?: boolean | undefined;
103
+ metaSchema?: JzodElement | undefined;
104
+ valueSchema?: JzodElement | undefined;
105
+ } | undefined;
106
+ optional?: boolean | undefined;
107
+ } | undefined;
108
+ type: "number";
109
+ coerce?: boolean | undefined;
110
+ validations: JzodAttributeNumberValidations[];
111
+ };
112
+ type JzodAttributeStringValidations = {
113
+ extra?: {
114
+ [x: string]: any;
115
+ } | undefined;
116
+ type: "max" | "min" | "length" | "email" | "url" | "emoji" | "uuid" | "cuid" | "cuid2" | "ulid" | "regex" | "includes" | "startsWith" | "endsWith" | "datetime" | "ip";
117
+ parameter?: any;
118
+ };
119
+ type JzodAttributePlainStringWithValidations = {
120
+ optional?: boolean | undefined;
121
+ nullable?: boolean | undefined;
122
+ extra?: any | undefined;
123
+ tag?: {
124
+ value?: any;
125
+ schema?: {
126
+ optional?: boolean | undefined;
127
+ metaSchema?: JzodElement | undefined;
128
+ valueSchema?: JzodElement | undefined;
129
+ } | undefined;
130
+ optional?: boolean | undefined;
131
+ } | undefined;
132
+ type: "string";
133
+ coerce?: boolean | undefined;
134
+ validations: JzodAttributeStringValidations[];
135
+ };
136
+ type JzodElement = JzodArray | JzodPlainAttribute | JzodAttributePlainDateWithValidations | JzodAttributePlainNumberWithValidations | JzodAttributePlainStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodObject | JzodPromise | JzodRecord | JzodReference | JzodSet | JzodTuple | JzodUnion;
137
+ type JzodEnum = {
138
+ optional?: boolean | undefined;
139
+ nullable?: boolean | undefined;
140
+ extra?: any | undefined;
141
+ tag?: {
142
+ value?: any;
143
+ schema?: {
144
+ optional?: boolean | undefined;
145
+ metaSchema?: JzodElement | undefined;
146
+ valueSchema?: JzodElement | undefined;
147
+ } | undefined;
148
+ optional?: boolean | undefined;
149
+ } | undefined;
150
+ type: "enum";
151
+ definition: string[];
152
+ };
153
+ type JzodEnumAttributeTypes = "any" | "bigint" | "boolean" | "date" | "never" | "null" | "number" | "string" | "uuid" | "undefined" | "unknown" | "void";
154
+ type JzodEnumElementTypes = "array" | "date" | "enum" | "function" | "lazy" | "literal" | "intersection" | "map" | "number" | "object" | "promise" | "record" | "schemaReference" | "set" | "string" | "tuple" | "union";
155
+ type JzodFunction = {
156
+ optional?: boolean | undefined;
157
+ nullable?: boolean | undefined;
158
+ extra?: any | undefined;
159
+ tag?: {
160
+ value?: any;
161
+ schema?: {
162
+ optional?: boolean | undefined;
163
+ metaSchema?: JzodElement | undefined;
164
+ valueSchema?: JzodElement | undefined;
165
+ } | undefined;
166
+ optional?: boolean | undefined;
167
+ } | undefined;
168
+ type: "function";
169
+ definition: {
170
+ args: JzodElement[];
171
+ returns?: JzodElement | undefined;
172
+ };
173
+ };
174
+ type JzodLazy = {
175
+ optional?: boolean | undefined;
176
+ nullable?: boolean | undefined;
177
+ extra?: any | undefined;
178
+ tag?: {
179
+ value?: any;
180
+ schema?: {
181
+ optional?: boolean | undefined;
182
+ metaSchema?: JzodElement | undefined;
183
+ valueSchema?: JzodElement | undefined;
184
+ } | undefined;
185
+ optional?: boolean | undefined;
186
+ } | undefined;
187
+ type: "lazy";
188
+ definition: JzodReference;
189
+ };
190
+ type JzodLiteral = {
191
+ optional?: boolean | undefined;
192
+ nullable?: boolean | undefined;
193
+ extra?: any | undefined;
194
+ tag?: {
195
+ value?: any;
196
+ schema?: {
197
+ optional?: boolean | undefined;
198
+ metaSchema?: JzodElement | undefined;
199
+ valueSchema?: JzodElement | undefined;
200
+ } | undefined;
201
+ optional?: boolean | undefined;
202
+ } | undefined;
203
+ type: "literal";
204
+ definition: string | number | bigint | boolean;
205
+ };
206
+ type JzodIntersection = {
207
+ optional?: boolean | undefined;
208
+ nullable?: boolean | undefined;
209
+ extra?: any | undefined;
210
+ tag?: {
211
+ value?: any;
212
+ schema?: {
213
+ optional?: boolean | undefined;
214
+ metaSchema?: JzodElement | undefined;
215
+ valueSchema?: JzodElement | undefined;
216
+ } | undefined;
217
+ optional?: boolean | undefined;
218
+ } | undefined;
219
+ type: "intersection";
220
+ definition: {
221
+ left: JzodElement;
222
+ right: JzodElement;
223
+ };
224
+ };
225
+ type JzodMap = {
226
+ optional?: boolean | undefined;
227
+ nullable?: boolean | undefined;
228
+ extra?: any | undefined;
229
+ tag?: {
230
+ value?: any;
231
+ schema?: {
232
+ optional?: boolean | undefined;
233
+ metaSchema?: JzodElement | undefined;
234
+ valueSchema?: JzodElement | undefined;
235
+ } | undefined;
236
+ optional?: boolean | undefined;
237
+ } | undefined;
238
+ type: "map";
239
+ definition: [
240
+ JzodElement,
241
+ JzodElement
242
+ ];
243
+ };
244
+ type JzodObject = {
245
+ optional?: boolean | undefined;
246
+ nullable?: boolean | undefined;
247
+ extra?: any | undefined;
248
+ tag?: {
249
+ value?: any;
250
+ schema?: {
251
+ optional?: boolean | undefined;
252
+ metaSchema?: JzodElement | undefined;
253
+ valueSchema?: JzodElement | undefined;
254
+ } | undefined;
255
+ optional?: boolean | undefined;
256
+ } | undefined;
257
+ extend?: (((JzodReference | JzodObject) | undefined) | ((JzodReference | JzodObject) | undefined)[]) | undefined;
258
+ type: "object";
259
+ nonStrict?: boolean | undefined;
260
+ partial?: boolean | undefined;
261
+ carryOn?: (JzodObject | JzodUnion) | undefined;
262
+ definition: {
263
+ [x: string]: JzodElement;
264
+ };
265
+ };
266
+ type JzodPromise = {
267
+ optional?: boolean | undefined;
268
+ nullable?: boolean | undefined;
269
+ extra?: any | undefined;
270
+ tag?: {
271
+ value?: any;
272
+ schema?: {
273
+ optional?: boolean | undefined;
274
+ metaSchema?: JzodElement | undefined;
275
+ valueSchema?: JzodElement | undefined;
276
+ } | undefined;
277
+ optional?: boolean | undefined;
278
+ } | undefined;
279
+ type: "promise";
280
+ definition: JzodElement;
281
+ };
282
+ type JzodRecord = {
283
+ optional?: boolean | undefined;
284
+ nullable?: boolean | undefined;
285
+ extra?: any | undefined;
286
+ tag?: {
287
+ value?: any;
288
+ schema?: {
289
+ optional?: boolean | undefined;
290
+ metaSchema?: JzodElement | undefined;
291
+ valueSchema?: JzodElement | undefined;
292
+ } | undefined;
293
+ optional?: boolean | undefined;
294
+ } | undefined;
295
+ type: "record";
296
+ definition: JzodElement;
297
+ };
298
+ type JzodReference = {
299
+ optional?: boolean | undefined;
300
+ nullable?: boolean | undefined;
301
+ extra?: any | undefined;
302
+ tag?: {
303
+ value?: any;
304
+ schema?: {
305
+ optional?: boolean | undefined;
306
+ metaSchema?: JzodElement | undefined;
307
+ valueSchema?: JzodElement | undefined;
308
+ } | undefined;
309
+ optional?: boolean | undefined;
310
+ } | undefined;
311
+ type: "schemaReference";
312
+ context?: {
313
+ [x: string]: JzodElement;
314
+ } | undefined;
315
+ carryOn?: (JzodObject | JzodUnion) | undefined;
316
+ definition: {
317
+ eager?: boolean | undefined;
318
+ partial?: boolean | undefined;
319
+ relativePath?: string | undefined;
320
+ absolutePath?: string | undefined;
321
+ };
322
+ };
323
+ type JzodSet = {
324
+ optional?: boolean | undefined;
325
+ nullable?: boolean | undefined;
326
+ extra?: any | undefined;
327
+ tag?: {
328
+ value?: any;
329
+ schema?: {
330
+ optional?: boolean | undefined;
331
+ metaSchema?: JzodElement | undefined;
332
+ valueSchema?: JzodElement | undefined;
333
+ } | undefined;
334
+ optional?: boolean | undefined;
335
+ } | undefined;
336
+ type: "set";
337
+ definition: JzodElement;
338
+ };
339
+ type JzodTuple = {
340
+ optional?: boolean | undefined;
341
+ nullable?: boolean | undefined;
342
+ extra?: any | undefined;
343
+ tag?: {
344
+ value?: any;
345
+ schema?: {
346
+ optional?: boolean | undefined;
347
+ metaSchema?: JzodElement | undefined;
348
+ valueSchema?: JzodElement | undefined;
349
+ } | undefined;
350
+ optional?: boolean | undefined;
351
+ } | undefined;
352
+ type: "tuple";
353
+ definition: JzodElement[];
354
+ };
355
+ type JzodUnion = {
356
+ optional?: boolean | undefined;
357
+ nullable?: boolean | undefined;
358
+ extra?: any | undefined;
359
+ tag?: {
360
+ value?: any;
361
+ schema?: {
362
+ optional?: boolean | undefined;
363
+ metaSchema?: JzodElement | undefined;
364
+ valueSchema?: JzodElement | undefined;
365
+ } | undefined;
366
+ optional?: boolean | undefined;
367
+ } | undefined;
368
+ type: "union";
369
+ discriminator?: ({
370
+ discriminatorType: "string";
371
+ value: string;
372
+ } | {
373
+ discriminatorType: "array";
374
+ value: string[];
375
+ }) | undefined;
376
+ carryOn?: (JzodObject | JzodUnion) | undefined;
377
+ definition: JzodElement[];
378
+ };
379
+ declare const jzodArray: z.ZodType<JzodArray>;
380
+ declare const jzodPlainAttribute: z.ZodType<JzodPlainAttribute>;
381
+ declare const jzodAttributeDateValidations: z.ZodType<JzodAttributeDateValidations>;
382
+ declare const jzodAttributePlainDateWithValidations: z.ZodType<JzodAttributePlainDateWithValidations>;
383
+ declare const jzodAttributeNumberValidations: z.ZodType<JzodAttributeNumberValidations>;
384
+ declare const jzodAttributePlainNumberWithValidations: z.ZodType<JzodAttributePlainNumberWithValidations>;
385
+ declare const jzodAttributeStringValidations: z.ZodType<JzodAttributeStringValidations>;
386
+ declare const jzodAttributePlainStringWithValidations: z.ZodType<JzodAttributePlainStringWithValidations>;
387
+ declare const jzodElement: z.ZodType<JzodElement>;
388
+ declare const jzodEnum: z.ZodType<JzodEnum>;
389
+ declare const jzodEnumAttributeTypes: z.ZodType<JzodEnumAttributeTypes>;
390
+ declare const jzodEnumElementTypes: z.ZodType<JzodEnumElementTypes>;
391
+ declare const jzodFunction: z.ZodType<JzodFunction>;
392
+ declare const jzodLazy: z.ZodType<JzodLazy>;
393
+ declare const jzodLiteral: z.ZodType<JzodLiteral>;
394
+ declare const jzodIntersection: z.ZodType<JzodIntersection>;
395
+ declare const jzodMap: z.ZodType<JzodMap>;
396
+ declare const jzodObject: z.ZodType<JzodObject>;
397
+ declare const jzodPromise: z.ZodType<JzodPromise>;
398
+ declare const jzodRecord: z.ZodType<JzodRecord>;
399
+ declare const jzodReference: z.ZodType<JzodReference>;
400
+ declare const jzodSet: z.ZodType<JzodSet>;
401
+ declare const jzodTuple: z.ZodType<JzodTuple>;
402
+ declare const jzodUnion: z.ZodType<JzodUnion>;
403
+
404
+ export { type JzodArray, type JzodAttributeDateValidations, type JzodAttributeNumberValidations, type JzodAttributePlainDateWithValidations, type JzodAttributePlainNumberWithValidations, type JzodAttributePlainStringWithValidations, type JzodAttributeStringValidations, type JzodElement, type JzodEnum, type JzodEnumAttributeTypes, type JzodEnumElementTypes, type JzodFunction, type JzodIntersection, type JzodLazy, type JzodLiteral, type JzodMap, type JzodObject, type JzodPlainAttribute, type JzodPromise, type JzodRecord, type JzodReference, type JzodSet, type JzodTuple, type JzodUnion, jzodArray, jzodAttributeDateValidations, jzodAttributeNumberValidations, jzodAttributePlainDateWithValidations, jzodAttributePlainNumberWithValidations, jzodAttributePlainStringWithValidations, jzodAttributeStringValidations, jzodElement, jzodEnum, jzodEnumAttributeTypes, jzodEnumElementTypes, jzodFunction, jzodIntersection, jzodLazy, jzodLiteral, jzodMap, jzodObject, jzodPlainAttribute, jzodPromise, jzodRecord, jzodReference, jzodSet, jzodToTsCode, jzodToZodTextAndTsTypeAliases, jzodToZodTextAndZodSchemaForTsGeneration, jzodTuple, jzodUnion };
package/dist/index.js ADDED
@@ -0,0 +1,177 @@
1
+ import { createRequire } from 'module'; const require = createRequire(import.meta.url);
2
+ import { fileURLToPath } from 'url'
3
+ import { dirname } from 'path'
4
+ const __filename = fileURLToPath(import.meta.url)
5
+ const __dirname = dirname(__filename)
6
+
7
+
8
+ // src/JzodToTs.ts
9
+ import { createTypeAlias, printNode, zodToTs } from "zod-to-ts";
10
+ import {
11
+ jzodToZodTextAndZodSchema
12
+ } from "@miroir-framework/jzod";
13
+ function jzodToZodTextAndZodSchemaForTsGeneration(element, context = {}) {
14
+ const contextFunction = () => context;
15
+ const elementZodSchemaAndDescription = jzodToZodTextAndZodSchema(
16
+ element,
17
+ contextFunction,
18
+ contextFunction,
19
+ true
20
+ // typeScriptGeneration
21
+ );
22
+ return elementZodSchemaAndDescription;
23
+ }
24
+ function jzodToZodTextAndTsTypeText(element, context = {}, typeName) {
25
+ const elementZodSchemaAndDescription = jzodToZodTextAndZodSchemaForTsGeneration(
26
+ element,
27
+ context
28
+ );
29
+ const contextTsTypesStringObject = Object.fromEntries(
30
+ Object.entries(elementZodSchemaAndDescription.contextZodSchema ?? {}).map((curr) => {
31
+ const actualTypeName2 = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
32
+ const tsNode = zodToTs(curr[1], typeName).node;
33
+ const typeAlias = createTypeAlias(tsNode, actualTypeName2);
34
+ const tsTypeString2 = printNode(typeAlias);
35
+ console.log("jzodToZodTextAndTsTypeText producing TS type for contextElement", curr[0]);
36
+ return [curr[0], tsTypeString2];
37
+ })
38
+ );
39
+ const actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
40
+ const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
41
+ const tsTypeAlias = createTypeAlias(tsTypeStringNode, actualTypeName);
42
+ const tsTypeString = printNode(tsTypeAlias);
43
+ return {
44
+ contextTsTypeText: contextTsTypesStringObject,
45
+ contextZodText: elementZodSchemaAndDescription.contextZodText ?? {},
46
+ zodText: elementZodSchemaAndDescription.zodText,
47
+ tsTypeText: tsTypeString
48
+ };
49
+ }
50
+ function jzodToZodTextAndTsTypeAliases(element, context = {}, typeName) {
51
+ const jzodToTsTypeAliasesAndZodTextStartTime = Date.now();
52
+ console.log("@@@@@@@@@@@@@@@@@ jzodToZodTextAndTsTypeAliases start!", Object.keys(context).length);
53
+ console.log("jzodToZodTextAndTsTypeAliases context:", JSON.stringify(Object.keys(context)));
54
+ const elementZodSchemaAndDescription = jzodToZodTextAndZodSchemaForTsGeneration(
55
+ element,
56
+ context
57
+ );
58
+ console.log(
59
+ "jzodToZodTextAndTsTypeAliases jzodToZodTextAndZodSchemaForTsGeneration duration",
60
+ Date.now() - jzodToTsTypeAliasesAndZodTextStartTime,
61
+ "ms"
62
+ );
63
+ const contextTsTypesStringStartTime = Date.now();
64
+ const contextTsTypesString = Object.fromEntries(
65
+ Object.entries(elementZodSchemaAndDescription.contextZodSchema ?? {}).map((curr) => {
66
+ console.log("jzodToZodTextAndTsTypeAliases converting elementZodSchemaAndDescription entry", curr[0]);
67
+ const actualTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
68
+ const tsNode = zodToTs(curr[1], typeName).node;
69
+ const typeAlias = createTypeAlias(tsNode, actualTypeName);
70
+ return [curr[0], typeAlias];
71
+ })
72
+ );
73
+ console.log(
74
+ "jzodToZodTextAndTsTypeAliases contextTsTypesString duration",
75
+ Date.now() - contextTsTypesStringStartTime,
76
+ "ms"
77
+ );
78
+ const tsTypeStringNodeStartTime = Date.now();
79
+ const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
80
+ const tsTypeStringTypeAlias = createTypeAlias(tsTypeStringNode, typeName ?? "");
81
+ console.log(
82
+ "jzodToZodTextAndTsTypeAliases tsTypeStringNode duration",
83
+ Date.now() - tsTypeStringNodeStartTime,
84
+ "ms"
85
+ );
86
+ console.log("@@@@@@@@@@@@@@@@@ jzodToZodTextAndTsTypeAliases end in:", Date.now() - jzodToTsTypeAliasesAndZodTextStartTime, "ms");
87
+ return {
88
+ contextTsTypeAliases: contextTsTypesString,
89
+ contextZodText: elementZodSchemaAndDescription.contextZodText ?? {},
90
+ zodText: elementZodSchemaAndDescription.zodText,
91
+ mainTsTypeAlias: tsTypeStringTypeAlias
92
+ };
93
+ }
94
+ function jzodToTsCode(typeName, jzodElement2, context = {}, exportPrefix = true, headerForZodImports = true, typeAnotationForSchema = [], extendedTsTypesText = "") {
95
+ const schemaName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c) : "";
96
+ const actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
97
+ const header = headerForZodImports ? `import { ZodType, ZodTypeAny, z } from "zod";` : "";
98
+ const tsTypeStringsAndZodText = jzodToZodTextAndTsTypeText(jzodElement2, context, actualTypeName);
99
+ const contextTsTypesString = tsTypeStringsAndZodText.contextTsTypeText ? Object.entries(tsTypeStringsAndZodText.contextTsTypeText).reduce((acc, curr) => {
100
+ return exportPrefix ? `${acc}
101
+ export ${curr[1]}` : `${acc}
102
+ ${curr[1]}`;
103
+ }, "") : "";
104
+ const contextJsCode = tsTypeStringsAndZodText.contextZodText ? Object.entries(tsTypeStringsAndZodText.contextZodText).reduce((acc, curr) => {
105
+ const contextTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
106
+ return typeAnotationForSchema.includes(curr[0]) ? `${acc}
107
+ export const ${curr[0]}: z.ZodType<${contextTypeName}> = ${curr[1]};` : `${acc}
108
+ export const ${curr[0]} = ${curr[1]};`;
109
+ }, "") : "";
110
+ const bodyTsCode = (exportPrefix ? "export " : "") + tsTypeStringsAndZodText.tsTypeText;
111
+ const bodyJsCode = typeAnotationForSchema.includes(schemaName ?? "") ? `export const ${schemaName}: z.ZodType<${actualTypeName}> = ${tsTypeStringsAndZodText.zodText};` : `export const ${schemaName} = ${tsTypeStringsAndZodText.zodText};`;
112
+ return `${header}
113
+ ${extendedTsTypesText ?? ""}
114
+ ${contextTsTypesString}
115
+ ${bodyTsCode}
116
+ ${contextJsCode}
117
+ ${bodyJsCode}
118
+ `;
119
+ }
120
+
121
+ // src/generated_jzodBootstrapElementSchema.ts
122
+ import { z } from "zod";
123
+ var jzodBaseObject = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional() }).strict();
124
+ var jzodArray = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("array"), definition: z.lazy(() => jzodElement) }).strict();
125
+ var jzodPlainAttribute = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.lazy(() => jzodEnumAttributeTypes), coerce: z.boolean().optional() }).strict();
126
+ var jzodAttributeDateValidations = z.object({ extra: z.record(z.string(), z.any()).optional(), type: z.enum(["min", "max"]), parameter: z.any() }).strict();
127
+ var jzodAttributePlainDateWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("date"), coerce: z.boolean().optional(), validations: z.array(z.lazy(() => jzodAttributeDateValidations)) }).strict();
128
+ var 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();
129
+ var jzodAttributePlainNumberWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("number"), coerce: z.boolean().optional(), validations: z.array(z.lazy(() => jzodAttributeNumberValidations)) }).strict();
130
+ var 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();
131
+ var jzodAttributePlainStringWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("string"), coerce: z.boolean().optional(), validations: z.array(z.lazy(() => jzodAttributeStringValidations)) }).strict();
132
+ var jzodElement = z.union([z.lazy(() => jzodArray), z.lazy(() => jzodPlainAttribute), z.lazy(() => jzodAttributePlainDateWithValidations), z.lazy(() => jzodAttributePlainNumberWithValidations), z.lazy(() => jzodAttributePlainStringWithValidations), 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)]);
133
+ var jzodEnum = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("enum"), definition: z.array(z.string()) }).strict();
134
+ var jzodEnumAttributeTypes = z.enum(["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]);
135
+ var jzodEnumElementTypes = z.enum(["array", "date", "enum", "function", "lazy", "literal", "intersection", "map", "number", "object", "promise", "record", "schemaReference", "set", "string", "tuple", "union"]);
136
+ var jzodFunction = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("function"), definition: z.object({ args: z.array(z.lazy(() => jzodElement)), returns: z.lazy(() => jzodElement).optional() }).strict() }).strict();
137
+ var jzodLazy = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("lazy"), definition: z.lazy(() => jzodReference) }).strict();
138
+ var jzodLiteral = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("literal"), definition: z.union([z.string(), z.number(), z.bigint(), z.boolean()]) }).strict();
139
+ var jzodIntersection = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("intersection"), definition: z.object({ left: z.lazy(() => jzodElement), right: z.lazy(() => jzodElement) }).strict() }).strict();
140
+ var jzodMap = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("map"), definition: z.tuple([z.lazy(() => jzodElement), z.lazy(() => jzodElement)]) }).strict();
141
+ var jzodObject = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), extend: z.union([z.union([z.lazy(() => jzodReference), z.lazy(() => jzodObject)]).optional(), z.array(z.union([z.lazy(() => jzodReference), z.lazy(() => jzodObject)]).optional())]).optional(), type: z.literal("object"), nonStrict: z.boolean().optional(), partial: z.boolean().optional(), carryOn: z.union([z.lazy(() => jzodObject), z.lazy(() => jzodUnion)]).optional(), definition: z.record(z.string(), z.lazy(() => jzodElement)) }).strict();
142
+ var jzodPromise = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("promise"), definition: z.lazy(() => jzodElement) }).strict();
143
+ var jzodRecord = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("record"), definition: z.lazy(() => jzodElement) }).strict();
144
+ var jzodReference = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("schemaReference"), context: z.record(z.string(), z.lazy(() => jzodElement)).optional(), carryOn: z.union([z.lazy(() => jzodObject), z.lazy(() => jzodUnion)]).optional(), definition: z.object({ eager: z.boolean().optional(), partial: z.boolean().optional(), relativePath: z.string().optional(), absolutePath: z.string().optional() }).strict() }).strict();
145
+ var jzodSet = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("set"), definition: z.lazy(() => jzodElement) }).strict();
146
+ var jzodTuple = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("tuple"), definition: z.array(z.lazy(() => jzodElement)) }).strict();
147
+ var jzodUnion = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.any().optional(), tag: z.object({ value: z.any(), schema: z.object({ optional: z.boolean().optional(), metaSchema: z.lazy(() => jzodElement).optional(), valueSchema: z.lazy(() => jzodElement).optional() }).strict().optional(), optional: z.boolean().optional() }).strict().optional(), type: z.literal("union"), discriminator: z.union([z.object({ discriminatorType: z.literal("string"), value: z.string() }).strict(), z.object({ discriminatorType: z.literal("array"), value: z.array(z.string()) }).strict()]).optional(), carryOn: z.union([z.lazy(() => jzodObject), z.lazy(() => jzodUnion)]).optional(), definition: z.array(z.lazy(() => jzodElement)) }).strict();
148
+ var jzodBootstrapElementSchema = z.lazy(() => jzodElement);
149
+ export {
150
+ jzodArray,
151
+ jzodAttributeDateValidations,
152
+ jzodAttributeNumberValidations,
153
+ jzodAttributePlainDateWithValidations,
154
+ jzodAttributePlainNumberWithValidations,
155
+ jzodAttributePlainStringWithValidations,
156
+ jzodAttributeStringValidations,
157
+ jzodElement,
158
+ jzodEnum,
159
+ jzodEnumAttributeTypes,
160
+ jzodEnumElementTypes,
161
+ jzodFunction,
162
+ jzodIntersection,
163
+ jzodLazy,
164
+ jzodLiteral,
165
+ jzodMap,
166
+ jzodObject,
167
+ jzodPlainAttribute,
168
+ jzodPromise,
169
+ jzodRecord,
170
+ jzodReference,
171
+ jzodSet,
172
+ jzodToTsCode,
173
+ jzodToZodTextAndTsTypeAliases,
174
+ jzodToZodTextAndZodSchemaForTsGeneration,
175
+ jzodTuple,
176
+ jzodUnion
177
+ };
package/package.json CHANGED
@@ -1,17 +1,23 @@
1
1
  {
2
2
  "name": "@miroir-framework/jzod-ts",
3
3
  "private": false,
4
- "version": "0.7.0",
4
+ "version": "0.8.0",
5
5
  "description": "The Typescript-related functionalities of Jzod.",
6
- "main": "dist/bundle.js",
7
- "types": "dist/bundle.d.ts",
6
+ "main": "dist/index.js",
7
+ "types": "dist/index.d.ts",
8
8
  "type": "module",
9
- "scripts": {
10
- "preBuild": "tsc --rootDir . --baseUrl . --module ESnext --target ES2017 --moduleResolution node --allowSyntheticDefaultImports --outdir ./tmp/ && node ./tmp/src/preBuild.js",
11
- "preBuildRun": "node ./tmp/src/preBuild.js",
12
- "build": "rollup --config",
13
- "test": "cross-env NODE_ENV=test jest --verbose --silent=false -t"
9
+ "exports": {
10
+ "./package.json": "./package.json",
11
+ ".": {
12
+ "import": "./dist/index.js",
13
+ "require": "./dist/index.cjs"
14
+ }
14
15
  },
16
+ "keywords": [
17
+ "zod",
18
+ "typescript",
19
+ "generator"
20
+ ],
15
21
  "author": "Miroir Framework <miroir-framework@protonmail.com>",
16
22
  "homepage": "https://github.com/miroir-framework/jzod/#readme",
17
23
  "bugs": "https://github.com/miroir-framework/jzod/issues",
@@ -19,28 +25,43 @@
19
25
  "files": [
20
26
  "LICENSE.md",
21
27
  "package.json",
22
- "dist/bundle.js",
23
- "dist/bundle.d.ts"
28
+ "dist/index.js",
29
+ "dist/index.cjs",
30
+ "dist/index.d.ts",
31
+ "dist/src/worker.js"
24
32
  ],
33
+ "scripts": {
34
+ "preBuild": "tsx ./scripts/preBuild.ts",
35
+ "build": "tsup",
36
+ "test": "cross-env NODE_ENV=test vitest run --poolOptions.threads.singleThread --passWithNoTests -t"
37
+ },
25
38
  "dependencies": {
26
- "@miroir-framework/jzod": "0.7.0",
27
- "zod": "^3.22.2",
39
+ "@miroir-framework/jzod": "0.8.1",
40
+ "zod": "^3.24.2",
28
41
  "zod-to-ts": "^1.2.0"
29
42
  },
30
43
  "devDependencies": {
44
+ "@babel/parser": "^7.26.10",
31
45
  "@babel/plugin-transform-modules-commonjs": "^7.20.11",
32
46
  "@babel/preset-env": "^7.22.5",
47
+ "@babel/types": "^7.26.10",
33
48
  "@jest/globals": "^29.3.1",
34
49
  "@rollup/plugin-commonjs": "^24.0.1",
35
50
  "@rollup/plugin-json": "^6.0.0",
36
51
  "@types/jest": "^29.2.4",
37
52
  "babel-jest": "^29.4.0",
53
+ "path": "^0.12.7",
38
54
  "rollup": "^3.10.1",
39
55
  "rollup-plugin-dts": "^5.1.1",
40
56
  "rollup-plugin-typescript2": "^0.34.1",
41
57
  "ts-jest": "^29.0.3",
42
58
  "tsconfig-paths": "^4.1.2",
43
- "typescript": "5.0.3",
59
+ "tsup": "^8.4.0",
60
+ "tsx": "^4.19.3",
61
+ "typescript": "5.8.2",
62
+ "url": "^0.11.4",
63
+ "vite-plugin-node-polyfills": "^0.23.0",
64
+ "vitest": "^3.0.8",
44
65
  "zod-to-json-schema": "^3.21.2"
45
66
  }
46
67
  }
package/dist/bundle.d.ts DELETED
@@ -1,303 +0,0 @@
1
- import ts from 'typescript';
2
- import { z } from 'zod';
3
-
4
- type JzodArray = {
5
- optional?: boolean | undefined;
6
- nullable?: boolean | undefined;
7
- extra?: {
8
- [x: string]: any;
9
- } | undefined;
10
- type: "array";
11
- definition: JzodElement;
12
- };
13
- type JzodAttribute = {
14
- optional?: boolean | undefined;
15
- nullable?: boolean | undefined;
16
- extra?: {
17
- [x: string]: any;
18
- } | undefined;
19
- type: "simpleType";
20
- coerce?: boolean | undefined;
21
- definition: JzodEnumAttributeTypes;
22
- };
23
- type JzodPlainAttribute = {
24
- optional?: boolean | undefined;
25
- nullable?: boolean | undefined;
26
- extra?: {
27
- [x: string]: any;
28
- } | undefined;
29
- type: JzodEnumAttributeTypes;
30
- coerce?: boolean | undefined;
31
- };
32
- type JzodAttributeDateValidations = {
33
- extra?: {
34
- [x: string]: any;
35
- } | undefined;
36
- type: "min" | "max";
37
- parameter?: any;
38
- };
39
- type JzodAttributeDateWithValidations = {
40
- optional?: boolean | undefined;
41
- nullable?: boolean | undefined;
42
- extra?: {
43
- [x: string]: any;
44
- } | undefined;
45
- type: "simpleType";
46
- definition: "date";
47
- coerce?: boolean | undefined;
48
- validations: JzodAttributeDateValidations[];
49
- };
50
- type JzodAttributePlainDateWithValidations = {
51
- optional?: boolean | undefined;
52
- nullable?: boolean | undefined;
53
- extra?: {
54
- [x: string]: any;
55
- } | undefined;
56
- type: "date";
57
- coerce?: boolean | undefined;
58
- validations: JzodAttributeDateValidations[];
59
- };
60
- type JzodAttributeNumberValidations = {
61
- extra?: {
62
- [x: string]: any;
63
- } | undefined;
64
- type: "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "multipleOf" | "finite" | "safe";
65
- parameter?: any;
66
- };
67
- type JzodAttributeNumberWithValidations = {
68
- optional?: boolean | undefined;
69
- nullable?: boolean | undefined;
70
- extra?: {
71
- [x: string]: any;
72
- } | undefined;
73
- type: "simpleType";
74
- definition: "number";
75
- coerce?: boolean | undefined;
76
- validations: JzodAttributeNumberValidations[];
77
- };
78
- type JzodAttributePlainNumberWithValidations = {
79
- optional?: boolean | undefined;
80
- nullable?: boolean | undefined;
81
- extra?: {
82
- [x: string]: any;
83
- } | undefined;
84
- type: "number";
85
- coerce?: boolean | undefined;
86
- validations: JzodAttributeNumberValidations[];
87
- };
88
- type JzodAttributeStringValidations = {
89
- extra?: {
90
- [x: string]: any;
91
- } | undefined;
92
- type: "max" | "min" | "length" | "email" | "url" | "emoji" | "uuid" | "cuid" | "cuid2" | "ulid" | "regex" | "includes" | "startsWith" | "endsWith" | "datetime" | "ip";
93
- parameter?: any;
94
- };
95
- type JzodAttributeStringWithValidations = {
96
- optional?: boolean | undefined;
97
- nullable?: boolean | undefined;
98
- extra?: {
99
- [x: string]: any;
100
- } | undefined;
101
- type: "simpleType";
102
- definition: "string";
103
- coerce?: boolean | undefined;
104
- validations: JzodAttributeStringValidations[];
105
- };
106
- type JzodAttributePlainStringWithValidations = {
107
- optional?: boolean | undefined;
108
- nullable?: boolean | undefined;
109
- extra?: {
110
- [x: string]: any;
111
- } | undefined;
112
- type: "string";
113
- coerce?: boolean | undefined;
114
- validations: JzodAttributeStringValidations[];
115
- };
116
- type JzodElement = JzodArray | JzodAttribute | JzodPlainAttribute | JzodAttributeDateWithValidations | JzodAttributePlainDateWithValidations | JzodAttributeNumberWithValidations | JzodAttributePlainNumberWithValidations | JzodAttributeStringWithValidations | JzodAttributePlainStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodObject | JzodPromise | JzodRecord | JzodReference | JzodSet | JzodTuple | JzodUnion;
117
- type JzodEnum = {
118
- optional?: boolean | undefined;
119
- nullable?: boolean | undefined;
120
- extra?: {
121
- [x: string]: any;
122
- } | undefined;
123
- type: "enum";
124
- definition: string[];
125
- };
126
- type JzodEnumAttributeTypes = "any" | "bigint" | "boolean" | "date" | "never" | "null" | "number" | "string" | "uuid" | "undefined" | "unknown" | "void";
127
- type JzodEnumElementTypes = "array" | "date" | "enum" | "function" | "lazy" | "literal" | "intersection" | "map" | "number" | "object" | "promise" | "record" | "schemaReference" | "set" | "simpleType" | "string" | "tuple" | "union";
128
- type JzodFunction = {
129
- optional?: boolean | undefined;
130
- nullable?: boolean | undefined;
131
- extra?: {
132
- [x: string]: any;
133
- } | undefined;
134
- type: "function";
135
- definition: {
136
- args: JzodElement[];
137
- returns?: JzodElement | undefined;
138
- };
139
- };
140
- type JzodLazy = {
141
- optional?: boolean | undefined;
142
- nullable?: boolean | undefined;
143
- extra?: {
144
- [x: string]: any;
145
- } | undefined;
146
- type: "lazy";
147
- definition: JzodFunction;
148
- };
149
- type JzodLiteral = {
150
- optional?: boolean | undefined;
151
- nullable?: boolean | undefined;
152
- extra?: {
153
- [x: string]: any;
154
- } | undefined;
155
- type: "literal";
156
- definition: string | number | bigint | boolean;
157
- };
158
- type JzodIntersection = {
159
- optional?: boolean | undefined;
160
- nullable?: boolean | undefined;
161
- extra?: {
162
- [x: string]: any;
163
- } | undefined;
164
- type: "intersection";
165
- definition: {
166
- left: JzodElement;
167
- right: JzodElement;
168
- };
169
- };
170
- type JzodMap = {
171
- optional?: boolean | undefined;
172
- nullable?: boolean | undefined;
173
- extra?: {
174
- [x: string]: any;
175
- } | undefined;
176
- type: "map";
177
- definition: [
178
- JzodElement,
179
- JzodElement
180
- ];
181
- };
182
- type JzodObject = {
183
- optional?: boolean | undefined;
184
- nullable?: boolean | undefined;
185
- extra?: {
186
- [x: string]: any;
187
- } | undefined;
188
- extend?: (JzodReference | JzodObject) | undefined;
189
- type: "object";
190
- nonStrict?: boolean | undefined;
191
- partial?: boolean | undefined;
192
- definition: {
193
- [x: string]: JzodElement;
194
- };
195
- };
196
- type JzodPromise = {
197
- optional?: boolean | undefined;
198
- nullable?: boolean | undefined;
199
- extra?: {
200
- [x: string]: any;
201
- } | undefined;
202
- type: "promise";
203
- definition: JzodElement;
204
- };
205
- type JzodRecord = {
206
- optional?: boolean | undefined;
207
- nullable?: boolean | undefined;
208
- extra?: {
209
- [x: string]: any;
210
- } | undefined;
211
- type: "record";
212
- definition: JzodElement;
213
- };
214
- type JzodReference = {
215
- optional?: boolean | undefined;
216
- nullable?: boolean | undefined;
217
- extra?: {
218
- [x: string]: any;
219
- } | undefined;
220
- type: "schemaReference";
221
- context?: {
222
- [x: string]: JzodElement;
223
- } | undefined;
224
- definition: {
225
- eager?: boolean | undefined;
226
- partial?: boolean | undefined;
227
- relativePath?: string | undefined;
228
- absolutePath?: string | undefined;
229
- };
230
- };
231
- type JzodSet = {
232
- optional?: boolean | undefined;
233
- nullable?: boolean | undefined;
234
- extra?: {
235
- [x: string]: any;
236
- } | undefined;
237
- type: "set";
238
- definition: JzodElement;
239
- };
240
- type JzodTuple = {
241
- optional?: boolean | undefined;
242
- nullable?: boolean | undefined;
243
- extra?: {
244
- [x: string]: any;
245
- } | undefined;
246
- type: "tuple";
247
- definition: JzodElement[];
248
- };
249
- type JzodUnion = {
250
- optional?: boolean | undefined;
251
- nullable?: boolean | undefined;
252
- extra?: {
253
- [x: string]: any;
254
- } | undefined;
255
- type: "union";
256
- discriminator?: string | undefined;
257
- definition: JzodElement[];
258
- };
259
- declare const jzodArray: z.ZodType<JzodArray>;
260
- declare const jzodAttribute: z.ZodType<JzodAttribute>;
261
- declare const jzodAttributeDateValidations: z.ZodType<JzodAttributeDateValidations>;
262
- declare const jzodAttributeDateWithValidations: z.ZodType<JzodAttributeDateWithValidations>;
263
- declare const jzodAttributeNumberValidations: z.ZodType<JzodAttributeNumberValidations>;
264
- declare const jzodAttributeNumberWithValidations: z.ZodType<JzodAttributeNumberWithValidations>;
265
- declare const jzodAttributeStringValidations: z.ZodType<JzodAttributeStringValidations>;
266
- declare const jzodAttributeStringWithValidations: z.ZodType<JzodAttributeStringWithValidations>;
267
- declare const jzodElement: z.ZodType<JzodElement>;
268
- declare const jzodEnum: z.ZodType<JzodEnum>;
269
- declare const jzodEnumAttributeTypes: z.ZodType<JzodEnumAttributeTypes>;
270
- declare const jzodEnumElementTypes: z.ZodType<JzodEnumElementTypes>;
271
- declare const jzodFunction: z.ZodType<JzodFunction>;
272
- declare const jzodLazy: z.ZodType<JzodLazy>;
273
- declare const jzodLiteral: z.ZodType<JzodLiteral>;
274
- declare const jzodIntersection: z.ZodType<JzodIntersection>;
275
- declare const jzodMap: z.ZodType<JzodMap>;
276
- declare const jzodObject: z.ZodType<JzodObject>;
277
- declare const jzodPromise: z.ZodType<JzodPromise>;
278
- declare const jzodRecord: z.ZodType<JzodRecord>;
279
- declare const jzodReference: z.ZodType<JzodReference>;
280
- declare const jzodSet: z.ZodType<JzodSet>;
281
- declare const jzodTuple: z.ZodType<JzodTuple>;
282
- declare const jzodUnion: z.ZodType<JzodUnion>;
283
-
284
- type TsTypeAliases = {
285
- [k: string]: ts.TypeAliasDeclaration;
286
- };
287
- interface TsTypeAliasesAndZodText {
288
- contextTsTypeAliases: {
289
- [k: string]: ts.TypeAliasDeclaration;
290
- };
291
- contextZodText: {
292
- [k: string]: string;
293
- };
294
- mainTsTypeAlias: ts.TypeAliasDeclaration;
295
- mainZodText: string;
296
- }
297
- declare function jzodToTsTypeAliasesAndZodText(element: JzodElement, typeName?: string): TsTypeAliasesAndZodText;
298
- declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string, typeAnotationForSchema?: string[]): string;
299
-
300
- declare function printTsTypeAlias(typeAlias: ts.TypeAliasDeclaration, exportPrefix?: boolean): string;
301
- declare function printTsTypeAliases(typeAliases: TsTypeAliases, exportPrefix?: boolean): string;
302
-
303
- export { JzodArray, JzodAttribute, JzodAttributeDateValidations, JzodAttributeDateWithValidations, JzodAttributeNumberValidations, JzodAttributeNumberWithValidations, JzodAttributePlainDateWithValidations, JzodAttributePlainNumberWithValidations, JzodAttributePlainStringWithValidations, JzodAttributeStringValidations, JzodAttributeStringWithValidations, JzodElement, JzodEnum, JzodEnumAttributeTypes, JzodEnumElementTypes, JzodFunction, JzodIntersection, JzodLazy, JzodLiteral, JzodMap, JzodObject, JzodPlainAttribute, JzodPromise, JzodRecord, JzodReference, JzodSet, JzodTuple, TsTypeAliasesAndZodText as JzodTypeAliasesAndZodText, JzodUnion, TsTypeAliases, jzodArray, jzodAttribute, jzodAttributeDateValidations, jzodAttributeDateWithValidations, jzodAttributeNumberValidations, jzodAttributeNumberWithValidations, jzodAttributeStringValidations, jzodAttributeStringWithValidations, jzodElement, jzodEnum, jzodEnumAttributeTypes, jzodEnumElementTypes, jzodFunction, jzodIntersection, jzodLazy, jzodLiteral, jzodMap, jzodObject, jzodPromise, jzodRecord, jzodReference, jzodSet, jzodToTsCode, jzodToTsTypeAliasesAndZodText, jzodTuple, jzodUnion, printTsTypeAlias, printTsTypeAliases };
package/dist/bundle.js DELETED
@@ -1,97 +0,0 @@
1
- import { printNode, withGetType, zodToTs, createTypeAlias } from 'zod-to-ts';
2
- import { jzodElementSchemaToZodSchemaAndDescription } from '@miroir-framework/jzod';
3
- import { z } from 'zod';
4
-
5
- function printTsTypeAlias(typeAlias, exportPrefix = true) {
6
- return (exportPrefix ? "export " : "") + printNode(typeAlias);
7
- }
8
- function printTsTypeAliases(typeAliases, exportPrefix = true) {
9
- const result = Object.entries(typeAliases).reduce((acc, curr) => {
10
- return `${acc}
11
- ${printTsTypeAlias(curr[1], exportPrefix)}`;
12
- }, "");
13
- return result;
14
- }
15
-
16
- function jzodToTsTypeAliasesAndZodText(element, typeName) {
17
- var _a, _b;
18
- const elementZodSchemaAndDescription = jzodElementSchemaToZodSchemaAndDescription(element, () => ({}), () => ({}), (innerReference, relativeReference) => withGetType(innerReference, (ts) => {
19
- const actualTypeName = relativeReference ? relativeReference.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
20
- return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(actualTypeName !== null && actualTypeName !== void 0 ? actualTypeName : "RELATIVEPATH_NOT_DEFINED"), undefined);
21
- }));
22
- const contextTsTypesString = Object.fromEntries(Object.entries((_a = elementZodSchemaAndDescription.contextZodSchema) !== null && _a !== void 0 ? _a : {}).map((curr) => {
23
- const actualTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
24
- const tsNode = zodToTs(curr[1], typeName).node;
25
- const typeAlias = createTypeAlias(tsNode, actualTypeName);
26
- return [curr[0], typeAlias];
27
- }));
28
- const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
29
- const tsTypeStringTypeAlias = createTypeAlias(tsTypeStringNode, typeName !== null && typeName !== void 0 ? typeName : "");
30
- return {
31
- contextTsTypeAliases: contextTsTypesString,
32
- contextZodText: (_b = elementZodSchemaAndDescription.contextZodText) !== null && _b !== void 0 ? _b : {},
33
- mainZodText: elementZodSchemaAndDescription.zodText,
34
- mainTsTypeAlias: tsTypeStringTypeAlias,
35
- };
36
- }
37
- function jzodToTsCode(jzodElement, exportPrefix = true, typeName, typeAnotationForSchema = []) {
38
- const schemaName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c) : "";
39
- const actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
40
- const header = `import { ZodType, ZodTypeAny, z } from "zod";`;
41
- const typeAliasesAndZodText = jzodToTsTypeAliasesAndZodText(jzodElement, actualTypeName);
42
- const bodyJsCode = typeAnotationForSchema.includes(schemaName !== null && schemaName !== void 0 ? schemaName : "")
43
- ? `export const ${schemaName}: z.ZodType<${actualTypeName}> = ${typeAliasesAndZodText.mainZodText};`
44
- : `export const ${schemaName} = ${typeAliasesAndZodText.mainZodText};`;
45
- const contextTsTypesString = printTsTypeAliases(typeAliasesAndZodText.contextTsTypeAliases, exportPrefix);
46
- const contextJsCode = typeAliasesAndZodText.contextZodText
47
- ? Object.entries(typeAliasesAndZodText.contextZodText).reduce((acc, curr) => {
48
- const contextTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
49
- return typeAnotationForSchema.includes(curr[0]) ?
50
- `${acc}
51
- export const ${curr[0]}: z.ZodType<${contextTypeName}> = ${curr[1]};`
52
- :
53
- `${acc}
54
- export const ${curr[0]} = ${curr[1]};`;
55
- }, "")
56
- : "";
57
- const tsTypesString = (exportPrefix ? "export " : "") + printNode(typeAliasesAndZodText.mainTsTypeAlias);
58
- return `${header}
59
- ${contextTsTypesString}
60
- ${tsTypesString}
61
- ${contextJsCode}
62
- ${bodyJsCode}
63
- `;
64
- }
65
-
66
- z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict();
67
- 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();
68
- 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();
69
- const jzodPlainAttribute = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.lazy(() => jzodEnumAttributeTypes), coerce: z.boolean().optional() }).strict();
70
- const jzodAttributeDateValidations = z.object({ extra: z.record(z.string(), z.any()).optional(), type: z.enum(["min", "max"]), parameter: z.any() }).strict();
71
- 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();
72
- const jzodAttributePlainDateWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("date"), coerce: z.boolean().optional(), validations: z.array(z.lazy(() => jzodAttributeDateValidations)) }).strict();
73
- 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();
74
- 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();
75
- const jzodAttributePlainNumberWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("number"), coerce: z.boolean().optional(), validations: z.array(z.lazy(() => jzodAttributeNumberValidations)) }).strict();
76
- 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();
77
- 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();
78
- const jzodAttributePlainStringWithValidations = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("string"), coerce: z.boolean().optional(), validations: z.array(z.lazy(() => jzodAttributeStringValidations)) }).strict();
79
- const jzodElement = z.union([z.lazy(() => jzodArray), z.lazy(() => jzodAttribute), z.lazy(() => jzodPlainAttribute), z.lazy(() => jzodAttributeDateWithValidations), z.lazy(() => jzodAttributePlainDateWithValidations), z.lazy(() => jzodAttributeNumberWithValidations), z.lazy(() => jzodAttributePlainNumberWithValidations), z.lazy(() => jzodAttributeStringWithValidations), z.lazy(() => jzodAttributePlainStringWithValidations), 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)]);
80
- 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();
81
- const jzodEnumAttributeTypes = z.enum(["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]);
82
- const jzodEnumElementTypes = z.enum(["array", "date", "enum", "function", "lazy", "literal", "intersection", "map", "number", "object", "promise", "record", "schemaReference", "set", "simpleType", "string", "tuple", "union"]);
83
- 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();
84
- 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();
85
- 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();
86
- 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();
87
- 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();
88
- 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();
89
- 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();
90
- 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();
91
- 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(), partial: z.boolean().optional(), relativePath: z.string().optional(), absolutePath: z.string().optional() }).strict() }).strict();
92
- const jzodSet = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("set"), definition: z.lazy(() => jzodElement) }).strict();
93
- const jzodTuple = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("tuple"), definition: z.array(z.lazy(() => jzodElement)) }).strict();
94
- const jzodUnion = z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict().extend({ type: z.literal("union"), discriminator: z.string().optional(), definition: z.array(z.lazy(() => jzodElement)) }).strict();
95
- z.lazy(() => jzodElement);
96
-
97
- export { jzodArray, jzodAttribute, jzodAttributeDateValidations, jzodAttributeDateWithValidations, jzodAttributeNumberValidations, jzodAttributeNumberWithValidations, jzodAttributeStringValidations, jzodAttributeStringWithValidations, jzodElement, jzodEnum, jzodEnumAttributeTypes, jzodEnumElementTypes, jzodFunction, jzodIntersection, jzodLazy, jzodLiteral, jzodMap, jzodObject, jzodPromise, jzodRecord, jzodReference, jzodSet, jzodToTsCode, jzodToTsTypeAliasesAndZodText, jzodTuple, jzodUnion, printTsTypeAlias, printTsTypeAliases };