@nmtjs/type 0.6.5 → 0.7.1

package/dist/types/number.js

@@ -1,97 +1,44 @@
-import { Type } from '@sinclair/typebox';
+import { gt, gte, int, lt, lte, number, regex, string } from "@zod/mini";
 import { BaseType } from "./base.js";
+import { CustomType, TransformType } from "./custom.js";
 export class NumberType extends BaseType {
-    static factory(options = {}) {
-        return new NumberType(Type.Number(options), {
-            options
-        });
-    }
-    positive() {
-        return this.min(0, true);
-    }
-    negative() {
-        return this.max(0, true);
-    }
-    max(value, exclusive) {
-        return NumberType.factory({
-            ...this.props.options,
-            maximum: value,
-            ...!exclusive ? {} : {
-                exclusiveMaximum: value
-            }
-        });
-    }
-    min(value, exclusive) {
-        return NumberType.factory({
-            ...this.props.options,
-            minimum: value,
-            ...!exclusive ? {} : {
-                exclusiveMinimum: value
-            }
-        });
-    }
+	static factory(...checks) {
+		return new NumberType({
+			encodedZodType: number().check(...checks),
+			params: { checks }
+		});
+	}
+	positive() {
+		return NumberType.factory(...this.params.checks, gte(0));
+	}
+	negative() {
+		return NumberType.factory(...this.params.checks, lte(0));
+	}
+	lt(value) {
+		return NumberType.factory(...this.params.checks, lt(value));
+	}
+	lte(value) {
+		return NumberType.factory(...this.params.checks, lte(value));
+	}
+	gte(value) {
+		return NumberType.factory(...this.params.checks, gte(value));
+	}
+	gt(value) {
+		return NumberType.factory(...this.params.checks, gt(value));
+	}
 }
