@miroir-framework/jzod-ts 0.5.0

package/README.md

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

package/babel.config.cjs

@@ -0,0 +1,13 @@
+module.exports = api => {
+  const isTest = api.env('test');
+  // You can use isTest to determine what presets and plugins to use.
+  console.log('########################################################')
+  return {
+  presets: [['@babel/preset-env', {targets: {node: 'current'}}]],
+  "env": {
+      "test": {
+        "plugins": ["@babel/plugin-transform-modules-commonjs"]
+      }
+    }
+  };
+}

package/dist/bundle.d.ts

@@ -0,0 +1,419 @@
+import ts from 'typescript';
+import { z, ZodType } from 'zod';
+
+declare const jzodRootSchema: z.ZodObject<{
+    optional: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    optional?: boolean | undefined;
+}, {
+    optional?: boolean | undefined;
+}>;
+type JzodRoot = z.infer<typeof jzodRootSchema>;
+declare const jzodEnumAttributeTypesSchema: z.ZodEnum<["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]>;
+type JzodEnumTypes = z.infer<typeof jzodEnumAttributeTypesSchema>;
+declare const jzodEnumElementTypesSchema: z.ZodEnum<["array", "enum", "function", "lazy", "literal", "intersection", "map", "object", "promise", "record", "schemaReference", "set", "simpleType", "tuple", "union"]>;
+type JzodEnumElementTypes = z.infer<typeof jzodEnumElementTypesSchema>;
+interface JzodArray extends JzodRoot {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'array';
+    definition: JzodElement;
+}
+declare const jzodArraySchema: z.ZodType<JzodArray>;
+declare const jzodAttributeDateValidationsSchema: z.ZodObject<{
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    type: z.ZodEnum<["min", "max"]>;
+    parameter: z.ZodAny;
+}, "strict", z.ZodTypeAny, {
+    type: "min" | "max";
+    extra?: Record<string, any> | undefined;
+    parameter?: any;
+}, {
+    type: "min" | "max";
+    extra?: Record<string, any> | undefined;
+    parameter?: any;
+}>;
+type JzodAttributeDateValidations = z.infer<typeof jzodAttributeDateValidationsSchema>;
+declare const jzodAttributeNumberValidationsSchema: z.ZodObject<{
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    type: z.ZodEnum<["gt", "gte", "lt", "lte", "int", "positive", "nonpositive", "negative", "nonnegative", "multipleOf", "finite", "safe"]>;
+    parameter: z.ZodAny;
+}, "strict", z.ZodTypeAny, {
+    type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
+    extra?: Record<string, any> | undefined;
+    parameter?: any;
+}, {
+    type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
+    extra?: Record<string, any> | undefined;
+    parameter?: any;
+}>;
+type JzodAttributeNumberValidations = z.infer<typeof jzodAttributeNumberValidationsSchema>;
+declare const jzodAttributeStringValidationsSchema: z.ZodObject<{
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    type: z.ZodEnum<["max", "min", "length", "email", "url", "emoji", "uuid", "cuid", "cuid2", "ulid", "regex", "includes", "startsWith", "endsWith", "datetime", "ip"]>;
+    parameter: z.ZodAny;
+}, "strict", z.ZodTypeAny, {
+    type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
+    extra?: Record<string, any> | undefined;
+    parameter?: any;
+}, {
+    type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
+    extra?: Record<string, any> | undefined;
+    parameter?: any;
+}>;
+type JzodAttributeStringValidations = z.infer<typeof jzodAttributeStringValidationsSchema>;
+declare const jzodAttributeDateWithValidationsSchema: z.ZodObject<{
+    optional: z.ZodOptional<z.ZodBoolean>;
+    nullable: z.ZodOptional<z.ZodBoolean>;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    coerce: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"simpleType">;
+    definition: z.ZodLiteral<"date">;
+    validations: z.ZodArray<z.ZodObject<{
+        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        type: z.ZodEnum<["min", "max"]>;
+        parameter: z.ZodAny;
+    }, "strict", z.ZodTypeAny, {
+        type: "min" | "max";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }, {
+        type: "min" | "max";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    type: "simpleType";
+    definition: "date";
+    validations: {
+        type: "min" | "max";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}, {
+    type: "simpleType";
+    definition: "date";
+    validations: {
+        type: "min" | "max";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}>;
+type JzodAttributeDateWithValidations = z.infer<typeof jzodAttributeDateWithValidationsSchema>;
+declare const jzodAttributeNumberWithValidationsSchema: z.ZodObject<{
+    optional: z.ZodOptional<z.ZodBoolean>;
+    nullable: z.ZodOptional<z.ZodBoolean>;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    coerce: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"simpleType">;
+    definition: z.ZodLiteral<"number">;
+    validations: z.ZodArray<z.ZodObject<{
+        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        type: z.ZodEnum<["gt", "gte", "lt", "lte", "int", "positive", "nonpositive", "negative", "nonnegative", "multipleOf", "finite", "safe"]>;
+        parameter: z.ZodAny;
+    }, "strict", z.ZodTypeAny, {
+        type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }, {
+        type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    type: "simpleType";
+    definition: "number";
+    validations: {
+        type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}, {
+    type: "simpleType";
+    definition: "number";
+    validations: {
+        type: "multipleOf" | "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "finite" | "safe";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}>;
+type JzodAttributeNumberWithValidations = z.infer<typeof jzodAttributeNumberWithValidationsSchema>;
+declare const jzodAttributeStringWithValidationsSchema: z.ZodObject<{
+    optional: z.ZodOptional<z.ZodBoolean>;
+    nullable: z.ZodOptional<z.ZodBoolean>;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    coerce: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"simpleType">;
+    definition: z.ZodLiteral<"string">;
+    validations: z.ZodArray<z.ZodObject<{
+        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        type: z.ZodEnum<["max", "min", "length", "email", "url", "emoji", "uuid", "cuid", "cuid2", "ulid", "regex", "includes", "startsWith", "endsWith", "datetime", "ip"]>;
+        parameter: z.ZodAny;
+    }, "strict", z.ZodTypeAny, {
+        type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }, {
+        type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    type: "simpleType";
+    definition: "string";
+    validations: {
+        type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}, {
+    type: "simpleType";
+    definition: "string";
+    validations: {
+        type: "length" | "includes" | "uuid" | "min" | "max" | "email" | "url" | "emoji" | "cuid" | "cuid2" | "ulid" | "regex" | "startsWith" | "endsWith" | "datetime" | "ip";
+        extra?: Record<string, any> | undefined;
+        parameter?: any;
+    }[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}>;
+type JzodAttributeStringWithValidations = z.infer<typeof jzodAttributeStringWithValidationsSchema>;
+declare const jzodAttributeSchema: z.ZodObject<{
+    optional: z.ZodOptional<z.ZodBoolean>;
+    nullable: z.ZodOptional<z.ZodBoolean>;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    coerce: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"simpleType">;
+    definition: z.ZodLazy<z.ZodEnum<["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]>>;
+}, "strict", z.ZodTypeAny, {
+    type: "simpleType";
+    definition: "string" | "number" | "bigint" | "boolean" | "undefined" | "any" | "date" | "never" | "null" | "uuid" | "unknown" | "void";
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}, {
+    type: "simpleType";
+    definition: "string" | "number" | "bigint" | "boolean" | "undefined" | "any" | "date" | "never" | "null" | "uuid" | "unknown" | "void";
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+    coerce?: boolean | undefined;
+}>;
+type JzodAttribute = z.infer<typeof jzodAttributeSchema>;
+type JzodElement = JzodArray | JzodAttribute | JzodAttributeDateWithValidations | JzodAttributeNumberWithValidations | JzodAttributeStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodRecord | JzodObject | JzodPromise | JzodReference | JzodSet | JzodTuple | JzodUnion;
+declare const jzodElementSchema: z.ZodType<JzodElement>;
+declare const jzodEnumSchema: z.ZodObject<{
+    optional: z.ZodOptional<z.ZodBoolean>;
+    nullable: z.ZodOptional<z.ZodBoolean>;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    type: z.ZodLiteral<"enum">;
+    definition: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    type: "enum";
+    definition: string[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+}, {
+    type: "enum";
+    definition: string[];
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+}>;
+type JzodEnum = z.infer<typeof jzodEnumSchema>;
+interface JzodFunction {
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'function';
+    definition: {
+        args: JzodElement[];
+        returns?: JzodElement;
+    };
+}
+declare const jzodFunctionSchema: ZodType<JzodFunction>;
+declare const jzodLazySchema: z.ZodObject<{
+    type: z.ZodLiteral<"lazy">;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    definition: ZodType<JzodFunction, z.ZodTypeDef, JzodFunction>;
+}, "strict", z.ZodTypeAny, {
+    type: "lazy";
+    definition: JzodFunction;
+    extra?: Record<string, any> | undefined;
+}, {
+    type: "lazy";
+    definition: JzodFunction;
+    extra?: Record<string, any> | undefined;
+}>;
+type JzodLazy = z.infer<typeof jzodLazySchema>;
+declare const jzodLiteralSchema: z.ZodObject<{
+    optional: z.ZodOptional<z.ZodBoolean>;
+    nullable: z.ZodOptional<z.ZodBoolean>;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    type: z.ZodLiteral<"literal">;
+    definition: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    type: "literal";
+    definition: string;
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+}, {
+    type: "literal";
+    definition: string;
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: Record<string, any> | undefined;
+}>;
+type JzodLiteral = z.infer<typeof jzodLiteralSchema>;
+interface JzodIntersection {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'intersection';
+    definition: {
+        left: JzodElement;
+        right: JzodElement;
+    };
+}
+declare const jzodIntersectionSchema: z.ZodType<JzodIntersection>;
+interface JzodMap extends JzodRoot {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'map';
+    definition: [JzodElement, JzodElement];
+}
+declare const jzodMapSchema: z.ZodType<JzodMap>;
+interface JzodObject extends JzodRoot {
+    optional?: boolean;
+    nullable?: boolean;
+    extend?: JzodReference | JzodObject;
+    extra?: {
+        [k: string]: any;
+    };
+    type: "object";
+    nonStrict?: boolean;
+    definition: {
+        [attributeName: string]: JzodElement;
+    };
+}
+declare const jzodObjectSchema: z.ZodType<JzodObject>;
+interface JzodPromise extends JzodRoot {
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'promise';
+    definition: JzodElement;
+}
+declare const jzodPromiseSchema: z.ZodType<JzodPromise>;
+interface JzodRecord {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'record';
+    definition: JzodElement;
+}
+declare const jzodRecordSchema: z.ZodType<JzodRecord>;
+interface JzodReference {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    context?: {
+        [attributeName: string]: JzodElement;
+    };
+    type: 'schemaReference';
+    definition: {
+        eager?: boolean;
+        relativePath?: string;
+        absolutePath?: string;
+    };
+}
+declare const jzodReferenceSchema: ZodType<JzodReference>;
+interface JzodSet extends JzodRoot {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'set';
+    definition: JzodElement;
+}
+declare const jzodSetSchema: z.ZodType<JzodSet>;
+interface JzodTuple {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: 'tuple';
+    definition: JzodElement[];
+}
+declare const jzodTupleSchema: z.ZodType<JzodTuple>;
+interface JzodUnion {
+    optional?: boolean;
+    nullable?: boolean;
+    extra?: {
+        [k: string]: any;
+    };
+    type: "union";
+    discriminator?: string;
+    definition: JzodElement[];
+}
+declare const jzodUnionSchema: z.ZodType<JzodUnion>;
+
+type TsTypeAliases = {
+    [k: string]: ts.TypeAliasDeclaration;
+};
+interface TsTypeAliasesAndZodText {
+    contextTsTypeAliases: {
+        [k: string]: ts.TypeAliasDeclaration;
+    };
+    contextZodText: {
+        [k: string]: string;
+    };
+    mainTsTypeAlias: ts.TypeAliasDeclaration;
+    mainZodText: string;
+}
+declare function jzodToTsTypeAliasesAndZodText(element: JzodElement, typeName?: string): TsTypeAliasesAndZodText;
+declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string): string;
+
+declare function printTsTypeAlias(typeAlias: ts.TypeAliasDeclaration, exportPrefix?: boolean): string;
+declare function printTsTypeAliases(typeAliases: TsTypeAliases, exportPrefix?: boolean): string;
+
+export { JzodArray, JzodAttribute, JzodAttributeDateValidations, JzodAttributeDateWithValidations, JzodAttributeNumberValidations, JzodAttributeNumberWithValidations, JzodAttributeStringValidations, JzodAttributeStringWithValidations, JzodElement, JzodEnum, JzodEnumElementTypes, JzodEnumTypes, JzodFunction, JzodIntersection, JzodLazy, JzodLiteral, JzodMap, JzodObject, JzodPromise, JzodRecord, JzodReference, JzodSet, JzodTuple, TsTypeAliasesAndZodText as JzodTypeAliasesAndZodText, JzodUnion, TsTypeAliases, jzodArraySchema, jzodAttributeDateValidationsSchema, jzodAttributeDateWithValidationsSchema, jzodAttributeNumberValidationsSchema, jzodAttributeNumberWithValidationsSchema, jzodAttributeSchema, jzodAttributeStringValidationsSchema, jzodAttributeStringWithValidationsSchema, jzodElementSchema, jzodEnumAttributeTypesSchema, jzodEnumElementTypesSchema, jzodEnumSchema, jzodFunctionSchema, jzodIntersectionSchema, jzodLazySchema, jzodLiteralSchema, jzodMapSchema, jzodObjectSchema, jzodPromiseSchema, jzodRecordSchema, jzodReferenceSchema, jzodSetSchema, jzodToTsCode, jzodToTsTypeAliasesAndZodText, jzodTupleSchema, jzodUnionSchema, printTsTypeAlias, printTsTypeAliases };