@miroir-framework/jzod-ts 0.6.2 → 0.6.3

package/jest.config.js

@@ -1,63 +0,0 @@
-// import { pathsToModuleNameMapper } from 'ts-jest';
-// import compilerOptions from './tsconfig'
-
-const esModules = ['uuid'].join('|');
-
-export default (path, options) =>({
-  "verbose": true,
-  "rootDir": ".",
-  "moduleDirectories": [
-    "node_modules",
-  ],
-  transformIgnorePatterns: [`<rootDir>\/(?!(/node_modules/(?!${esModules})))\/`],
-  // modulePaths: ["./packages/miroir-standalone-app/src/"], // <-- This will be set to 'baseUrl' value
-  modulePaths: ["./src/"], // <-- This will be set to 'baseUrl' value
-  // modulePaths: [compilerOptions.baseUrl], // <-- This will be set to 'baseUrl' value
-  moduleNameMapper: 
-    // Object.assign(
-      {
-      // "^miroir-fwk(.*)$": "<rootDir>/src/$1",
-      // "^(.*)$": "$1",
-      '\\.(css|scss|sass)$': 'identity-obj-proxy',
-      }
-    // pathsToModuleNameMapper(compilerOptions.paths /*, { prefix: '<rootDir>/' } */)
-    // )
-  ,
-  // resolver:options.defaultResolver(path, {...options}),
-  testEnvironment: "node",
-  moduleFileExtensions:[
-    "ts", "tsx", "js", "mjs", "cjs", "jsx", "json", "node"
-  ],
-  // preset:'ts-jest/presets/default-esm',
-  "transform": {
-    "^.+\\.tsx?$": [
-      "ts-jest",
-      {
-        // useESM:true,
-        // tsconfig: "../../tsconfig.json"
-        tsconfig: 
-        {
-          resolveJsonModule: true,
-          esModuleInterop: true,
-          allowSyntheticDefaultImports:true,
-          allowJs: true,
-          moduleResolution: "node",
-          // module: "ESNext",
-          // target: "ES2017",
-                // rootDir: "./src/",
-          traceResolution: true,
-          module:"commonjs"
-        },
-      }
-    ],
-    "^.+\\.js?$": ["babel-jest"],
-  },
-  // moduleNameMapper: {
-  //   "^miroir-fwk\/(.+)$": "<rootDir>/src/$1",
-  //   '\\.(css|scss|sass)$': 'identity-obj-proxy',
-  // },
-  "testPathIgnorePatterns": [
-    "./node_modules/",
-    "./.cache/"
-  ],
-})

package/rollup.config.js

@@ -1,36 +0,0 @@
-import typescript from 'rollup-plugin-typescript2';
-import dts from 'rollup-plugin-dts';
-
-export default [
-  {
-    input: ["src/index.ts"],
-    external: [
-      'zod',
-      'zod-to-ts',
-      '@miroir-framework/jzod',
-    ],
-    output: [
-        {
-            file: `dist/bundle.js`,
-            entryFileNames: "[name].js",
-            format: "es",
-            exports: "named"
-        }
-    ],
-    plugins: [
-      typescript(),
-    ],
-  },
-  {
-    input: ["dist/src/index.d.ts"],
-    output: [
-        {
-          file: `dist/bundle.d.ts`,
-          format: 'es',
-        }
-    ],
-    plugins: [
-      dts(),
-    ],
-  }
-];

package/src/JzodToTs.ts