-export class IntegerType extends BaseType {
-    static factory(options = {}) {
-        return new IntegerType(Type.Integer(options), {
-            options
-        });
-    }
-    positive() {
-        return this.min(0, true);
-    }
-    negative() {
-        return this.max(0, true);
-    }
-    max(value, exclusive) {
-        return IntegerType.factory({
-            ...this.props.options,
-            maximum: value,
-            ...!exclusive ? {} : {
-                exclusiveMaximum: value
-            }
-        });
-    }
-    min(value, exclusive) {
-        return IntegerType.factory({
-            ...this.props.options,
-            minimum: value,
-            ...!exclusive ? {} : {
-                exclusiveMinimum: value
-            }
-        });
-    }
+export class IntegerType extends NumberType {
+	static factory(...checks) {
+		return NumberType.factory(...checks, int());
+	}
 }
-export class BigIntType extends BaseType {
-    static factory(options = {}) {
-        return new BigIntType(Type.BigInt(options), {
-            options
-        }, {
-            encode: (value)=>`${value}`
-        });
-    }
-    positive() {
-        return this.min(0n, true);
-    }
-    negative() {
-        return this.max(0n, true);
-    }
-    max(value, exclusive) {
-        return BigIntType.factory({
-            ...this.props.options,
-            maximum: value,
-            ...!exclusive ? {} : {
-                exclusiveMaximum: value
-            }
-        });
-    }
-    min(value, exclusive) {
-        return BigIntType.factory({
-            ...this.props.options,
-            minimum: value,
-            ...!exclusive ? {} : {
-                exclusiveMinimum: value
-            }
-        });
-    }
+export class BigIntType extends TransformType {
+	static factory() {
+		return CustomType.factory({
+			decode: (value) => BigInt(value),
+			encode: (value) => value.toString(),
+			type: string().check(regex(/^-?\d+$/)),
+			error: "Invalid bigint format"
+		});
+	}
 }

package/dist/types/number.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/number.ts"],"sourcesContent":["import {\n  type BigIntOptions,\n  type IntegerOptions,\n  type NumberOptions,\n  type TBigInt,\n  type TInteger,\n  type TNumber,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class NumberType extends BaseType<\n  TNumber,\n  { options: NumberOptions },\n  number\n> {\n  static factory(options: NumberOptions = {}) {\n    return new NumberType(Type.Number(options), { options })\n  }\n\n  positive() {\n    return this.min(0, true)\n  }\n\n  negative() {\n    return this.max(0, true)\n  }\n\n  max(value: number, exclusive?: true) {\n    return NumberType.factory({\n      ...this.props.options,\n      maximum: value,\n      ...(!exclusive ? {} : { exclusiveMaximum: value }),\n    })\n  }\n\n  min(value: number, exclusive?: true) {\n    return NumberType.factory({\n      ...this.props.options,\n      minimum: value,\n      ...(!exclusive ? {} : { exclusiveMinimum: value }),\n    })\n  }\n}\n\nexport class IntegerType extends BaseType<\n  TInteger,\n  { options: IntegerOptions },\n  number\n> {\n  static factory(options: IntegerOptions = {}) {\n    return new IntegerType(Type.Integer(options), { options })\n  }\n\n  positive() {\n    return this.min(0, true)\n  }\n\n  negative() {\n    return this.max(0, true)\n  }\n\n  max(value: number, exclusive?: true) {\n    return IntegerType.factory({\n      ...this.props.options,\n      maximum: value,\n      ...(!exclusive ? {} : { exclusiveMaximum: value }),\n    })\n  }\n\n  min(value: number, exclusive?: true) {\n    return IntegerType.factory({\n      ...this.props.options,\n      minimum: value,\n      ...(!exclusive ? {} : { exclusiveMinimum: value }),\n    })\n  }\n}\n\n// TODO: this is not json schema compatible\nexport class BigIntType extends BaseType<\n  TBigInt,\n  { options: BigIntOptions },\n  bigint\n> {\n  static factory(options: BigIntOptions = {}) {\n    return new BigIntType(\n      Type.BigInt(options),\n      { options },\n      { encode: (value) => `${value}` },\n    )\n  }\n\n  positive() {\n    return this.min(0n, true)\n  }\n\n  negative() {\n    return this.max(0n, true)\n  }\n\n  max(value: bigint, exclusive?: true) {\n    return BigIntType.factory({\n      ...this.props.options,\n      maximum: value,\n      ...(!exclusive ? {} : { exclusiveMaximum: value }),\n    })\n  }\n\n  min(value: bigint, exclusive?: true) {\n    return BigIntType.factory({\n      ...this.props.options,\n      minimum: value,\n      ...(!exclusive ? {} : { exclusiveMinimum: value }),\n    })\n  }\n}\n"],"names":["Type","BaseType","NumberType","factory","options","Number","positive","min","negative","max","value","exclusive","props","maximum","exclusiveMaximum","minimum","exclusiveMinimum","IntegerType","Integer","BigIntType","BigInt","encode"],"mappings":"AAAA,SAOEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,mBAAmBD;IAK9B,OAAOE,QAAQC,UAAyB,CAAC,CAAC,EAAE;QAC1C,OAAO,IAAIF,WAAWF,KAAKK,MAAM,CAACD,UAAU;YAAEA;QAAQ;IACxD;IAEAE,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,GAAG;IACrB;IAEAC,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,GAAG;IACrB;IAEAA,IAAIC,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOT,WAAWC,OAAO,CAAC;YACxB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBS,SAASH;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEG,kBAAkBJ;YAAM,CAAC;QACnD;IACF;IAEAH,IAAIG,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOT,WAAWC,OAAO,CAAC;YACxB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBW,SAASL;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEK,kBAAkBN;YAAM,CAAC;QACnD;IACF;AACF;AAEA,OAAO,MAAMO,oBAAoBhB;IAK/B,OAAOE,QAAQC,UAA0B,CAAC,CAAC,EAAE;QAC3C,OAAO,IAAIa,YAAYjB,KAAKkB,OAAO,CAACd,UAAU;YAAEA;QAAQ;IAC1D;IAEAE,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,GAAG;IACrB;IAEAC,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,GAAG;IACrB;IAEAA,IAAIC,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOM,YAAYd,OAAO,CAAC;YACzB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBS,SAASH;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEG,kBAAkBJ;YAAM,CAAC;QACnD;IACF;IAEAH,IAAIG,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOM,YAAYd,OAAO,CAAC;YACzB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBW,SAASL;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEK,kBAAkBN;YAAM,CAAC;QACnD;IACF;AACF;AAGA,OAAO,MAAMS,mBAAmBlB;IAK9B,OAAOE,QAAQC,UAAyB,CAAC,CAAC,EAAE;QAC1C,OAAO,IAAIe,WACTnB,KAAKoB,MAAM,CAAChB,UACZ;YAAEA;QAAQ,GACV;YAAEiB,QAAQ,CAACX,QAAU,CAAC,EAAEA,MAAM,CAAC;QAAC;IAEpC;IAEAJ,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,EAAE,EAAE;IACtB;IAEAC,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,EAAE,EAAE;IACtB;IAEAA,IAAIC,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOQ,WAAWhB,OAAO,CAAC;YACxB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBS,SAASH;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEG,kBAAkBJ;YAAM,CAAC;QACnD;IACF;IAEAH,IAAIG,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOQ,WAAWhB,OAAO,CAAC;YACxB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBW,SAASL;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEK,kBAAkBN;YAAM,CAAC;QACnD;IACF;AACF"}
+{"mappings":"AAAA,SAEE,IACA,KACA,KACA,IACA,KACA,QACA,OACA,cAGK,WAAW;AAClB,SAAS,gBAAgB,WAAW;AACpC,SAAS,YAAY,qBAAqB,aAAa;AAIvD,OAAO,MAAM,mBAAmB,SAG9B;CACA,OAAO,QAAQ,GAAG,QAAiB;AACjC,SAAO,IAAI,WAAW;GACpB,gBAAgB,QAAQ,CAAC,MAAM,GAAG,OAAO;GACzC,QAAQ,EAAE,OAAQ;EACnB;CACF;CAED,WAAW;AACT,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,EAAE,CAAC;CACzD;CAED,WAAW;AACT,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,EAAE,CAAC;CACzD;CAED,GAAGA,OAAe;AAChB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,GAAG,MAAM,CAAC;CAC5D;CAED,IAAIA,OAAe;AACjB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,MAAM,CAAC;CAC7D;CAED,IAAIA,OAAe;AACjB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,MAAM,CAAC;CAC7D;CAED,GAAGA,OAAe;AAChB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,GAAG,MAAM,CAAC;CAC5D;AACF;AAED,OAAO,MAAM,oBAAoB,WAAW;CAC1C,OAAO,QAAQ,GAAG,QAAiB;AACjC,SAAO,WAAW,QAAQ,GAAG,QAAQ,KAAK,CAAC;CAC5C;AACF;AAED,OAAO,MAAM,mBAAmB,cAA6C;CAC3E,OAAO,UAAU;AACf,SAAO,WAAW,QAAuC;GACvD,QAAQ,CAAC,UAAU,OAAO,MAAM;GAChC,QAAQ,CAAC,UAAU,MAAM,UAAU;GACnC,MAAM,QAAQ,CAAC,MAAM,MAAM,UAAU,CAAC;GACtC,OAAO;EACR,EAAC;CACH;AACF","names":["value: number"],"sources":["src/types/number.ts"],"sourcesContent":["import {\n  type core,\n  gt,\n  gte,\n  int,\n  lt,\n  lte,\n  number,\n  regex,\n  string,\n  type ZodMiniNumber,\n  type ZodMiniString,\n} from '@zod/mini'\nimport { BaseType } from './base.ts'\nimport { CustomType, TransformType } from './custom.ts'\n\ntype Check = core.CheckFn<number> | core.$ZodCheck<number>\n\nexport class NumberType extends BaseType<\n  ZodMiniNumber<number>,\n  ZodMiniNumber<number>\n> {\n  static factory(...checks: Check[]) {\n    return new NumberType({\n      encodedZodType: number().check(...checks),\n      params: { checks },\n    })\n  }\n\n  positive() {\n    return NumberType.factory(...this.params.checks, gte(0))\n  }\n\n  negative() {\n    return NumberType.factory(...this.params.checks, lte(0))\n  }\n\n  lt(value: number) {\n    return NumberType.factory(...this.params.checks, lt(value))\n  }\n\n  lte(value: number) {\n    return NumberType.factory(...this.params.checks, lte(value))\n  }\n\n  gte(value: number) {\n    return NumberType.factory(...this.params.checks, gte(value))\n  }\n\n  gt(value: number) {\n    return NumberType.factory(...this.params.checks, gt(value))\n  }\n}\n\nexport class IntegerType extends NumberType {\n  static factory(...checks: Check[]) {\n    return NumberType.factory(...checks, int())\n  }\n}\n\nexport class BigIntType extends TransformType<bigint, ZodMiniString<string>> {\n  static factory() {\n    return CustomType.factory<bigint, ZodMiniString<string>>({\n      decode: (value) => BigInt(value),\n      encode: (value) => value.toString(),\n      type: string().check(regex(/^-?\\d+$/)),\n      error: 'Invalid bigint format',\n    })\n  }\n}\n"],"version":3}

package/dist/types/object.js

@@ -1,49 +1,60 @@
-import { Type } from '@sinclair/typebox';
+import { object, record, strictObject } from "@zod/mini";
 import { BaseType } from "./base.js";
 import { EnumType } from "./enum.js";
 export class ObjectType extends BaseType {
-    static factory(properties, options = {}) {
-        const schemaProperties = {};
-        for(const key in properties){
-            schemaProperties[key] = properties[key].schema;
-        }
-        return new ObjectType(Type.Object(schemaProperties, options), {
-            properties
-        });
-    }
+	static factory(properties) {
+		const encodeProperties = {};
+		const decodeProperties = {};
+		for (const key in properties) {
+			encodeProperties[key] = properties[key].encodedZodType;
+			decodeProperties[key] = properties[key].decodedZodType;
+		}
+		return new ObjectType({
+			encodedZodType: object(encodeProperties),
+			decodedZodType: object(decodeProperties),
+			props: { properties }
+		});
+	}
 }
 export class RecordType extends BaseType {
-    static factory(key, element, options = {}) {
-        return new RecordType(Type.Record(key.schema, element.schema, options));
-    }
+	static factory(key, element) {
+		return new RecordType({
+			encodedZodType: record(key.encodedZodType, element.encodedZodType),
+			decodedZodType: record(key.decodedZodType, element.decodedZodType),
+			props: {
+				key,
+				element
+			}
+		});
+	}
 }
 export function keyof(type) {
-    return EnumType.factory(Object.keys(type.props.properties));
+	return EnumType.factory(Object.keys(type.props.properties));
 }
 export function pick(source, pick) {
-    const properties = Object.fromEntries(Object.entries(source.props.properties).filter(([key])=>pick[key]));
-    return ObjectType.factory(properties);
+	const properties = Object.fromEntries(Object.entries(source.props.properties).filter(([key]) => pick[key]));
+	return ObjectType.factory(properties);
 }
 export function omit(source, omit) {
-    const properties = Object.fromEntries(Object.entries(source.props.properties).filter(([key])=>!omit[key]));
-    return ObjectType.factory(properties);
+	const properties = Object.fromEntries(Object.entries(source.props.properties).filter(([key]) => !omit[key]));
+	return ObjectType.factory(properties);
 }
 export function extend(object1, properties) {
-    return ObjectType.factory({
-        ...object1.props.properties,
-        ...properties
-    });
+	return ObjectType.factory({
+		...object1.props.properties,
+		...properties
+	});
 }
 export function merge(object1, object2) {
-    return ObjectType.factory({
-        ...object1.props.properties,
-        ...object2.props.properties
-    });
+	return ObjectType.factory({
+		...object1.props.properties,
+		...object2.props.properties
+	});
 }
 export function partial(object) {
-    const properties = {};
-    for (const [key, value] of Object.entries(object.props.properties)){
-        properties[key] = value.optional();
-    }
-    return ObjectType.factory(properties, {});
+	const properties = {};
+	for (const [key, value] of Object.entries(object.props.properties)) {
+		properties[key] = value.optional();
+	}
+	return ObjectType.factory(properties);
 }

package/dist/types/object.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/object.ts"],"sourcesContent":["import {\n  type ObjectOptions,\n  type TObject,\n  type TRecordOrObject,\n  type TSchema,\n  Type,\n} from '@sinclair/typebox'\nimport type { StaticInputDecode } from '../inference.ts'\nimport type { UnionToTupleString } from '../utils.ts'\nimport { BaseType, type BaseTypeAny, type OptionalType } from './base.ts'\nimport { EnumType, type ObjectEnumType } from './enum.ts'\nimport type { LiteralType } from './literal.ts'\nimport type { StringType } from './string.ts'\n\nexport type ObjectTypeProps = { [k: string]: BaseTypeAny }\nexport type AnyObjectType = ObjectType<ObjectTypeProps>\nexport class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<\n  TObject<{ [K in keyof T]: T[K]['schema'] }>,\n  { properties: T },\n  StaticInputDecode<TObject<{ [K in keyof T]: T[K]['schema'] }>>\n> {\n  static factory<T extends ObjectTypeProps = {}>(\n    properties: T,\n    options: ObjectOptions = {},\n  ) {\n    const schemaProperties = {} as {\n      [K in keyof T]: T[K]['schema']\n    }\n\n    for (const key in properties) {\n      schemaProperties[key] = properties[key].schema\n    }\n\n    return new ObjectType<T>(Type.Object(schemaProperties, options) as any, {\n      properties,\n    })\n  }\n}\n\nexport class RecordType<\n  K extends LiteralType | EnumType | ObjectEnumType | StringType,\n  E extends BaseType,\n> extends BaseType<TRecordOrObject<K['schema'], E['schema']>> {\n  static factory<\n    K extends\n      | LiteralType<any>\n      | EnumType<any>\n      | ObjectEnumType<any>\n      | StringType,\n    E extends BaseType,\n  >(key: K, element: E, options: ObjectOptions = {}) {\n    return new RecordType<K, E>(\n      Type.Record(key.schema, element.schema, options) as any,\n    )\n  }\n}\n\nexport function keyof<T extends ObjectType>(\n  type: T,\n): EnumType<\n  UnionToTupleString<T extends ObjectType<infer Props> ? keyof Props : never>\n> {\n  return EnumType.factory(Object.keys(type.props.properties) as any)\n}\n\nexport function pick<\n  T extends AnyObjectType,\n  P extends { [K in keyof T['props']['properties']]?: true },\n>(\n  source: T,\n  pick: P,\n): ObjectType<{\n  [K in keyof P]: P[K] extends true\n    ? K extends keyof T['props']['properties']\n      ? T['props']['properties'][K]\n      : never\n    : never\n}> {\n  const properties = Object.fromEntries(\n    Object.entries(source.props.properties).filter(([key]) => pick[key]),\n  )\n  return ObjectType.factory(properties) as any\n}\n\nexport function omit<\n  T extends AnyObjectType,\n  P extends { [K in keyof T['props']['properties']]?: true },\n>(\n  source: T,\n  omit: P,\n): ObjectType<{\n  [K in keyof T['props']['properties'] as K extends keyof P\n    ? never\n    : K]: T['props']['properties'][K]\n}> {\n  const properties = Object.fromEntries(\n    Object.entries(source.props.properties).filter(([key]) => !omit[key]),\n  )\n  return ObjectType.factory(properties) as any\n}\n\nexport function extend<T extends AnyObjectType, P extends ObjectTypeProps>(\n  object1: T,\n  properties: P,\n): ObjectType<{\n  [K in keyof T['props']['properties'] | keyof P]: K extends keyof P\n    ? P[K]\n    : K extends keyof T['props']['properties']\n      ? T['props']['properties'][K]\n      : never\n}> {\n  return ObjectType.factory({\n    ...object1.props.properties,\n    ...properties,\n  }) as any\n}\n\nexport function merge<T1 extends AnyObjectType, T2 extends AnyObjectType>(\n  object1: T1,\n  object2: T2,\n): ObjectType<{\n  [K in\n    | keyof T1['props']['properties']\n    | keyof T2['props']['properties']]: K extends keyof T2['props']['properties']\n    ? T2['props']['properties'][K]\n    : K extends keyof T1['props']['properties']\n      ? T1['props']['properties'][K]\n      : never\n}> {\n  return ObjectType.factory({\n    ...object1.props.properties,\n    ...object2.props.properties,\n  }) as any\n}\n\nexport function partial<\n  T extends AnyObjectType,\n  P extends T extends ObjectType<infer Props> ? Props : never,\n>(\n  object: T,\n): ObjectType<{\n  [K in keyof P]: P[K] extends BaseType<any, any, infer T>\n    ? OptionalType<P[K], T>\n    : never\n}> {\n  const properties = {} as any\n\n  for (const [key, value] of Object.entries(object.props.properties)) {\n    properties[key] = value.optional()\n  }\n\n  return ObjectType.factory(properties, {}) as any\n}\n"],"names":["Type","BaseType","EnumType","ObjectType","factory","properties","options","schemaProperties","key","schema","Object","RecordType","element","Record","keyof","type","keys","props","pick","source","fromEntries","entries","filter","omit","extend","object1","merge","object2","partial","object","value","optional"],"mappings":"AAAA,SAKEA,IAAI,QACC,oBAAmB;AAG1B,SAASC,QAAQ,QAA6C,YAAW;AACzE,SAASC,QAAQ,QAA6B,YAAW;AAMzD,OAAO,MAAMC,mBAAmDF;IAK9D,OAAOG,QACLC,UAAa,EACbC,UAAyB,CAAC,CAAC,EAC3B;QACA,MAAMC,mBAAmB,CAAC;QAI1B,IAAK,MAAMC,OAAOH,WAAY;YAC5BE,gBAAgB,CAACC,IAAI,GAAGH,UAAU,CAACG,IAAI,CAACC,MAAM;QAChD;QAEA,OAAO,IAAIN,WAAcH,KAAKU,MAAM,CAACH,kBAAkBD,UAAiB;YACtED;QACF;IACF;AACF;AAEA,OAAO,MAAMM,mBAGHV;IACR,OAAOG,QAOLI,GAAM,EAAEI,OAAU,EAAEN,UAAyB,CAAC,CAAC,EAAE;QACjD,OAAO,IAAIK,WACTX,KAAKa,MAAM,CAACL,IAAIC,MAAM,EAAEG,QAAQH,MAAM,EAAEH;IAE5C;AACF;AAEA,OAAO,SAASQ,MACdC,IAAO;IAIP,OAAOb,SAASE,OAAO,CAACM,OAAOM,IAAI,CAACD,KAAKE,KAAK,CAACZ,UAAU;AAC3D;AAEA,OAAO,SAASa,KAIdC,MAAS,EACTD,IAAO;IAQP,MAAMb,aAAaK,OAAOU,WAAW,CACnCV,OAAOW,OAAO,CAACF,OAAOF,KAAK,CAACZ,UAAU,EAAEiB,MAAM,CAAC,CAAC,CAACd,IAAI,GAAKU,IAAI,CAACV,IAAI;IAErE,OAAOL,WAAWC,OAAO,CAACC;AAC5B;AAEA,OAAO,SAASkB,KAIdJ,MAAS,EACTI,IAAO;IAMP,MAAMlB,aAAaK,OAAOU,WAAW,CACnCV,OAAOW,OAAO,CAACF,OAAOF,KAAK,CAACZ,UAAU,EAAEiB,MAAM,CAAC,CAAC,CAACd,IAAI,GAAK,CAACe,IAAI,CAACf,IAAI;IAEtE,OAAOL,WAAWC,OAAO,CAACC;AAC5B;AAEA,OAAO,SAASmB,OACdC,OAAU,EACVpB,UAAa;IAQb,OAAOF,WAAWC,OAAO,CAAC;QACxB,GAAGqB,QAAQR,KAAK,CAACZ,UAAU;QAC3B,GAAGA,UAAU;IACf;AACF;AAEA,OAAO,SAASqB,MACdD,OAAW,EACXE,OAAW;IAUX,OAAOxB,WAAWC,OAAO,CAAC;QACxB,GAAGqB,QAAQR,KAAK,CAACZ,UAAU;QAC3B,GAAGsB,QAAQV,KAAK,CAACZ,UAAU;IAC7B;AACF;AAEA,OAAO,SAASuB,QAIdC,MAAS;IAMT,MAAMxB,aAAa,CAAC;IAEpB,KAAK,MAAM,CAACG,KAAKsB,MAAM,IAAIpB,OAAOW,OAAO,CAACQ,OAAOZ,KAAK,CAACZ,UAAU,EAAG;QAClEA,UAAU,CAACG,IAAI,GAAGsB,MAAMC,QAAQ;IAClC;IAEA,OAAO5B,WAAWC,OAAO,CAACC,YAAY,CAAC;AACzC"}
+{"mappings":"AAAA,SAEE,QACA,QACA,oBAGK,WAAW;AAElB,SAAS,gBAAqD,WAAW;AACzE,SAAS,gBAAgB,WAAW;AAMpC,OAAO,MAAM,mBAAmD,SAI9D;CACA,OAAO,QAAwCA,YAAe;EAC5D,MAAM,mBAAmB,CAAE;EAG3B,MAAM,mBAAmB,CAAE;AAI3B,OAAK,MAAM,OAAO,YAAY;AAC5B,oBAAiB,OAAO,WAAW,KAAK;AACxC,oBAAiB,OAAO,WAAW,KAAK;EACzC;AAED,SAAO,IAAI,WAAc;GACvB,gBAAgB,OAAO,iBAAiB;GACxC,gBAAgB,OAAO,iBAAiB;GACxC,OAAO,EAAE,WAAY;EACtB;CACF;AACF;AAED,OAAO,MAAM,mBAGH,SAGR;CACA,OAAO,QAGLC,KAAQC,SAAY;AACpB,SAAO,IAAI,WAAiB;GAC1B,gBAAgB,OACb,IAAY,gBACb,QAAQ,eACT;GACD,gBAAgB,OACb,IAAY,gBACb,QAAQ,eACT;GACD,OAAO;IAAE;IAAK;GAAS;EACxB;CACF;AACF;AAED,OAAO,SAAS,MACdC,MAGA;AACA,QAAO,SAAS,QAAQ,OAAO,KAAK,KAAK,MAAM,WAAW,CAAQ;AACnE;AAED,OAAO,SAAS,KAIdC,QACAC,MAOC;CACD,MAAM,aAAa,OAAO,YACxB,OAAO,QAAQ,OAAO,MAAM,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,KAAK,KAAK,KAAK,CACrE;AACD,QAAO,WAAW,QAAQ,WAAW;AACtC;AAED,OAAO,SAAS,KAIdD,QACAE,MAKC;CACD,MAAM,aAAa,OAAO,YACxB,OAAO,QAAQ,OAAO,MAAM,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,MAAM,KAAK,KAAK,CACtE;AACD,QAAO,WAAW,QAAQ,WAAW;AACtC;AAED,OAAO,SAAS,OACdC,SACAC,YAOC;AACD,QAAO,WAAW,QAAQ;EACxB,GAAG,QAAQ,MAAM;EACjB,GAAG;CACJ,EAAC;AACH;AAED,OAAO,SAAS,MACdC,SACAC,SASC;AACD,QAAO,WAAW,QAAQ;EACxB,GAAG,QAAQ,MAAM;EACjB,GAAG,QAAQ,MAAM;CAClB,EAAC;AACH;AAED,OAAO,SAAS,QAIdC,QAGC;CACD,MAAM,aAAa,CAAE;AAErB,MAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,QAAQ,OAAO,MAAM,WAAW,EAAE;AAClE,aAAW,OAAO,MAAM,UAAU;CACnC;AAED,QAAO,WAAW,QAAQ,WAAW;AACtC","names":["properties: T","key: K","element: E","type: T","source: T","pick: P","omit: P","object1: T","properties: P","object1: T1","object2: T2","object: T"],"sources":["src/types/object.ts"],"sourcesContent":["import {\n  type core,\n  object,\n  record,\n  strictObject,\n  type ZodMiniObject,\n  type ZodMiniRecord,\n} from '@zod/mini'\n\nimport { BaseType, type BaseTypeAny, type OptionalType } from './base.ts'\nimport { EnumType } from './enum.ts'\nimport type { LiteralType } from './literal.ts'\nimport type { StringType } from './string.ts'\n\nexport type ObjectTypeProps = { [k: string]: BaseTypeAny }\nexport type AnyObjectType = ObjectType<ObjectTypeProps>\nexport class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<\n  ZodMiniObject<{ [K in keyof T]: T[K]['encodedZodType'] }, {}>,\n  ZodMiniObject<{ [K in keyof T]: T[K]['decodedZodType'] }, {}>,\n  { properties: T }\n> {\n  static factory<T extends ObjectTypeProps = {}>(properties: T) {\n    const encodeProperties = {} as {\n      [K in keyof T]: T[K]['encodedZodType']\n    }\n    const decodeProperties = {} as {\n      [K in keyof T]: T[K]['decodedZodType']\n    }\n\n    for (const key in properties) {\n      encodeProperties[key] = properties[key].encodedZodType\n      decodeProperties[key] = properties[key].decodedZodType\n    }\n\n    return new ObjectType<T>({\n      encodedZodType: object(encodeProperties),\n      decodedZodType: object(decodeProperties),\n      props: { properties },\n    })\n  }\n}\n\nexport class RecordType<\n  K extends LiteralType<string | number> | EnumType | StringType,\n  E extends BaseType,\n> extends BaseType<\n  ZodMiniRecord<K['encodedZodType'], E['encodedZodType']>,\n  ZodMiniRecord<K['decodedZodType'], E['decodedZodType']>\n> {\n  static factory<\n    K extends LiteralType<string | number> | EnumType | StringType,\n    E extends BaseType,\n  >(key: K, element: E) {\n    return new RecordType<K, E>({\n      encodedZodType: record(\n        (key as any).encodedZodType,\n        element.encodedZodType,\n      ),\n      decodedZodType: record(\n        (key as any).decodedZodType,\n        element.decodedZodType,\n      ),\n      props: { key, element },\n    })\n  }\n}\n\nexport function keyof<T extends ObjectType>(\n  type: T,\n): EnumType<\n  core.utils.ToEnum<Extract<keyof T['props']['properties'], string>>\n> {\n  return EnumType.factory(Object.keys(type.props.properties) as any)\n}\n\nexport function pick<\n  T extends AnyObjectType,\n  P extends { [K in keyof T['props']['properties']]?: true },\n>(\n  source: T,\n  pick: P,\n): ObjectType<{\n  [K in keyof P]: P[K] extends true\n    ? K extends keyof T['props']['properties']\n      ? T['props']['properties'][K]\n      : never\n    : never\n}> {\n  const properties = Object.fromEntries(\n    Object.entries(source.props.properties).filter(([key]) => pick[key]),\n  )\n  return ObjectType.factory(properties) as any\n}\n\nexport function omit<\n  T extends AnyObjectType,\n  P extends { [K in keyof T['props']['properties']]?: true },\n>(\n  source: T,\n  omit: P,\n): ObjectType<{\n  [K in keyof T['props']['properties'] as K extends keyof P\n    ? never\n    : K]: T['props']['properties'][K]\n}> {\n  const properties = Object.fromEntries(\n    Object.entries(source.props.properties).filter(([key]) => !omit[key]),\n  )\n  return ObjectType.factory(properties) as any\n}\n\nexport function extend<T extends AnyObjectType, P extends ObjectTypeProps>(\n  object1: T,\n  properties: P,\n): ObjectType<{\n  [K in keyof T['props']['properties'] | keyof P]: K extends keyof P\n    ? P[K]\n    : K extends keyof T['props']['properties']\n      ? T['props']['properties'][K]\n      : never\n}> {\n  return ObjectType.factory({\n    ...object1.props.properties,\n    ...properties,\n  }) as any\n}\n\nexport function merge<T1 extends AnyObjectType, T2 extends AnyObjectType>(\n  object1: T1,\n  object2: T2,\n): ObjectType<{\n  [K in\n    | keyof T1['props']['properties']\n    | keyof T2['props']['properties']]: K extends keyof T2['props']['properties']\n    ? T2['props']['properties'][K]\n    : K extends keyof T1['props']['properties']\n      ? T1['props']['properties'][K]\n      : never\n}> {\n  return ObjectType.factory({\n    ...object1.props.properties,\n    ...object2.props.properties,\n  }) as any\n}\n\nexport function partial<\n  T extends AnyObjectType,\n  P extends T extends ObjectType<infer Props> ? Props : never,\n>(\n  object: T,\n): ObjectType<{\n  [K in keyof P]: OptionalType<P[K]>\n}> {\n  const properties = {} as any\n\n  for (const [key, value] of Object.entries(object.props.properties)) {\n    properties[key] = value.optional()\n  }\n\n  return ObjectType.factory(properties)\n}\n"],"version":3}

package/dist/types/string.js

@@ -1,50 +1,52 @@
-import { Type } from '@sinclair/typebox';
+import { cuid, cuid2, e164, email, emoji, ipv4, ipv6, jwt, maxLength, minLength, nanoid, regex, string, url, uuid } from "@zod/mini";
 import { BaseType } from "./base.js";
 export class StringType extends BaseType {
-    static factory(options = {}) {
-        return new StringType(Type.String(options), {
-            options
-        });
-    }
-    max(value) {
-        return StringType.factory({
-            ...this.props.options,
-            maxLength: value
-        });
-    }
-    min(value) {
-        return StringType.factory({
-            ...this.props.options,
-            minLength: value
-        });
-    }
-    format(format) {
-        return StringType.factory({
-            ...this.props.options,
-            pattern: undefined,
-            format
-        });
-    }
-    pattern(pattern) {
-        return StringType.factory({
-            ...this.props.options,
-            format: undefined,
-            pattern
-        });
-    }
-    email() {
-        return this.format('email');
-    }
-    url() {
-        return this.format('uri');
-    }
-    ipv4() {
-        return this.format('ipv4');
-    }
-    ipv6() {
-        return this.format('ipv6');
-    }
-    uuid() {
-        return this.format('uuid');
-    }
+	static factory(...checks) {
+		return new StringType({
+			encodedZodType: string().check(...checks),
+			params: { checks }
+		});
+	}
+	max(value) {
+		return StringType.factory(...this.params.checks, maxLength(value));
+	}
+	min(value) {
+		return StringType.factory(...this.params.checks, minLength(value));
+	}
+	pattern(pattern) {
+		return StringType.factory(...this.params.checks, regex(typeof pattern === "string" ? new RegExp(pattern) : pattern));
+	}
+	email(options) {
+		return StringType.factory(...this.params.checks, email(options));
+	}
+	url(options) {
+		return StringType.factory(...this.params.checks, url(options));
+	}
+	ipv4(options) {
+		return StringType.factory(...this.params.checks, ipv4(options));
+	}
+	ipv6(options) {
+		return StringType.factory(...this.params.checks, ipv6(options));
+	}
+	uuid(options) {
+		return StringType.factory(...this.params.checks, uuid(options));
+	}
+	emoji(options) {
+		return StringType.factory(...this.params.checks, emoji(options));
+	}
+	nanoid(options) {
+		return StringType.factory(...this.params.checks, nanoid(options));
+	}
+	cuid(options) {
+		return StringType.factory(...this.params.checks, cuid(options));
+	}
+	cuid2(options) {
+		return StringType.factory(...this.params.checks, cuid2(options));
+	}
+	e164(options) {
+		return StringType.factory(...this.params.checks, e164(options));
+	}
+	jwt(options) {
+		return StringType.factory(...this.params.checks, jwt(options));
+	}
 }

package/dist/types/string.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/string.ts"],"sourcesContent":["import { type StringOptions, type TString, Type } from '@sinclair/typebox'\nimport type { StaticOutputDecode } from '../inference.ts'\nimport { BaseType } from './base.ts'\n\nexport class StringType extends BaseType<\n  TString,\n  { options: StringOptions },\n  string\n> {\n  static factory(options: StringOptions = {}) {\n    return new StringType(Type.String(options), { options })\n  }\n\n  max(value: number) {\n    return StringType.factory({\n      ...this.props.options,\n      maxLength: value,\n    })\n  }\n\n  min(value: number) {\n    return StringType.factory({\n      ...this.props.options,\n      minLength: value,\n    })\n  }\n\n  format(format: TString['format']) {\n    return StringType.factory({\n      ...this.props.options,\n      pattern: undefined,\n      format,\n    })\n  }\n\n  pattern(pattern: string) {\n    return StringType.factory({\n      ...this.props.options,\n      format: undefined,\n      pattern,\n    })\n  }\n\n  email() {\n    return this.format('email')\n  }\n\n  url() {\n    return this.format('uri')\n  }\n\n  ipv4() {\n    return this.format('ipv4')\n  }\n\n  ipv6() {\n    return this.format('ipv6')\n  }\n\n  uuid() {\n    return this.format('uuid')\n  }\n}\n"],"names":["Type","BaseType","StringType","factory","options","String","max","value","props","maxLength","min","minLength","format","pattern","undefined","email","url","ipv4","ipv6","uuid"],"mappings":"AAAA,SAA2CA,IAAI,QAAQ,oBAAmB;AAE1E,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,mBAAmBD;IAK9B,OAAOE,QAAQC,UAAyB,CAAC,CAAC,EAAE;QAC1C,OAAO,IAAIF,WAAWF,KAAKK,MAAM,CAACD,UAAU;YAAEA;QAAQ;IACxD;IAEAE,IAAIC,KAAa,EAAE;QACjB,OAAOL,WAAWC,OAAO,CAAC;YACxB,GAAG,IAAI,CAACK,KAAK,CAACJ,OAAO;YACrBK,WAAWF;QACb;IACF;IAEAG,IAAIH,KAAa,EAAE;QACjB,OAAOL,WAAWC,OAAO,CAAC;YACxB,GAAG,IAAI,CAACK,KAAK,CAACJ,OAAO;YACrBO,WAAWJ;QACb;IACF;IAEAK,OAAOA,MAAyB,EAAE;QAChC,OAAOV,WAAWC,OAAO,CAAC;YACxB,GAAG,IAAI,CAACK,KAAK,CAACJ,OAAO;YACrBS,SAASC;YACTF;QACF;IACF;IAEAC,QAAQA,OAAe,EAAE;QACvB,OAAOX,WAAWC,OAAO,CAAC;YACxB,GAAG,IAAI,CAACK,KAAK,CAACJ,OAAO;YACrBQ,QAAQE;YACRD;QACF;IACF;IAEAE,QAAQ;QACN,OAAO,IAAI,CAACH,MAAM,CAAC;IACrB;IAEAI,MAAM;QACJ,OAAO,IAAI,CAACJ,MAAM,CAAC;IACrB;IAEAK,OAAO;QACL,OAAO,IAAI,CAACL,MAAM,CAAC;IACrB;IAEAM,OAAO;QACL,OAAO,IAAI,CAACN,MAAM,CAAC;IACrB;IAEAO,OAAO;QACL,OAAO,IAAI,CAACP,MAAM,CAAC;IACrB;AACF"}
+{"mappings":"AAAA,SAEE,MACA,OACA,MACA,OACA,OACA,MACA,MACA,KACA,WACA,WACA,QACA,OACA,QACA,KACA,YAEK,WAAW;AAElB,SAAS,gBAAgB,WAAW;AAIpC,OAAO,MAAM,mBAAmB,SAG9B;CACA,OAAO,QAAQ,GAAG,QAAiB;AACjC,SAAO,IAAI,WAAW;GACpB,gBAAgB,QAAQ,CAAC,MAAM,GAAG,OAAO;GACzC,QAAQ,EAAE,OAAQ;EACnB;CACF;CAED,IAAIA,OAAe;AACjB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,UAAU,MAAM,CAAC;CACnE;CAED,IAAIA,OAAe;AACjB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,UAAU,MAAM,CAAC;CACnE;CAED,QAAQC,SAA0B;AAChC,SAAO,WAAW,QAChB,GAAG,KAAK,OAAO,QACf,aAAa,YAAY,WAAW,IAAI,OAAO,WAAW,QAAQ,CACnE;CACF;CAED,MAAMC,SAAgC;AACpC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,MAAM,QAAQ,CAAC;CACjE;CAED,IAAIC,SAA8B;AAChC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,QAAQ,CAAC;CAC/D;CAED,KAAKC,SAA+B;AAClC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,KAAK,QAAQ,CAAC;CAChE;CAED,KAAKC,SAA+B;AAClC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,KAAK,QAAQ,CAAC;CAChE;CAED,KAAKC,SAA+B;AAClC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,KAAK,QAAQ,CAAC;CAChE;CAED,MAAMC,SAAgC;AACpC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,MAAM,QAAQ,CAAC;CACjE;CAED,OAAOC,SAAiC;AACtC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,OAAO,QAAQ,CAAC;CAClE;CAED,KAAKC,SAA+B;AAClC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,KAAK,QAAQ,CAAC;CAChE;CAED,MAAMC,SAAgC;AACpC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,MAAM,QAAQ,CAAC;CACjE;CAED,KAAKC,SAA+B;AAClC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,KAAK,QAAQ,CAAC;CAChE;CAED,IAAIC,SAA8B;AAChC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,QAAQ,CAAC;CAC/D;AACF","names":["value: number","pattern: string | RegExp","options?: core.$ZodEmailParams","options?: core.$ZodURLParams","options?: core.$ZodIPv4Params","options?: core.$ZodIPv6Params","options?: core.$ZodUUIDParams","options?: core.$ZodEmojiParams","options?: core.$ZodNanoIDParams","options?: core.$ZodCUIDParams","options?: core.$ZodCUID2Params","options?: core.$ZodE164Params","options?: core.$ZodJWTParams"],"sources":["src/types/string.ts"],"sourcesContent":["import {\n  type core,\n  cuid,\n  cuid2,\n  e164,\n  email,\n  emoji,\n  ipv4,\n  ipv6,\n  jwt,\n  maxLength,\n  minLength,\n  nanoid,\n  regex,\n  string,\n  url,\n  uuid,\n  type ZodMiniString,\n} from '@zod/mini'\n\nimport { BaseType } from './base.ts'\n\ntype Check = core.CheckFn<string> | core.$ZodCheck<string>\n\nexport class StringType extends BaseType<\n  ZodMiniString<string>,\n  ZodMiniString<string>\n> {\n  static factory(...checks: Check[]) {\n    return new StringType({\n      encodedZodType: string().check(...checks),\n      params: { checks },\n    })\n  }\n\n  max(value: number) {\n    return StringType.factory(...this.params.checks, maxLength(value))\n  }\n\n  min(value: number) {\n    return StringType.factory(...this.params.checks, minLength(value))\n  }\n\n  pattern(pattern: string | RegExp) {\n    return StringType.factory(\n      ...this.params.checks,\n      regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern),\n    )\n  }\n\n  email(options?: core.$ZodEmailParams) {\n    return StringType.factory(...this.params.checks, email(options))\n  }\n\n  url(options?: core.$ZodURLParams) {\n    return StringType.factory(...this.params.checks, url(options))\n  }\n\n  ipv4(options?: core.$ZodIPv4Params) {\n    return StringType.factory(...this.params.checks, ipv4(options))\n  }\n\n  ipv6(options?: core.$ZodIPv6Params) {\n    return StringType.factory(...this.params.checks, ipv6(options))\n  }\n\n  uuid(options?: core.$ZodUUIDParams) {\n    return StringType.factory(...this.params.checks, uuid(options))\n  }\n\n  emoji(options?: core.$ZodEmojiParams) {\n    return StringType.factory(...this.params.checks, emoji(options))\n  }\n\n  nanoid(options?: core.$ZodNanoIDParams) {\n    return StringType.factory(...this.params.checks, nanoid(options))\n  }\n\n  cuid(options?: core.$ZodCUIDParams) {\n    return StringType.factory(...this.params.checks, cuid(options))\n  }\n\n  cuid2(options?: core.$ZodCUID2Params) {\n    return StringType.factory(...this.params.checks, cuid2(options))\n  }\n\n  e164(options?: core.$ZodE164Params) {\n    return StringType.factory(...this.params.checks, e164(options))\n  }\n\n  jwt(options?: core.$ZodJWTParams) {\n    return StringType.factory(...this.params.checks, jwt(options))\n  }\n}\n"],"version":3}

package/dist/types/temporal.js

@@ -1,57 +1,91 @@
-import { Type } from '@sinclair/typebox';
-import { Temporal } from 'temporal-polyfill';
+import { iso, regex, string } from "@zod/mini";
+import { Temporal } from "temporal-polyfill";
 import { CustomType, TransformType } from "./custom.js";
-const createTemporalTransformer = (type, decode = (value)=>Temporal[type].from(value))=>{
-    const encode = (value)=>value.toString({
-            calendarName: 'never',
-            smallestUnit: 'microsecond',
-            timeZoneName: 'never'
-        });
-    return {
-        decode,
-        encode
-    };
+const createTemporalTransformer = (type, decode = (value) => Temporal[type].from(value)) => {
+	const encode = (value) => value.toString({
+		calendarName: "never",
+		smallestUnit: "microsecond",
+		timeZoneName: "never"
+	});
+	return {
+		decode,
+		encode
+	};
 };
 export class PlainDateType extends TransformType {
-    static transformer = createTemporalTransformer('PlainDate');
-    static factory() {
-        return CustomType.factory(PlainDateType.transformer.decode, PlainDateType.transformer.encode, Type.String());
-    }
+	static transformer = createTemporalTransformer("PlainDate");
+	static factory() {
+		return CustomType.factory({
+			decode: PlainDateType.transformer.decode,
+			encode: PlainDateType.transformer.encode,
+			type: iso.date(),
+			error: "Invalid date format"
+		});
+	}
 }
 export class PlainDateTimeType extends TransformType {
-    static transformer = createTemporalTransformer('PlainDateTime');
-    _encode = PlainDateTimeType.transformer.encode;
-    static factory() {
-        return CustomType.factory(PlainDateTimeType.transformer.decode, PlainDateTimeType.transformer.encode, Type.String());
-    }
+	static transformer = createTemporalTransformer("PlainDateTime");
+	static factory() {
+		return CustomType.factory({
+			decode: PlainDateTimeType.transformer.decode,
+			encode: PlainDateTimeType.transformer.encode,
+			type: iso.datetime({ local: true }),
+			error: "Invalid datetime format"
+		});
+	}
 }
 export class ZonedDateTimeType extends TransformType {
-    static transformer = createTemporalTransformer('ZonedDateTime', (value)=>Temporal.Instant.from(value).toZonedDateTimeISO('UTC'));
-    static factory() {
-        return CustomType.factory(ZonedDateTimeType.transformer.decode, ZonedDateTimeType.transformer.encode, Type.String());
-    }
+	static transformer = createTemporalTransformer("ZonedDateTime", (value) => Temporal.Instant.from(value).toZonedDateTimeISO("UTC"));
+	static factory() {
+		return CustomType.factory({
+			decode: ZonedDateTimeType.transformer.decode,
+			encode: ZonedDateTimeType.transformer.encode,
+			type: iso.datetime({ local: true }),
+			error: "Invalid datetime format"
+		});
+	}
 }
 export class PlainTimeType extends TransformType {
-    static transformer = createTemporalTransformer('PlainTime');
-    static factory() {
-        return CustomType.factory(PlainTimeType.transformer.decode, PlainTimeType.transformer.encode, Type.String());
-    }
+	static transformer = createTemporalTransformer("PlainTime");
+	static factory() {
+		return CustomType.factory({
+			decode: PlainTimeType.transformer.decode,
+			encode: PlainTimeType.transformer.encode,
+			type: iso.time(),
+			error: "Invalid time format"
+		});
+	}
 }
 export class DurationType extends TransformType {
-    static transformer = createTemporalTransformer('Duration');
-    static factory() {
-        return CustomType.factory(DurationType.transformer.decode, DurationType.transformer.encode, Type.String());
-    }
+	static transformer = createTemporalTransformer("Duration");
+	static factory() {
+		return CustomType.factory({
+			decode: DurationType.transformer.decode,
+			encode: DurationType.transformer.encode,
+			type: iso.duration(),
+			error: "Invalid duration format"
+		});
+	}
 }
 export class PlainYearMonthType extends TransformType {
-    static transformer = createTemporalTransformer('PlainYearMonth');
-    static factory() {
-        return CustomType.factory(PlainYearMonthType.transformer.decode, PlainYearMonthType.transformer.encode, Type.String());
-    }
+	static transformer = createTemporalTransformer("PlainYearMonth");
+	static factory() {
+		return CustomType.factory({
+			decode: PlainYearMonthType.transformer.decode,
+			encode: PlainYearMonthType.transformer.encode,
+			type: string().check(regex(/^\d{4}-\d{2}$/)),
+			error: "Invalid year-month format"
+		});
+	}
 }
 export class PlainMonthDayType extends TransformType {
-    static transformer = createTemporalTransformer('PlainMonthDay');
-    static factory() {
-        return CustomType.factory(PlainMonthDayType.transformer.decode, PlainMonthDayType.transformer.encode, Type.String());
-    }
+	static transformer = createTemporalTransformer("PlainMonthDay");
+	static factory() {
+		return CustomType.factory({
+			decode: PlainMonthDayType.transformer.decode,
+			encode: PlainMonthDayType.transformer.encode,
+			type: string().check(regex(/^\d{2}-\d{2}$/)),
+			error: "Invalid month-day format"
+		});
+	}
 }

package/dist/types/temporal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/temporal.ts"],"sourcesContent":["import { type TString, Type } from '@sinclair/typebox'\nimport { Temporal } from 'temporal-polyfill'\nimport { CustomType, TransformType } from './custom.ts'\n\ntype Types = Exclude<\n  keyof typeof Temporal,\n  'Now' | 'Instant' | 'Calendar' | 'TimeZone'\n>\n\ntype TemporalTransformer<T extends Types> = {\n  decode: (value: string) => ReturnType<(typeof Temporal)[T]['from']>\n  encode: (value: ReturnType<(typeof Temporal)[T]['from']>) => string\n}\n\nconst createTemporalTransformer = <T extends Types>(\n  type: T,\n  decode = (value: string) => Temporal[type].from(value),\n) => {\n  const encode = (value: ReturnType<(typeof Temporal)[T]['from']>) =>\n    value.toString({\n      calendarName: 'never',\n      smallestUnit: 'microsecond',\n      timeZoneName: 'never',\n    })\n\n  return {\n    decode,\n    encode,\n  } as TemporalTransformer<T>\n}\n\nexport class PlainDateType extends TransformType<Temporal.PlainDate, TString> {\n  static readonly transformer = createTemporalTransformer('PlainDate')\n\n  static factory() {\n    return CustomType.factory(\n      PlainDateType.transformer.decode,\n      PlainDateType.transformer.encode,\n      Type.String(),\n    )\n  }\n}\n\nexport class PlainDateTimeType extends TransformType<\n  Temporal.PlainDateTime,\n  TString\n> {\n  static readonly transformer = createTemporalTransformer('PlainDateTime')\n  protected _encode = PlainDateTimeType.transformer.encode\n\n  static factory() {\n    return CustomType.factory(\n      PlainDateTimeType.transformer.decode,\n      PlainDateTimeType.transformer.encode,\n      Type.String(),\n    )\n  }\n}\n\nexport class ZonedDateTimeType extends TransformType<\n  Temporal.ZonedDateTime,\n  TString\n> {\n  static readonly transformer = createTemporalTransformer(\n    'ZonedDateTime',\n    (value) => Temporal.Instant.from(value).toZonedDateTimeISO('UTC'),\n  )\n\n  static factory() {\n    return CustomType.factory(\n      ZonedDateTimeType.transformer.decode,\n      ZonedDateTimeType.transformer.encode,\n      Type.String(),\n    )\n  }\n}\n\nexport class PlainTimeType extends TransformType<Temporal.PlainTime, TString> {\n  static readonly transformer = createTemporalTransformer('PlainTime')\n\n  static factory() {\n    return CustomType.factory(\n      PlainTimeType.transformer.decode,\n      PlainTimeType.transformer.encode,\n      Type.String(),\n    )\n  }\n}\n\nexport class DurationType extends TransformType<Temporal.Duration, TString> {\n  static readonly transformer = createTemporalTransformer('Duration')\n\n  static factory() {\n    return CustomType.factory(\n      DurationType.transformer.decode,\n      DurationType.transformer.encode,\n      Type.String(),\n    )\n  }\n}\n\nexport class PlainYearMonthType extends TransformType<\n  Temporal.PlainYearMonth,\n  TString\n> {\n  static readonly transformer = createTemporalTransformer('PlainYearMonth')\n\n  static factory() {\n    return CustomType.factory(\n      PlainYearMonthType.transformer.decode,\n      PlainYearMonthType.transformer.encode,\n      Type.String(),\n    )\n  }\n}\n\nexport class PlainMonthDayType extends TransformType<\n  Temporal.PlainMonthDay,\n  TString\n> {\n  static readonly transformer = createTemporalTransformer('PlainMonthDay')\n\n  static factory() {\n    return CustomType.factory(\n      PlainMonthDayType.transformer.decode,\n      PlainMonthDayType.transformer.encode,\n      Type.String(),\n    )\n  }\n}\n"],"names":["Type","Temporal","CustomType","TransformType","createTemporalTransformer","type","decode","value","from","encode","toString","calendarName","smallestUnit","timeZoneName","PlainDateType","transformer","factory","String","PlainDateTimeType","_encode","ZonedDateTimeType","Instant","toZonedDateTimeISO","PlainTimeType","DurationType","PlainYearMonthType","PlainMonthDayType"],"mappings":"AAAA,SAAuBA,IAAI,QAAQ,oBAAmB;AACtD,SAASC,QAAQ,QAAQ,oBAAmB;AAC5C,SAASC,UAAU,EAAEC,aAAa,QAAQ,cAAa;AAYvD,MAAMC,4BAA4B,CAChCC,MACAC,SAAS,CAACC,QAAkBN,QAAQ,CAACI,KAAK,CAACG,IAAI,CAACD,MAAM;IAEtD,MAAME,SAAS,CAACF,QACdA,MAAMG,QAAQ,CAAC;YACbC,cAAc;YACdC,cAAc;YACdC,cAAc;QAChB;IAEF,OAAO;QACLP;QACAG;IACF;AACF;AAEA,OAAO,MAAMK,sBAAsBX;IACjC,OAAgBY,cAAcX,0BAA0B,aAAY;IAEpE,OAAOY,UAAU;QACf,OAAOd,WAAWc,OAAO,CACvBF,cAAcC,WAAW,CAACT,MAAM,EAChCQ,cAAcC,WAAW,CAACN,MAAM,EAChCT,KAAKiB,MAAM;IAEf;AACF;AAEA,OAAO,MAAMC,0BAA0Bf;IAIrC,OAAgBY,cAAcX,0BAA0B,iBAAgB;IAC9De,UAAUD,kBAAkBH,WAAW,CAACN,MAAM,CAAA;IAExD,OAAOO,UAAU;QACf,OAAOd,WAAWc,OAAO,CACvBE,kBAAkBH,WAAW,CAACT,MAAM,EACpCY,kBAAkBH,WAAW,CAACN,MAAM,EACpCT,KAAKiB,MAAM;IAEf;AACF;AAEA,OAAO,MAAMG,0BAA0BjB;IAIrC,OAAgBY,cAAcX,0BAC5B,iBACA,CAACG,QAAUN,SAASoB,OAAO,CAACb,IAAI,CAACD,OAAOe,kBAAkB,CAAC,QAC5D;IAED,OAAON,UAAU;QACf,OAAOd,WAAWc,OAAO,CACvBI,kBAAkBL,WAAW,CAACT,MAAM,EACpCc,kBAAkBL,WAAW,CAACN,MAAM,EACpCT,KAAKiB,MAAM;IAEf;AACF;AAEA,OAAO,MAAMM,sBAAsBpB;IACjC,OAAgBY,cAAcX,0BAA0B,aAAY;IAEpE,OAAOY,UAAU;QACf,OAAOd,WAAWc,OAAO,CACvBO,cAAcR,WAAW,CAACT,MAAM,EAChCiB,cAAcR,WAAW,CAACN,MAAM,EAChCT,KAAKiB,MAAM;IAEf;AACF;AAEA,OAAO,MAAMO,qBAAqBrB;IAChC,OAAgBY,cAAcX,0BAA0B,YAAW;IAEnE,OAAOY,UAAU;QACf,OAAOd,WAAWc,OAAO,CACvBQ,aAAaT,WAAW,CAACT,MAAM,EAC/BkB,aAAaT,WAAW,CAACN,MAAM,EAC/BT,KAAKiB,MAAM;IAEf;AACF;AAEA,OAAO,MAAMQ,2BAA2BtB;IAItC,OAAgBY,cAAcX,0BAA0B,kBAAiB;IAEzE,OAAOY,UAAU;QACf,OAAOd,WAAWc,OAAO,CACvBS,mBAAmBV,WAAW,CAACT,MAAM,EACrCmB,mBAAmBV,WAAW,CAACN,MAAM,EACrCT,KAAKiB,MAAM;IAEf;AACF;AAEA,OAAO,MAAMS,0BAA0BvB;IAIrC,OAAgBY,cAAcX,0BAA0B,iBAAgB;IAExE,OAAOY,UAAU;QACf,OAAOd,WAAWc,OAAO,CACvBU,kBAAkBX,WAAW,CAACT,MAAM,EACpCoB,kBAAkBX,WAAW,CAACN,MAAM,EACpCT,KAAKiB,MAAM;IAEf;AACF"}
+{"mappings":"AAAA,SAAS,KAAK,OAAO,cAAkC,WAAW;AAClE,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,YAAY,qBAAqB,aAAa;AAYvD,MAAM,4BAA4B,CAChCA,MACA,SAAS,CAACC,UAAkB,SAAS,MAAM,KAAK,MAAM,KACnD;CACH,MAAM,SAAS,CAACC,UACd,MAAM,SAAS;EACb,cAAc;EACd,cAAc;EACd,cAAc;CACf,EAAC;AAEJ,QAAO;EACL;EACA;CACD;AACF;AAID,OAAO,MAAM,sBAAsB,cAGjC;CACA,OAAO,cAAc,0BAA0B,YAAY;CAE3D,OAAO,UAAU;AACf,SAAO,WAAW,QAAyC;GACzD,QAAQ,cAAc,YAAY;GAClC,QAAQ,cAAc,YAAY;GAClC,MAAM,IAAI,MAAM;GAChB,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,0BAA0B,cAGrC;CACA,OAAO,cAAc,0BAA0B,gBAAgB;CAE/D,OAAO,UAAU;AACf,SAAO,WAAW,QAA6C;GAC7D,QAAQ,kBAAkB,YAAY;GACtC,QAAQ,kBAAkB,YAAY;GACtC,MAAM,IAAI,SAAS,EAAE,OAAO,KAAM,EAAC;GACnC,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,0BAA0B,cAGrC;CACA,OAAO,cAAc,0BAA0B,iBAAiB,CAAC,UAC/D,SAAS,QAAQ,KAAK,MAAM,CAAC,mBAAmB,MAAM,CACvD;CAED,OAAO,UAAU;AACf,SAAO,WAAW,QAA6C;GAC7D,QAAQ,kBAAkB,YAAY;GACtC,QAAQ,kBAAkB,YAAY;GACtC,MAAM,IAAI,SAAS,EAAE,OAAO,KAAM,EAAC;GACnC,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,sBAAsB,cAGjC;CACA,OAAO,cAAc,0BAA0B,YAAY;CAE3D,OAAO,UAAU;AACf,SAAO,WAAW,QAAyC;GACzD,QAAQ,cAAc,YAAY;GAClC,QAAQ,cAAc,YAAY;GAClC,MAAM,IAAI,MAAM;GAChB,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,qBAAqB,cAGhC;CACA,OAAO,cAAc,0BAA0B,WAAW;CAE1D,OAAO,UAAU;AACf,SAAO,WAAW,QAAwC;GACxD,QAAQ,aAAa,YAAY;GACjC,QAAQ,aAAa,YAAY;GACjC,MAAM,IAAI,UAAU;GACpB,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,2BAA2B,cAGtC;CACA,OAAO,cAAc,0BAA0B,iBAAiB;CAEhE,OAAO,UAAU;AACf,SAAO,WAAW,QAA8C;GAC9D,QAAQ,mBAAmB,YAAY;GACvC,QAAQ,mBAAmB,YAAY;GACvC,MAAM,QAAQ,CAAC,MAAM,MAAM,gBAAgB,CAAC;GAC5C,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,0BAA0B,cAGrC;CACA,OAAO,cAAc,0BAA0B,gBAAgB;CAE/D,OAAO,UAAU;AACf,SAAO,WAAW,QAA6C;GAC7D,QAAQ,kBAAkB,YAAY;GACtC,QAAQ,kBAAkB,YAAY;GACtC,MAAM,QAAQ,CAAC,MAAM,MAAM,gBAAgB,CAAC;GAC5C,OAAO;EACR,EAAC;CACH;AACF","names":["type: T","value: string","value: ReturnType<(typeof Temporal)[T]['from']>"],"sources":["src/types/temporal.ts"],"sourcesContent":["import { iso, regex, string, type ZodMiniString } from '@zod/mini'\nimport { Temporal } from 'temporal-polyfill'\nimport { CustomType, TransformType } from './custom.ts'\n\ntype Types = Exclude<\n  keyof typeof Temporal,\n  'Now' | 'Instant' | 'Calendar' | 'TimeZone'\n>\n\ntype TemporalTransformer<T extends Types> = {\n  decode: (value: string) => ReturnType<(typeof Temporal)[T]['from']>\n  encode: (value: ReturnType<(typeof Temporal)[T]['from']>) => string\n}\n\nconst createTemporalTransformer = <T extends Types>(\n  type: T,\n  decode = (value: string) => Temporal[type].from(value),\n) => {\n  const encode = (value: ReturnType<(typeof Temporal)[T]['from']>) =>\n    value.toString({\n      calendarName: 'never',\n      smallestUnit: 'microsecond',\n      timeZoneName: 'never',\n    })\n\n  return {\n    decode,\n    encode,\n  } as TemporalTransformer<T>\n}\n\ntype EncodedType = ZodMiniString<string>\n\nexport class PlainDateType extends TransformType<\n  Temporal.PlainDate,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainDate')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainDate, EncodedType>({\n      decode: PlainDateType.transformer.decode,\n      encode: PlainDateType.transformer.encode,\n      type: iso.date(),\n      error: 'Invalid date format',\n    })\n  }\n}\n\nexport class PlainDateTimeType extends TransformType<\n  Temporal.PlainDateTime,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainDateTime')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainDateTime, EncodedType>({\n      decode: PlainDateTimeType.transformer.decode,\n      encode: PlainDateTimeType.transformer.encode,\n      type: iso.datetime({ local: true }),\n      error: 'Invalid datetime format',\n    })\n  }\n}\n\nexport class ZonedDateTimeType extends TransformType<\n  Temporal.ZonedDateTime,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('ZonedDateTime', (value) =>\n    Temporal.Instant.from(value).toZonedDateTimeISO('UTC'),\n  )\n\n  static factory() {\n    return CustomType.factory<Temporal.ZonedDateTime, EncodedType>({\n      decode: ZonedDateTimeType.transformer.decode,\n      encode: ZonedDateTimeType.transformer.encode,\n      type: iso.datetime({ local: true }),\n      error: 'Invalid datetime format',\n    })\n  }\n}\n\nexport class PlainTimeType extends TransformType<\n  Temporal.PlainTime,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainTime')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainTime, EncodedType>({\n      decode: PlainTimeType.transformer.decode,\n      encode: PlainTimeType.transformer.encode,\n      type: iso.time(),\n      error: 'Invalid time format',\n    })\n  }\n}\n\nexport class DurationType extends TransformType<\n  Temporal.Duration,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('Duration')\n\n  static factory() {\n    return CustomType.factory<Temporal.Duration, EncodedType>({\n      decode: DurationType.transformer.decode,\n      encode: DurationType.transformer.encode,\n      type: iso.duration(),\n      error: 'Invalid duration format',\n    })\n  }\n}\n\nexport class PlainYearMonthType extends TransformType<\n  Temporal.PlainYearMonth,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainYearMonth')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainYearMonth, EncodedType>({\n      decode: PlainYearMonthType.transformer.decode,\n      encode: PlainYearMonthType.transformer.encode,\n      type: string().check(regex(/^\\d{4}-\\d{2}$/)),\n      error: 'Invalid year-month format',\n    })\n  }\n}\n\nexport class PlainMonthDayType extends TransformType<\n  Temporal.PlainMonthDay,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainMonthDay')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainMonthDay, EncodedType>({\n      decode: PlainMonthDayType.transformer.decode,\n      encode: PlainMonthDayType.transformer.encode,\n      type: string().check(regex(/^\\d{2}-\\d{2}$/)),\n      error: 'Invalid month-day format',\n    })\n  }\n}\n"],"version":3}

package/dist/types/union.js

@@ -1,25 +1,33 @@
-import { Type } from '@sinclair/typebox';
-import { DiscriminatedUnion } from "../schemas/discriminated-union.js";
+import { discriminatedUnion, intersection, union } from "@zod/mini";
 import { BaseType } from "./base.js";
 export class UnionType extends BaseType {
-    static factory(...options) {
-        return new UnionType(Type.Union(options.map((t)=>t.schema)), {
-            options
-        });
-    }
+	static factory(...options) {
+		return new UnionType({
+			encodedZodType: union(options.map((t) => t.encodedZodType)),
+			decodedZodType: union(options.map((t) => t.decodedZodType)),
+			props: { options }
+		});
+	}
 }
 export class IntersactionType extends BaseType {
-    static factory(...options) {
-        return new IntersactionType(Type.Intersect(options.map((t)=>t.schema)), {
-            options
-        });
-    }
+	static factory(...options) {
+		const [first, second] = options;
+		return new IntersactionType({
+			encodedZodType: intersection(first.encodedZodType, second.encodedZodType),
+			decodedZodType: intersection(first.decodedZodType, second.decodedZodType),
+			props: { options }
+		});
+	}
 }
 export class DiscriminatedUnionType extends BaseType {
-    static factory(key, ...options) {
-        return new DiscriminatedUnionType(DiscriminatedUnion(key, options.map((t)=>t.schema)), {
-            key,
-            options
-        });
-    }
+	static factory(key, ...options) {
+		return new DiscriminatedUnionType({
+			encodedZodType: discriminatedUnion(options.map((t) => t.encodedZodType)),
+			decodedZodType: discriminatedUnion(options.map((t) => t.decodedZodType)),
+			props: {
+				key,
+				options
+			}
+		});
+	}
 }