@miroir-framework/jzod-ts 0.7.0 → 0.8.2

package/README.md

@@ -1,3 +1,3 @@
-# Jzod-ts
-
+# Jzod-ts
+
 see [Jzod](https://github.com/miroir-framework/jzod) for usage information.

package/dist/index.cjs

@@ -0,0 +1,226 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  jzodArray: () => jzodArray,
+  jzodAttributeDateValidations: () => jzodAttributeDateValidations,
+  jzodAttributeNumberValidations: () => jzodAttributeNumberValidations,
+  jzodAttributePlainDateWithValidations: () => jzodAttributePlainDateWithValidations,
+  jzodAttributePlainNumberWithValidations: () => jzodAttributePlainNumberWithValidations,
+  jzodAttributePlainStringWithValidations: () => jzodAttributePlainStringWithValidations,
+  jzodAttributeStringValidations: () => jzodAttributeStringValidations,
+  jzodElement: () => jzodElement,
+  jzodEnum: () => jzodEnum,
+  jzodEnumAttributeTypes: () => jzodEnumAttributeTypes,
+  jzodEnumElementTypes: () => jzodEnumElementTypes,
+  jzodFunction: () => jzodFunction,
+  jzodIntersection: () => jzodIntersection,
+  jzodLazy: () => jzodLazy,
+  jzodLiteral: () => jzodLiteral,
+  jzodMap: () => jzodMap,
+  jzodObject: () => jzodObject,
+  jzodPlainAttribute: () => jzodPlainAttribute,
+  jzodPromise: () => jzodPromise,
+  jzodRecord: () => jzodRecord,
+  jzodReference: () => jzodReference,
+  jzodSet: () => jzodSet,
+  jzodToTsCode: () => jzodToTsCode,
+  jzodToZodTextAndTsTypeAliases: () => jzodToZodTextAndTsTypeAliases,
+  jzodToZodTextAndZodSchemaForTsGeneration: () => jzodToZodTextAndZodSchemaForTsGeneration,
+  jzodTuple: () => jzodTuple,
+  jzodUnion: () => jzodUnion
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/JzodToTs.ts
+var import_zod_to_ts = require("zod-to-ts");
+var import_jzod = require("@miroir-framework/jzod");
+function jzodToZodTextAndZodSchemaForTsGeneration(element, context = {}) {
+  const contextFunction = () => context;
+  const elementZodSchemaAndDescription = (0, import_jzod.jzodToZodTextAndZodSchema)(
+    element,
+    contextFunction,
+    contextFunction,
+    { typeScriptGeneration: true }
+    // typeScriptGeneration
+  );
+  return elementZodSchemaAndDescription;
+}
+function jzodToZodTextAndTsTypeText(element, context = {}, typeName) {
+  const elementZodSchemaAndDescription = jzodToZodTextAndZodSchemaForTsGeneration(
+    element,
+    context
+  );
+  const contextTsTypesStringObject = Object.fromEntries(
+    Object.entries(elementZodSchemaAndDescription.contextZodSchema ?? {}).map((curr) => {
+      const actualTypeName2 = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
+      const tsNode = (0, import_zod_to_ts.zodToTs)(curr[1], typeName).node;
+      const typeAlias = (0, import_zod_to_ts.createTypeAlias)(tsNode, actualTypeName2);
+      const tsTypeString2 = (0, import_zod_to_ts.printNode)(typeAlias);
+      return [curr[0], tsTypeString2];
+    })
+  );
+  const actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
+  const tsTypeStringNode = (0, import_zod_to_ts.zodToTs)(elementZodSchemaAndDescription.zodSchema, typeName).node;
+  const tsTypeAlias = (0, import_zod_to_ts.createTypeAlias)(tsTypeStringNode, actualTypeName);
+  const tsTypeString = (0, import_zod_to_ts.printNode)(tsTypeAlias);
+  return {
+    contextTsTypeText: contextTsTypesStringObject,
+    contextZodText: elementZodSchemaAndDescription.contextZodText ?? {},
+    zodText: elementZodSchemaAndDescription.zodText,
+    tsTypeText: tsTypeString
+  };
+}
+function jzodToZodTextAndTsTypeAliases(element, context = {}, typeName) {
+  const jzodToTsTypeAliasesAndZodTextStartTime = Date.now();
+  console.log("@@@@@@@@@@@@@@@@@ jzodToZodTextAndTsTypeAliases start!", Object.keys(context).length);
+  console.log("jzodToZodTextAndTsTypeAliases context:", JSON.stringify(Object.keys(context)));
+  const elementZodSchemaAndDescription = jzodToZodTextAndZodSchemaForTsGeneration(
+    element,
+    context
+  );
+  console.log(
+    "jzodToZodTextAndTsTypeAliases jzodToZodTextAndZodSchemaForTsGeneration duration",
+    Date.now() - jzodToTsTypeAliasesAndZodTextStartTime,
+    "ms"
+  );
+  const contextTsTypesStringStartTime = Date.now();
+  const contextTsTypesString = Object.fromEntries(
+    Object.entries(elementZodSchemaAndDescription.contextZodSchema ?? {}).map((curr) => {
+      console.log("jzodToZodTextAndTsTypeAliases converting elementZodSchemaAndDescription entry", curr[0]);
+      const actualTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
+      const tsNode = (0, import_zod_to_ts.zodToTs)(curr[1], typeName).node;
+      const typeAlias = (0, import_zod_to_ts.createTypeAlias)(tsNode, actualTypeName);
+      return [curr[0], typeAlias];
+    })
+  );
+  console.log(
+    "jzodToZodTextAndTsTypeAliases contextTsTypesString duration",
+    Date.now() - contextTsTypesStringStartTime,
+    "ms"
+  );
+  const tsTypeStringNodeStartTime = Date.now();
+  const tsTypeStringNode = (0, import_zod_to_ts.zodToTs)(elementZodSchemaAndDescription.zodSchema, typeName).node;
+  const tsTypeStringTypeAlias = (0, import_zod_to_ts.createTypeAlias)(tsTypeStringNode, typeName ?? "");
+  console.log(
+    "jzodToZodTextAndTsTypeAliases tsTypeStringNode duration",
+    Date.now() - tsTypeStringNodeStartTime,
+    "ms"
+  );
+  console.log("@@@@@@@@@@@@@@@@@ jzodToZodTextAndTsTypeAliases end in:", Date.now() - jzodToTsTypeAliasesAndZodTextStartTime, "ms");
+  return {
+    contextTsTypeAliases: contextTsTypesString,
+    contextZodText: elementZodSchemaAndDescription.contextZodText ?? {},
+    zodText: elementZodSchemaAndDescription.zodText,
+    mainTsTypeAlias: tsTypeStringTypeAlias
+  };
+}
+function jzodToTsCode(typeName, jzodElement2, context = {}, exportPrefix = true, headerForZodImports = true, typeAnotationForSchema = [], extendedTsTypesText = "") {
+  console.log(
+    "################################### jzodToTsCode typeName",
+    typeName,
+    "jzodElement",
+    jzodElement2 && jzodElement2.context ? JSON.stringify(Object.keys(jzodElement2.context), null, 2) : void 0
+  );
+  const schemaName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c) : "";
+  const actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
+  const header = typeof headerForZodImports == "string" ? headerForZodImports : headerForZodImports ? `import { ZodType, ZodTypeAny, z } from "zod";` : "";
+  const tsTypeStringsAndZodText = jzodToZodTextAndTsTypeText(jzodElement2, context, actualTypeName);
+  const contextTsTypesString = tsTypeStringsAndZodText.contextTsTypeText ? Object.entries(tsTypeStringsAndZodText.contextTsTypeText).reduce((acc, curr) => {
+    return exportPrefix ? `${acc}
+export ${curr[1]}` : `${acc}
+${curr[1]}`;
+  }, "") : "";
+  const contextJsCode = tsTypeStringsAndZodText.contextZodText ? Object.entries(tsTypeStringsAndZodText.contextZodText).reduce((acc, curr) => {
+    const contextTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
+    return typeAnotationForSchema.includes(curr[0]) ? `${acc}
+export const ${curr[0]}: z.ZodType<${contextTypeName}> = ${curr[1]};` : `${acc}
+export const ${curr[0]} = ${curr[1]};`;
+  }, "") : "";
+  const bodyTsCode = (exportPrefix ? "export " : "") + tsTypeStringsAndZodText.tsTypeText;
+  const bodyJsCode = typeAnotationForSchema.includes(schemaName ?? "") ? `export const ${schemaName}: z.ZodType<${actualTypeName}> = ${tsTypeStringsAndZodText.zodText};` : `export const ${schemaName} = ${tsTypeStringsAndZodText.zodText};`;
+  return `${header}
+${extendedTsTypesText ?? ""}
+${contextTsTypesString}
+${bodyTsCode}
+${contextJsCode}
+${bodyJsCode}
+`;
+}
+
+// src/generated_jzodBootstrapElementSchema.ts
+var import_zod = require("zod");
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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)]);
+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();
+var jzodEnumAttributeTypes = import_zod.z.enum(["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]);
+var jzodEnumElementTypes = import_zod.z.enum(["array", "date", "enum", "function", "lazy", "literal", "intersection", "map", "number", "object", "promise", "record", "schemaReference", "set", "string", "tuple", "union"]);
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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"), optInDiscriminator: import_zod.z.boolean().optional(), 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();
+var jzodBootstrapElementSchema = import_zod.z.lazy(() => jzodElement);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.d.ts

@@ -0,0 +1,405 @@
+import ts from 'typescript';
+import { ZodTextAndZodSchemaRecord, ZodTextAndZodSchema } from '@miroir-framework/jzod';
+import { z } from 'zod';
+
+interface TsTypeAliasesAndZodText {
+    contextTsTypeAliases: {
+        [k: string]: ts.TypeAliasDeclaration;
+    };
+    contextZodText: {
+        [k: string]: string;
+    };
+    mainTsTypeAlias: ts.TypeAliasDeclaration;
+    zodText: string;
+}
+declare function jzodToZodTextAndZodSchemaForTsGeneration(element: any, // to avoid circularity on JzodElement
+context?: ZodTextAndZodSchemaRecord): ZodTextAndZodSchema;
+declare function jzodToZodTextAndTsTypeAliases(element: any, // to avoid circularity on JzodElement
+context?: ZodTextAndZodSchemaRecord, typeName?: string): TsTypeAliasesAndZodText;
+/**
+ *
+ * @param typeName the name given to the resulting TS type definition
+ * @param jzodElement the JzodElement to convert to TS code
+ * @param context the context of the JzodElement, to be used for recursive types, for example.
+ * @param exportPrefix true if the resulting TS code should be prefixed with "export "
+ * @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.
+ * @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.
+ * @returns a string containing the resulting TS code
+ */
+declare function jzodToTsCode(typeName: string, jzodElement: any, // to avoid circulatity on JzodElement
+context?: ZodTextAndZodSchemaRecord, exportPrefix?: boolean, headerForZodImports?: boolean | string, typeAnotationForSchema?: string[], extendedTsTypesText?: string): string;
+
+type JzodArray = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "array";
+    definition: JzodElement;
+};
+type JzodPlainAttribute = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: JzodEnumAttributeTypes;
+    coerce?: boolean | undefined;
+};
+type JzodAttributeDateValidations = {
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "min" | "max";
+    parameter?: any;
+};
+type JzodAttributePlainDateWithValidations = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "date";
+    coerce?: boolean | undefined;
+    validations: JzodAttributeDateValidations[];
+};
+type JzodAttributeNumberValidations = {
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "multipleOf" | "finite" | "safe";
+    parameter?: any;
+};
+type JzodAttributePlainNumberWithValidations = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "number";
+    coerce?: boolean | undefined;
+    validations: JzodAttributeNumberValidations[];
+};
+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;
+};
+type JzodAttributePlainStringWithValidations = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "string";
+    coerce?: boolean | undefined;
+    validations: JzodAttributeStringValidations[];
+};
+type JzodElement = JzodArray | JzodPlainAttribute | JzodAttributePlainDateWithValidations | JzodAttributePlainNumberWithValidations | JzodAttributePlainStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodObject | JzodPromise | JzodRecord | JzodReference | JzodSet | JzodTuple | JzodUnion;
+type JzodEnum = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "enum";
+    definition: string[];
+};
+type JzodEnumAttributeTypes = "any" | "bigint" | "boolean" | "date" | "never" | "null" | "number" | "string" | "uuid" | "undefined" | "unknown" | "void";
+type JzodEnumElementTypes = "array" | "date" | "enum" | "function" | "lazy" | "literal" | "intersection" | "map" | "number" | "object" | "promise" | "record" | "schemaReference" | "set" | "string" | "tuple" | "union";
+type JzodFunction = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "function";
+    definition: {
+        args: JzodElement[];
+        returns?: JzodElement | undefined;
+    };
+};
+type JzodLazy = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "lazy";
+    definition: JzodReference;
+};
+type JzodLiteral = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "literal";
+    definition: string | number | bigint | boolean;
+};
+type JzodIntersection = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "intersection";
+    definition: {
+        left: JzodElement;
+        right: JzodElement;
+    };
+};
+type JzodMap = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "map";
+    definition: [
+        JzodElement,
+        JzodElement
+    ];
+};
+type JzodObject = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    extend?: (((JzodReference | JzodObject) | undefined) | ((JzodReference | JzodObject) | undefined)[]) | undefined;
+    type: "object";
+    nonStrict?: boolean | undefined;
+    partial?: boolean | undefined;
+    carryOn?: (JzodObject | JzodUnion) | undefined;
+    definition: {
+        [x: string]: JzodElement;
+    };
+};
+type JzodPromise = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "promise";
+    definition: JzodElement;
+};
+type JzodRecord = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "record";
+    definition: JzodElement;
+};
+type JzodReference = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "schemaReference";
+    context?: {
+        [x: string]: JzodElement;
+    } | undefined;
+    carryOn?: (JzodObject | JzodUnion) | undefined;
+    definition: {
+        eager?: boolean | undefined;
+        partial?: boolean | undefined;
+        relativePath?: string | undefined;
+        absolutePath?: string | undefined;
+    };
+};
+type JzodSet = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "set";
+    definition: JzodElement;
+};
+type JzodTuple = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "tuple";
+    definition: JzodElement[];
+};
+type JzodUnion = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: any | undefined;
+    tag?: {
+        value?: any;
+        schema?: {
+            optional?: boolean | undefined;
+            metaSchema?: JzodElement | undefined;
+            valueSchema?: JzodElement | undefined;
+        } | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    type: "union";
+    optInDiscriminator?: boolean | undefined;
+    discriminator?: ({
+        discriminatorType: "string";
+        value: string;
+    } | {
+        discriminatorType: "array";
+        value: string[];
+    }) | undefined;
+    carryOn?: (JzodObject | JzodUnion) | undefined;
+    definition: JzodElement[];
+};
+declare const jzodArray: z.ZodType<JzodArray>;
+declare const jzodPlainAttribute: z.ZodType<JzodPlainAttribute>;
+declare const jzodAttributeDateValidations: z.ZodType<JzodAttributeDateValidations>;
+declare const jzodAttributePlainDateWithValidations: z.ZodType<JzodAttributePlainDateWithValidations>;
+declare const jzodAttributeNumberValidations: z.ZodType<JzodAttributeNumberValidations>;
+declare const jzodAttributePlainNumberWithValidations: z.ZodType<JzodAttributePlainNumberWithValidations>;
+declare const jzodAttributeStringValidations: z.ZodType<JzodAttributeStringValidations>;
+declare const jzodAttributePlainStringWithValidations: z.ZodType<JzodAttributePlainStringWithValidations>;
+declare const jzodElement: z.ZodType<JzodElement>;
+declare const jzodEnum: z.ZodType<JzodEnum>;
+declare const jzodEnumAttributeTypes: z.ZodType<JzodEnumAttributeTypes>;
+declare const jzodEnumElementTypes: z.ZodType<JzodEnumElementTypes>;
+declare const jzodFunction: z.ZodType<JzodFunction>;
+declare const jzodLazy: z.ZodType<JzodLazy>;
+declare const jzodLiteral: z.ZodType<JzodLiteral>;
+declare const jzodIntersection: z.ZodType<JzodIntersection>;
+declare const jzodMap: z.ZodType<JzodMap>;
+declare const jzodObject: z.ZodType<JzodObject>;
+declare const jzodPromise: z.ZodType<JzodPromise>;
+declare const jzodRecord: z.ZodType<JzodRecord>;
+declare const jzodReference: z.ZodType<JzodReference>;
+declare const jzodSet: z.ZodType<JzodSet>;
+declare const jzodTuple: z.ZodType<JzodTuple>;
+declare const jzodUnion: z.ZodType<JzodUnion>;
+
+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 };