@@ -1,118 +0,0 @@
-import ts from "typescript";
-import { ZodTypeAny } from "zod";
-import { GetType, createTypeAlias, printNode, withGetType, zodToTs } from "zod-to-ts";
-
-import { jzodElementSchemaToZodSchemaAndDescription } from "@miroir-framework/jzod";
-
-import { JzodElement } from "./generated_jzodBootstrapElementSchema";
-
-import { printTsTypeAliases } from "./tools";
-// ################################################################################################
-export type TsTypeAliases =  {
-  [k: string]: ts.TypeAliasDeclaration;
-}
-
-// ################################################################################################
-export interface TsTypeAliasesAndZodText {
-  contextTsTypeAliases: { [k: string]: ts.TypeAliasDeclaration },
-  contextZodText: { [k: string]: string },
-  mainTsTypeAlias: ts.TypeAliasDeclaration,
-  mainZodText: string 
-}
-
-// ################################################################################################
-export function jzodToTsTypeAliasesAndZodText(
-  element: JzodElement,
-  typeName?: string,
-): TsTypeAliasesAndZodText
-{
-  const elementZodSchemaAndDescription = jzodElementSchemaToZodSchemaAndDescription(
-    element as any,
-    () => ({}),
-    () => ({}),
-    (innerReference: ZodTypeAny & GetType, relativeReference: string | undefined) =>
-      withGetType(innerReference, (ts:any) => {
-        const actualTypeName = relativeReference?relativeReference.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
-        return ts.factory.createTypeReferenceNode(
-          ts.factory.createIdentifier(actualTypeName ?? "RELATIVEPATH_NOT_DEFINED"),
-          undefined
-        );
-      }
-    ) 
-  );
-
-  const contextTsTypesString = Object.fromEntries(
-    Object.entries(elementZodSchemaAndDescription.contextZodSchema ?? {}).map((curr) => {
-      const actualTypeName = curr[0]?curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
-      const tsNode = zodToTs(curr[1], typeName).node;
-      const typeAlias = createTypeAlias(tsNode, actualTypeName);
-      return [curr[0], typeAlias];
-    })
-  );
-
-  const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
-  const tsTypeStringTypeAlias = createTypeAlias(tsTypeStringNode, typeName??"");
-
-  return {
-    contextTsTypeAliases: contextTsTypesString,
-    contextZodText: elementZodSchemaAndDescription.contextZodText??{},
-    mainZodText: elementZodSchemaAndDescription.zodText,
-    mainTsTypeAlias: tsTypeStringTypeAlias,
-  };
-}
-
-
-// ################################################################################################
-export function jzodToTsCode (
-  jzodElement: JzodElement,
-  exportPrefix: boolean = true,
-  typeName?: string,
-  // typeSchema: boolean = false,
-  typeAnotationForSchema: string[] = [],
-): string {
-  // console.log(
-  //   "################################### jzodToTsCode ",
-  //   "jzodElement",
-  //   JSON.stringify(jzodElement, null, 2)
-  // );
-  
-  const schemaName = typeName?typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c):"";
-  const actualTypeName = typeName?typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
-
-  // console.log("jzodToTsCode typeAnotationForSchema", typeAnotationForSchema);
-
-  const header = `import { ZodType, ZodTypeAny, z } from "zod";`;
-
-  const typeAliasesAndZodText = jzodToTsTypeAliasesAndZodText(jzodElement, actualTypeName);
-
-  const bodyJsCode = typeAnotationForSchema.includes(schemaName??"")
-    ? `export const ${schemaName}: z.ZodType<${actualTypeName}> = ${typeAliasesAndZodText.mainZodText};`
-    : `export const ${schemaName} = ${typeAliasesAndZodText.mainZodText};`;
-
-  const contextTsTypesString = printTsTypeAliases(typeAliasesAndZodText.contextTsTypeAliases, exportPrefix);
-  // console.log("jzodToTsCode zod text for converted jzodElement",typeAliasesAndZodText.contextZodText);
-
-  const contextJsCode = typeAliasesAndZodText.contextZodText
-    ? Object.entries(typeAliasesAndZodText.contextZodText).reduce((acc, curr) => {
-      const contextTypeName = curr[0]?curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c):"";
-      return typeAnotationForSchema.includes(curr[0])?
-        `${acc}
-export const ${curr[0]}: z.ZodType<${contextTypeName}> = ${curr[1]};`
-      :
-        `${acc}
-export const ${curr[0]} = ${curr[1]};`
-      ;
-    }, "")
-    : ""
-  ;
-
-  const tsTypesString = (exportPrefix?"export ":"") + printNode(typeAliasesAndZodText.mainTsTypeAlias);
-  // console.log("getTsCodeCorrespondingToZodSchemaAndDescription tsTypeString",tsTypesString);
-
-  return `${header}
-${contextTsTypesString}
-${tsTypesString}
-${contextJsCode}
-${bodyJsCode}
-`;
-}

package/src/generated_jzodBootstrapElementSchema.ts

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

package/src/index.ts

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

package/src/preBuild.ts

@@ -1,59 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { jzodBootstrapElementSchema } from '@miroir-framework/jzod';
-
-import { jzodToTsCode } from './JzodToTs.js';
-
-export function generateZodSchemaFileFromJzodSchema(
-  jzodElement: any, //JzodElement,
-  targetFileName: string,
-  jzodSchemaVariableName:string,
-) {
-  // console.log("generateZodSchemaFileFromJzodSchema called!");
- 
-  const newFileContentsNotFormated = jzodToTsCode(jzodElement, true, jzodSchemaVariableName,Object.keys(jzodElement.context))
-  // const newFileContents = `import { JzodObject, jzodObject } from "@miroir-framework/jzod-ts";
-  const newFileContents = `${newFileContentsNotFormated}
-`;
-
-  if (targetFileName && existsSync(targetFileName)) {
-    const oldFileContents = readFileSync(targetFileName).toString()
-    if (newFileContents != oldFileContents)  {
-      // console.log("generateZodSchemaFileFromJzodSchema newFileContents",newFileContents);
-      writeFileSync(targetFileName,newFileContents);
-    } else {
-      console.log("generateZodSchemaFileFromJzodSchema entityDefinitionReport old contents equal new contents, no file generation needed.");
-    }
-  } else {
-    writeFileSync(targetFileName,newFileContents);
-  }
-}
-
-// ################################################################################################
-const jzodSchemaConversion
-: {
-  jzodElement: any,
-  targetFileName: string,
-  jzodSchemaVariableName:string,
-}[]
-= [
-  {
-    jzodElement: jzodBootstrapElementSchema,
-    targetFileName: "./src/generated_jzodBootstrapElementSchema.ts",
-    jzodSchemaVariableName: "jzodBootstrapElementSchema",
-  },
-];
-
-console.info("Prebuild!");
-
-try {
-  for (const schema of jzodSchemaConversion) {
-    generateZodSchemaFileFromJzodSchema(schema.jzodElement,schema.targetFileName,schema.jzodSchemaVariableName)
-    console.info("GENERATING",jzodBootstrapElementSchema);
-    console.info("GENERATED",schema.targetFileName);
-  }
-
-} catch (error) {
-  console.error("could not generate TS files from Jzod schemas", error);
-}
-
-console.info("Prebuild end!");

package/src/tools.ts

@@ -1,25 +0,0 @@
-import { printNode } from "zod-to-ts";
-import ts from "typescript";
-
-import { TsTypeAliases } from "./JzodToTs";
-
-// ################################################################################################
-export function printTsTypeAlias(
-  typeAlias: ts.TypeAliasDeclaration,
-  exportPrefix: boolean = true,
-): string {
-  return (exportPrefix?"export ":"")+printNode(typeAlias)
-}
-
-// ################################################################################################
-export function printTsTypeAliases(
-  typeAliases: TsTypeAliases,
-  exportPrefix: boolean = true,
-): string {
-  const result = Object.entries(typeAliases).reduce((acc, curr) => {
-    // console.log("printTypeAliases ", JSON.stringify(curr));
-    return `${acc}
-${printTsTypeAlias(curr[1],exportPrefix)}`;
-  }, "");
-  return result;
-}