@nmtjs/type 0.6.5 → 0.7.1

package/dist/index.js

@@ -1,44 +1,47 @@
+import * as zod from "@zod/mini";
 import { AnyType } from "./types/any.js";
 import { ArrayType } from "./types/array.js";
 import { BooleanType } from "./types/boolean.js";
 import { CustomType } from "./types/custom.js";
 import { DateType } from "./types/date.js";
-import { EnumType, ObjectEnumType } from "./types/enum.js";
+import { EnumType } from "./types/enum.js";
 import { LiteralType } from "./types/literal.js";
 import { NeverType } from "./types/never.js";
 import { BigIntType, IntegerType, NumberType } from "./types/number.js";
 import { extend, keyof, merge, ObjectType, omit, partial, pick, RecordType } from "./types/object.js";
 import { StringType } from "./types/string.js";
 import { DiscriminatedUnionType, IntersactionType, UnionType } from "./types/union.js";
-export * from "./schemas/nullable.js";
+zod.config(zod.core.locales.en());
+export { NeemataTypeError } from "./types/base.js";
 export { BaseType } from "./types/base.js";
-export { ArrayType, BooleanType, CustomType, DateType, EnumType, LiteralType, IntegerType, NumberType, ObjectType, StringType, IntersactionType, UnionType, AnyType, NeverType,  };
-export var type;
-(function(type) {
-    type.never = NeverType.factory;
-    type.boolean = BooleanType.factory;
-    type.string = StringType.factory;
-    type.number = NumberType.factory;
-    type.integer = IntegerType.factory;
-    type.bitint = BigIntType.factory;
-    type.literal = LiteralType.factory;
-    type.objectEnum = ObjectEnumType.factory;
-    type.arrayEnum = EnumType.factory;
-    type.date = DateType.factory;
-    type.array = ArrayType.factory;
-    type.record = RecordType.factory;
-    type.any = AnyType.factory;
-    type.or = UnionType.factory;
-    type.and = IntersactionType.factory;
-    type.discriminatedUnion = DiscriminatedUnionType.factory;
-    type.custom = CustomType.factory;
-    type.object = Object.assign(ObjectType.factory.bind(ObjectType), {
-        keyof,
-        partial,
-        merge,
-        omit,
-        extend,
-        pick
-    });
+export { ArrayType, BooleanType, CustomType, DateType, EnumType, LiteralType, IntegerType, NumberType, ObjectType, StringType, IntersactionType, UnionType, AnyType, NeverType, DiscriminatedUnionType, RecordType };
+export let type;
+(function(_type) {
+	const never = _type.never = NeverType.factory;
+	const boolean = _type.boolean = BooleanType.factory;
+	const string = _type.string = StringType.factory;
+	const number = _type.number = NumberType.factory;
+	const integer = _type.integer = IntegerType.factory;
+	const bitint = _type.bitint = BigIntType.factory;
+	const literal = _type.literal = LiteralType.factory;
+	const enumeration = _type.enumeration = EnumType.factory;
+	const date = _type.date = DateType.factory;
+	const array = _type.array = ArrayType.factory;
+	const record = _type.record = RecordType.factory;
+	const any = _type.any = AnyType.factory;
+	const or = _type.or = UnionType.factory;
+	const and = _type.and = IntersactionType.factory;
+	const union = _type.union = UnionType.factory;
+	const intersaction = _type.intersaction = IntersactionType.factory;
+	const discriminatedUnion = _type.discriminatedUnion = DiscriminatedUnionType.factory;
+	const custom = _type.custom = CustomType.factory;
+	const object = _type.object = Object.assign(ObjectType.factory.bind(ObjectType), {
+		keyof,
+		partial,
+		merge,
+		omit,
+		extend,
+		pick
+	});
 })(type || (type = {}));
-export { type as t };
+export { type as t, zod };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import type {\n  StaticInputDecode,\n  StaticInputEncode,\n  StaticOutputDecode,\n  StaticOutputEncode,\n} from './inference.ts'\nimport { AnyType } from './types/any.ts'\nimport { ArrayType } from './types/array.ts'\nimport type { BaseTypeAny } from './types/base.ts'\nimport { BooleanType } from './types/boolean.ts'\nimport { CustomType } from './types/custom.ts'\nimport { DateType } from './types/date.ts'\nimport { EnumType, ObjectEnumType } from './types/enum.ts'\nimport { LiteralType } from './types/literal.ts'\nimport { NeverType } from './types/never.ts'\nimport { BigIntType, IntegerType, NumberType } from './types/number.ts'\nimport {\n  extend,\n  keyof,\n  merge,\n  ObjectType,\n  omit,\n  partial,\n  pick,\n  RecordType,\n} from './types/object.ts'\nimport { StringType } from './types/string.ts'\nimport {\n  DiscriminatedUnionType,\n  IntersactionType,\n  UnionType,\n} from './types/union.ts'\n\nexport type { TSchema } from '@sinclair/typebox'\nexport * from './schemas/nullable.ts'\nexport { BaseType, type BaseTypeAny } from './types/base.ts'\nexport {\n  ArrayType,\n  BooleanType,\n  CustomType,\n  DateType,\n  EnumType,\n  LiteralType,\n  IntegerType,\n  NumberType,\n  ObjectType,\n  StringType,\n  IntersactionType,\n  UnionType,\n  AnyType,\n  NeverType,\n}\n\nexport namespace type {\n  export namespace infer {\n    export type decoded<T extends BaseTypeAny<any>> = StaticOutputDecode<\n      T['schema']\n    >\n    export type encoded<T extends BaseTypeAny<any>> = StaticOutputEncode<\n      T['schema']\n    >\n    export namespace input {\n      export type decoded<T extends BaseTypeAny<any>> = StaticInputDecode<\n        T['schema']\n      >\n      export type encoded<T extends BaseTypeAny<any>> = StaticInputEncode<\n        T['schema']\n      >\n    }\n  }\n\n  export const never = NeverType.factory\n  export const boolean = BooleanType.factory\n  export const string = StringType.factory\n  export const number = NumberType.factory\n  export const integer = IntegerType.factory\n  export const bitint = BigIntType.factory\n  export const literal = LiteralType.factory\n  export const objectEnum = ObjectEnumType.factory\n  export const arrayEnum = EnumType.factory\n  export const date = DateType.factory\n  export const array = ArrayType.factory\n  export const record = RecordType.factory\n  export const any = AnyType.factory\n  export const or = UnionType.factory\n  export const and = IntersactionType.factory\n  export const discriminatedUnion = DiscriminatedUnionType.factory\n  export const custom = CustomType.factory\n  export const object = Object.assign(ObjectType.factory.bind(ObjectType), {\n    keyof,\n    partial,\n    merge,\n    omit,\n    extend,\n    pick,\n  })\n}\n\nexport { type as t }\n"],"names":["AnyType","ArrayType","BooleanType","CustomType","DateType","EnumType","ObjectEnumType","LiteralType","NeverType","BigIntType","IntegerType","NumberType","extend","keyof","merge","ObjectType","omit","partial","pick","RecordType","StringType","DiscriminatedUnionType","IntersactionType","UnionType","BaseType","type","never","factory","boolean","string","number","integer","bitint","literal","objectEnum","arrayEnum","date","array","record","any","or","and","discriminatedUnion","custom","object","Object","assign","bind","t"],"mappings":"AAMA,SAASA,OAAO,QAAQ,iBAAgB;AACxC,SAASC,SAAS,QAAQ,mBAAkB;AAE5C,SAASC,WAAW,QAAQ,qBAAoB;AAChD,SAASC,UAAU,QAAQ,oBAAmB;AAC9C,SAASC,QAAQ,QAAQ,kBAAiB;AAC1C,SAASC,QAAQ,EAAEC,cAAc,QAAQ,kBAAiB;AAC1D,SAASC,WAAW,QAAQ,qBAAoB;AAChD,SAASC,SAAS,QAAQ,mBAAkB;AAC5C,SAASC,UAAU,EAAEC,WAAW,EAAEC,UAAU,QAAQ,oBAAmB;AACvE,SACEC,MAAM,EACNC,KAAK,EACLC,KAAK,EACLC,UAAU,EACVC,IAAI,EACJC,OAAO,EACPC,IAAI,EACJC,UAAU,QACL,oBAAmB;AAC1B,SAASC,UAAU,QAAQ,oBAAmB;AAC9C,SACEC,sBAAsB,EACtBC,gBAAgB,EAChBC,SAAS,QACJ,mBAAkB;AAGzB,cAAc,wBAAuB;AACrC,SAASC,QAAQ,QAA0B,kBAAiB;AAC5D,SACEvB,SAAS,EACTC,WAAW,EACXC,UAAU,EACVC,QAAQ,EACRC,QAAQ,EACRE,WAAW,EACXG,WAAW,EACXC,UAAU,EACVI,UAAU,EACVK,UAAU,EACVE,gBAAgB,EAChBC,SAAS,EACTvB,OAAO,EACPQ,SAAS,KACV;;UAEgBiB;SAkBFC,QAAQlB,UAAUmB,OAAO;SACzBC,UAAU1B,YAAYyB,OAAO;SAC7BE,SAAST,WAAWO,OAAO;SAC3BG,SAASnB,WAAWgB,OAAO;SAC3BI,UAAUrB,YAAYiB,OAAO;SAC7BK,SAASvB,WAAWkB,OAAO;SAC3BM,UAAU1B,YAAYoB,OAAO;SAC7BO,aAAa5B,eAAeqB,OAAO;SACnCQ,YAAY9B,SAASsB,OAAO;SAC5BS,OAAOhC,SAASuB,OAAO;SACvBU,QAAQpC,UAAU0B,OAAO;SACzBW,SAASnB,WAAWQ,OAAO;SAC3BY,MAAMvC,QAAQ2B,OAAO;SACrBa,KAAKjB,UAAUI,OAAO;SACtBc,MAAMnB,iBAAiBK,OAAO;SAC9Be,qBAAqBrB,uBAAuBM,OAAO;SACnDgB,SAASxC,WAAWwB,OAAO;SAC3BiB,SAASC,OAAOC,MAAM,CAAC/B,WAAWY,OAAO,CAACoB,IAAI,CAAChC,aAAa;QACvEF;QACAI;QACAH;QACAE;QACAJ;QACAM;IACF;AACF,GA3CiBO,SAAAA;AA6CjB,SAASA,QAAQuB,CAAJ,GAAO"}
+{"mappings":"AAAA,YAAY,SAAS,WAAW;AAChC,SAAS,eAAe,gBAAgB;AACxC,SAAS,iBAAiB,kBAAkB;AAE5C,SAAS,mBAAmB,oBAAoB;AAChD,SAAS,kBAAkB,mBAAmB;AAC9C,SAAS,gBAAgB,iBAAiB;AAC1C,SAAS,gBAAgB,iBAAiB;AAC1C,SAAS,mBAAmB,oBAAoB;AAChD,SAAS,iBAAiB,kBAAkB;AAC5C,SAAS,YAAY,aAAa,kBAAkB,mBAAmB;AACvE,SACE,QACA,OACA,OACA,YACA,MACA,SACA,MACA,kBACK,mBAAmB;AAC1B,SAAS,kBAAkB,mBAAmB;AAC9C,SACE,wBACA,kBACA,iBACK,kBAAkB;AAEzB,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC;AAEjC,SAAS,wBAAwB;AACjC,SAAS,gBAAkC;AAC3C,SACE,WACA,aACA,YACA,UACA,UACA,aACA,aACA,YACA,YACA,YACA,kBACA,WACA,SACA,WACA,wBACA;;AAGK;CAiBE,MAAM,sBAAQ,UAAU;CACxB,MAAM,0BAAU,YAAY;CAC5B,MAAM,wBAAS,WAAW;CAC1B,MAAM,wBAAS,WAAW;CAC1B,MAAM,0BAAU,YAAY;CAC5B,MAAM,wBAAS,WAAW;CAC1B,MAAM,0BAAU,YAAY;CAC5B,MAAM,kCAAc,SAAS;CAC7B,MAAM,oBAAO,SAAS;CACtB,MAAM,sBAAQ,UAAU;CACxB,MAAM,wBAAS,WAAW;CAC1B,MAAM,kBAAM,QAAQ;CACpB,MAAM,gBAAK,UAAU;CACrB,MAAM,kBAAM,iBAAiB;CAC7B,MAAM,sBAAQ,UAAU;CACxB,MAAM,oCAAe,iBAAiB;CACtC,MAAM,gDAAqB,uBAAuB;CAClD,MAAM,wBAAS,WAAW;CAC1B,MAAM,wBAAS,OAAO,OAAO,WAAW,QAAQ,KAAK,WAAW,EAAE;EACvE;EACA;EACA;EACA;EACA;EACA;CACD,EAAC;;AAGJ,SAAS,QAAQ,GAAG","names":[],"sources":["src/index.ts"],"sourcesContent":["import * as zod from '@zod/mini'\nimport { AnyType } from './types/any.ts'\nimport { ArrayType } from './types/array.ts'\nimport type { BaseTypeAny } from './types/base.ts'\nimport { BooleanType } from './types/boolean.ts'\nimport { CustomType } from './types/custom.ts'\nimport { DateType } from './types/date.ts'\nimport { EnumType } from './types/enum.ts'\nimport { LiteralType } from './types/literal.ts'\nimport { NeverType } from './types/never.ts'\nimport { BigIntType, IntegerType, NumberType } from './types/number.ts'\nimport {\n  extend,\n  keyof,\n  merge,\n  ObjectType,\n  omit,\n  partial,\n  pick,\n  RecordType,\n} from './types/object.ts'\nimport { StringType } from './types/string.ts'\nimport {\n  DiscriminatedUnionType,\n  IntersactionType,\n  UnionType,\n} from './types/union.ts'\n\nzod.config(zod.core.locales.en())\n\nexport { NeemataTypeError } from './types/base.ts'\nexport { BaseType, type BaseTypeAny } from './types/base.ts'\nexport {\n  ArrayType,\n  BooleanType,\n  CustomType,\n  DateType,\n  EnumType,\n  LiteralType,\n  IntegerType,\n  NumberType,\n  ObjectType,\n  StringType,\n  IntersactionType,\n  UnionType,\n  AnyType,\n  NeverType,\n  DiscriminatedUnionType,\n  RecordType,\n}\n\nexport namespace type {\n  export namespace infer {\n    export type decoded<T extends BaseTypeAny> =\n      T['decodedZodType']['_zod']['output']\n\n    export type encoded<T extends BaseTypeAny> =\n      T['encodedZodType']['_zod']['output']\n\n    export namespace input {\n      export type decoded<T extends BaseTypeAny> =\n        T['decodedZodType']['_zod']['input']\n\n      export type encoded<T extends BaseTypeAny> =\n        T['encodedZodType']['_zod']['input']\n    }\n  }\n\n  export const never = NeverType.factory\n  export const boolean = BooleanType.factory\n  export const string = StringType.factory\n  export const number = NumberType.factory\n  export const integer = IntegerType.factory\n  export const bitint = BigIntType.factory\n  export const literal = LiteralType.factory\n  export const enumeration = EnumType.factory\n  export const date = DateType.factory\n  export const array = ArrayType.factory\n  export const record = RecordType.factory\n  export const any = AnyType.factory\n  export const or = UnionType.factory\n  export const and = IntersactionType.factory\n  export const union = UnionType.factory\n  export const intersaction = IntersactionType.factory\n  export const discriminatedUnion = DiscriminatedUnionType.factory\n  export const custom = CustomType.factory\n  export const object = Object.assign(ObjectType.factory.bind(ObjectType), {\n    keyof,\n    partial,\n    merge,\n    omit,\n    extend,\n    pick,\n  })\n}\n\nexport { type as t, zod }\n"],"version":3}

package/dist/temporal.js

@@ -6,4 +6,3 @@ export const zonedDatetime = ZonedDateTimeType.factory;
 export const duration = DurationType.factory;
 export const plainYearMonth = PlainYearMonthType.factory;
 export const plainMonthDay = PlainMonthDayType.factory;
-export { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType,  };

package/dist/temporal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/temporal.ts"],"sourcesContent":["import {\n  DurationType,\n  PlainDateTimeType,\n  PlainDateType,\n  PlainMonthDayType,\n  PlainTimeType,\n  PlainYearMonthType,\n  ZonedDateTimeType,\n} from './types/temporal.ts'\n\nexport const plainDate = PlainDateType.factory\nexport const plainDatetime = PlainDateTimeType.factory\nexport const plainTime = PlainTimeType.factory\nexport const zonedDatetime = ZonedDateTimeType.factory\nexport const duration = DurationType.factory\nexport const plainYearMonth = PlainYearMonthType.factory\nexport const plainMonthDay = PlainMonthDayType.factory\n\nexport {\n  DurationType,\n  PlainDateTimeType,\n  PlainDateType,\n  PlainMonthDayType,\n  PlainTimeType,\n  PlainYearMonthType,\n  ZonedDateTimeType,\n}\n"],"names":["DurationType","PlainDateTimeType","PlainDateType","PlainMonthDayType","PlainTimeType","PlainYearMonthType","ZonedDateTimeType","plainDate","factory","plainDatetime","plainTime","zonedDatetime","duration","plainYearMonth","plainMonthDay"],"mappings":"AAAA,SACEA,YAAY,EACZC,iBAAiB,EACjBC,aAAa,EACbC,iBAAiB,EACjBC,aAAa,EACbC,kBAAkB,EAClBC,iBAAiB,QACZ,sBAAqB;AAE5B,OAAO,MAAMC,YAAYL,cAAcM,OAAO,CAAA;AAC9C,OAAO,MAAMC,gBAAgBR,kBAAkBO,OAAO,CAAA;AACtD,OAAO,MAAME,YAAYN,cAAcI,OAAO,CAAA;AAC9C,OAAO,MAAMG,gBAAgBL,kBAAkBE,OAAO,CAAA;AACtD,OAAO,MAAMI,WAAWZ,aAAaQ,OAAO,CAAA;AAC5C,OAAO,MAAMK,iBAAiBR,mBAAmBG,OAAO,CAAA;AACxD,OAAO,MAAMM,gBAAgBX,kBAAkBK,OAAO,CAAA;AAEtD,SACER,YAAY,EACZC,iBAAiB,EACjBC,aAAa,EACbC,iBAAiB,EACjBC,aAAa,EACbC,kBAAkB,EAClBC,iBAAiB,KAClB"}
+{"mappings":"AAAA,SACE,cACA,mBACA,eACA,mBACA,eACA,oBACA,yBACK,qBAAqB;AAE5B,OAAO,MAAM,YAAY,cAAc;AACvC,OAAO,MAAM,gBAAgB,kBAAkB;AAC/C,OAAO,MAAM,YAAY,cAAc;AACvC,OAAO,MAAM,gBAAgB,kBAAkB;AAC/C,OAAO,MAAM,WAAW,aAAa;AACrC,OAAO,MAAM,iBAAiB,mBAAmB;AACjD,OAAO,MAAM,gBAAgB,kBAAkB","names":[],"sources":["src/temporal.ts"],"sourcesContent":["import {\n  DurationType,\n  PlainDateTimeType,\n  PlainDateType,\n  PlainMonthDayType,\n  PlainTimeType,\n  PlainYearMonthType,\n  ZonedDateTimeType,\n} from './types/temporal.ts'\n\nexport const plainDate = PlainDateType.factory\nexport const plainDatetime = PlainDateTimeType.factory\nexport const plainTime = PlainTimeType.factory\nexport const zonedDatetime = ZonedDateTimeType.factory\nexport const duration = DurationType.factory\nexport const plainYearMonth = PlainYearMonthType.factory\nexport const plainMonthDay = PlainMonthDayType.factory\n\nexport type {\n  DurationType,\n  PlainDateTimeType,\n  PlainDateType,\n  PlainMonthDayType,\n  PlainTimeType,\n  PlainYearMonthType,\n  ZonedDateTimeType,\n}\n"],"version":3}

package/dist/types/any.js

@@ -1,7 +1,7 @@
-import { Type } from '@sinclair/typebox';
+import { any } from "@zod/mini";
 import { BaseType } from "./base.js";
 export class AnyType extends BaseType {
-    static factory() {
-        return new AnyType(Type.Any());
-    }
+	static factory() {
+		return new AnyType({ encodedZodType: any() });
+	}
 }

package/dist/types/any.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/any.ts"],"sourcesContent":["import { type TAny, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class AnyType extends BaseType<TAny, {}, any> {\n  static factory() {\n    return new AnyType(Type.Any())\n  }\n}\n"],"names":["Type","BaseType","AnyType","factory","Any"],"mappings":"AAAA,SAAoBA,IAAI,QAAQ,oBAAmB;AACnD,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,gBAAgBD;IAC3B,OAAOE,UAAU;QACf,OAAO,IAAID,QAAQF,KAAKI,GAAG;IAC7B;AACF"}
+{"mappings":"AAAA,SAAS,WAA4B,WAAW;AAChD,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,gBAAgB,SAAqB;CAChD,OAAO,UAAU;AACf,SAAO,IAAI,QAAQ,EACjB,gBAAgB,KAAK,CACtB;CACF;AACF","names":[],"sources":["src/types/any.ts"],"sourcesContent":["import { any, type ZodMiniAny } from '@zod/mini'\nimport { BaseType } from './base.ts'\n\nexport class AnyType extends BaseType<ZodMiniAny> {\n  static factory() {\n    return new AnyType({\n      encodedZodType: any(),\n    })\n  }\n}\n"],"version":3}

package/dist/types/array.js

@@ -1,26 +1,24 @@
-import { Type } from '@sinclair/typebox';
+import { array, length, maxLength, minLength } from "@zod/mini";
 import { BaseType } from "./base.js";
 export class ArrayType extends BaseType {
-    static factory(element, options = {}) {
-        return new ArrayType(Type.Array(element.schema, options));
-    }
-    min(value) {
-        return ArrayType.factory(this.props.element, {
-            ...this.props.options,
-            minItems: value
-        });
-    }
-    max(value) {
-        return ArrayType.factory(this.props.element, {
-            ...this.props.options,
-            maxItems: value
-        });
-    }
-    length(value) {
-        return ArrayType.factory(this.props.element, {
-            ...this.props.options,
-            minItems: value,
-            maxItems: value
-        });
-    }
+	static factory(element, ...checks) {
+		return new ArrayType({
+			encodedZodType: array(element.encodedZodType).check(...checks),
+			decodedZodType: array(element.decodedZodType).check(...checks),
+			params: { checks },
+			props: { element }
+		});
+	}
+	min(value) {
+		const check = minLength(value);
+		return ArrayType.factory(this.props.element, ...this.params.checks, check);
+	}
+	max(value) {
+		const check = maxLength(value);
+		return ArrayType.factory(this.props.element, ...this.params.checks, check);
+	}
+	length(value) {
+		const check = length(value);
+		return ArrayType.factory(this.props.element, ...this.params.checks, check);
+	}
 }

package/dist/types/array.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/array.ts"],"sourcesContent":["import {\n  type ArrayOptions,\n  type StaticDecode,\n  type TArray,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class ArrayType<T extends BaseType = BaseType> extends BaseType<\n  TArray<T['schema']>,\n  { element: T; options: ArrayOptions }\n> {\n  static factory<T extends BaseType>(element: T, options: ArrayOptions = {}) {\n    return new ArrayType<T>(Type.Array(element.schema, options))\n  }\n\n  min(value: number) {\n    return ArrayType.factory(this.props.element, {\n      ...this.props.options,\n      minItems: value,\n    })\n  }\n\n  max(value: number) {\n    return ArrayType.factory(this.props.element, {\n      ...this.props.options,\n      maxItems: value,\n    })\n  }\n\n  length(value: number) {\n    return ArrayType.factory(this.props.element, {\n      ...this.props.options,\n      minItems: value,\n      maxItems: value,\n    })\n  }\n}\n"],"names":["Type","BaseType","ArrayType","factory","element","options","Array","schema","min","value","props","minItems","max","maxItems","length"],"mappings":"AAAA,SAIEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,kBAAiDD;IAI5D,OAAOE,QAA4BC,OAAU,EAAEC,UAAwB,CAAC,CAAC,EAAE;QACzE,OAAO,IAAIH,UAAaF,KAAKM,KAAK,CAACF,QAAQG,MAAM,EAAEF;IACrD;IAEAG,IAAIC,KAAa,EAAE;QACjB,OAAOP,UAAUC,OAAO,CAAC,IAAI,CAACO,KAAK,CAACN,OAAO,EAAE;YAC3C,GAAG,IAAI,CAACM,KAAK,CAACL,OAAO;YACrBM,UAAUF;QACZ;IACF;IAEAG,IAAIH,KAAa,EAAE;QACjB,OAAOP,UAAUC,OAAO,CAAC,IAAI,CAACO,KAAK,CAACN,OAAO,EAAE;YAC3C,GAAG,IAAI,CAACM,KAAK,CAACL,OAAO;YACrBQ,UAAUJ;QACZ;IACF;IAEAK,OAAOL,KAAa,EAAE;QACpB,OAAOP,UAAUC,OAAO,CAAC,IAAI,CAACO,KAAK,CAACN,OAAO,EAAE;YAC3C,GAAG,IAAI,CAACM,KAAK,CAACL,OAAO;YACrBM,UAAUF;YACVI,UAAUJ;QACZ;IACF;AACF"}
+{"mappings":"AAAA,SACE,OAEA,QACA,WACA,iBAEK,WAAW;AAClB,SAAS,gBAAgB,WAAW;AAIpC,OAAO,MAAM,kBAAiD,SAI5D;CACA,OAAO,QAA4BA,SAAY,GAAG,QAAiB;AACjE,SAAO,IAAI,UAAa;GACtB,gBAAgB,MAAM,QAAQ,eAAe,CAAC,MAAM,GAAG,OAAO;GAC9D,gBAAgB,MAAM,QAAQ,eAAe,CAAC,MAAM,GAAG,OAAO;GAC9D,QAAQ,EAAE,OAAQ;GAClB,OAAO,EAAE,QAAS;EACnB;CACF;CAED,IAAIC,OAAe;EACjB,MAAM,QAAQ,UAAU,MAAM;AAC9B,SAAO,UAAU,QACf,KAAK,MAAM,SACX,GAAG,KAAK,OAAO,QACf,MACD;CACF;CAED,IAAIA,OAAe;EACjB,MAAM,QAAQ,UAAU,MAAM;AAC9B,SAAO,UAAU,QACf,KAAK,MAAM,SACX,GAAG,KAAK,OAAO,QACf,MACD;CACF;CAED,OAAOA,OAAe;EACpB,MAAM,QAAQ,OAAO,MAAM;AAC3B,SAAO,UAAU,QACf,KAAK,MAAM,SACX,GAAG,KAAK,OAAO,QACf,MACD;CACF;AACF","names":["element: T","value: number"],"sources":["src/types/array.ts"],"sourcesContent":["import {\n  array,\n  type core,\n  length,\n  maxLength,\n  minLength,\n  type ZodMiniArray,\n} from '@zod/mini'\nimport { BaseType } from './base.ts'\n\ntype Check = core.CheckFn<any[]> | core.$ZodCheck<any[]>\n\nexport class ArrayType<T extends BaseType = BaseType> extends BaseType<\n  ZodMiniArray<T['encodedZodType']>,\n  ZodMiniArray<T['decodedZodType']>,\n  { element: T }\n> {\n  static factory<T extends BaseType>(element: T, ...checks: Check[]) {\n    return new ArrayType<T>({\n      encodedZodType: array(element.encodedZodType).check(...checks),\n      decodedZodType: array(element.decodedZodType).check(...checks),\n      params: { checks },\n      props: { element },\n    })\n  }\n\n  min(value: number) {\n    const check = minLength(value)\n    return ArrayType.factory<T>(\n      this.props.element,\n      ...this.params.checks,\n      check,\n    )\n  }\n\n  max(value: number) {\n    const check = maxLength(value)\n    return ArrayType.factory<T>(\n      this.props.element,\n      ...this.params.checks,\n      check,\n    )\n  }\n\n  length(value: number) {\n    const check = length(value)\n    return ArrayType.factory<T>(\n      this.props.element,\n      ...this.params.checks,\n      check,\n    )\n  }\n}\n"],"version":3}

package/dist/types/base.js

@@ -1,74 +1,73 @@
-import { Optional } from '@sinclair/typebox';
-import { Default } from "../schemas/default.js";
-import { Nullable } from "../schemas/nullable.js";
+import { _default, core, nullable, optional, registry } from "@zod/mini";
+export const typesRegistry = registry();
+export const NeemataTypeError = core.$ZodError;
 export class BaseType {
-    schema;
-    props;
-    params;
-    constructor(schema, props = {}, params = {}){
-        const { hasDefault = false, nullable = false, optional = false } = params;
-        this.schema = schema;
-        this.props = props;
-        this.params = {
-            hasDefault,
-            nullable,
-            optional
-        };
-    }
-    optional() {
-        return OptionalType.factory(this);
-    }
-    nullable() {
-        return NullableType.factory(this);
-    }
-    nullish() {
-        return this.nullable().optional();
-    }
-    default(value) {
-        return DefaultType.factory(this, this.params.encode?.(value) ?? value);
-    }
-    description(description) {
-        const ThisConstructor = this.constructor;
-        return new ThisConstructor({
-            ...this.schema,
-            description
-        }, this.props, this.params);
-    }
-    examples(...examples) {
-        const ThisConstructor = this.constructor;
-        return new ThisConstructor({
-            ...this.schema,
-            examples
-        }, this.props, this.params);
-    }
+	encodedZodType;
+	decodedZodType;
+	props;
+	params;
+	constructor({ encodedZodType, decodedZodType = encodedZodType, props = {}, params = {} }) {
+		this.encodedZodType = encodedZodType;
+		this.decodedZodType = decodedZodType;
+		this.props = props;
+		this.params = Object.assign({ checks: [] }, params);
+	}
+	optional() {
+		return OptionalType.factory(this);
+	}
+	nullable() {
+		return NullableType.factory(this);
+	}
+	nullish() {
+		return this.nullable().optional();
+	}
+	default(value) {
+		return DefaultType.factory(this, value);
+	}
+	title(title) {
+		return this.meta({ title });
+	}
+	description(description) {
+		return this.meta({ description });
+	}
+	examples(...examples) {
+		return this.meta({ examples: this.params.encode ? examples.map(this.params.encode) : examples });
+	}
+	meta(newMetadata) {
+		const metadata = typesRegistry.get(this.encodedZodType) ?? {};
+		Object.assign(metadata, newMetadata);
+		typesRegistry.add(this.encodedZodType, metadata);
+		return this;
+	}
+	encode(data) {
+		return this.encodedZodType.parse(data, { reportInput: true });
+	}
+	decode(data) {
+		return this.decodedZodType.parse(data, { reportInput: true });
+	}
 }
 export class OptionalType extends BaseType {
-    static factory(type) {
-        return new OptionalType(Optional(type.schema), {
-            inner: type
-        }, {
-            ...type.params,
-            optional: true
-        });
-    }
+	static factory(type) {
+		return new OptionalType({
+			encodedZodType: optional(type.encodedZodType),
+			props: { inner: type }
+		});
+	}
 }
 export class NullableType extends BaseType {
-    static factory(type) {
-        return new NullableType(Nullable(type.schema), {
-            inner: type
-        }, {
-            ...type.params,
-            nullable: true
-        });
-    }
+	static factory(type) {
+		return new NullableType({
+			encodedZodType: nullable(type.encodedZodType),
+			props: { inner: type }
+		});
+	}
 }
 export class DefaultType extends BaseType {
-    static factory(type, defaultValue) {
-        return new DefaultType(Default(Optional(type.schema), defaultValue), {
-            inner: type
-        }, {
-            ...type.params,
-            hasDefault: true
-        });
-    }
+	static factory(type, defaultValue) {
+		return new DefaultType({
+			encodedZodType: _default(type.encodedZodType, type.params.encode?.(defaultValue) ?? defaultValue),
+			decodedZodType: _default(type.decodedZodType, defaultValue),
+			props: { inner: type }
+		});
+	}
 }

package/dist/types/base.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/base.ts"],"sourcesContent":["import { Optional, type TOptional, type TSchema } from '@sinclair/typebox'\nimport { Default, type TDefault } from '../schemas/default.ts'\nimport { Nullable, type TNullable } from '../schemas/nullable.ts'\n\nexport type TypeProps = Record<string, any>\n\nexport type TypeParams = {\n  optional?: boolean\n  nullable?: boolean\n  hasDefault?: boolean\n  encode?: (value: any) => any\n}\n\nexport type DefaultTypeParams = {\n  optional: false\n  nullable: false\n  hasDefault: false\n  encode?: TypeParams['encode']\n}\n\nexport type BaseTypeAny<T extends TSchema = TSchema> = BaseType<\n  T,\n  TypeProps,\n  any\n>\n\nexport abstract class BaseType<\n  Schema extends TSchema = TSchema,\n  Props extends TypeProps = TypeProps,\n  ValueType = unknown,\n> {\n  readonly schema: Schema\n  readonly props: Props\n  readonly params: TypeParams\n\n  constructor(\n    schema: Schema,\n    props: Props = {} as Props,\n    params: TypeParams = {} as TypeParams,\n  ) {\n    const { hasDefault = false, nullable = false, optional = false } = params\n    this.schema = schema\n\n    this.props = props\n    this.params = {\n      hasDefault,\n      nullable,\n      optional,\n    } as TypeParams\n  }\n\n  optional(): OptionalType<BaseType<Schema, Props>, ValueType> {\n    return OptionalType.factory(this) as any\n  }\n\n  nullable(): NullableType<BaseType<Schema, Props>, ValueType> {\n    return NullableType.factory(this) as any\n  }\n\n  nullish() {\n    return this.nullable().optional()\n  }\n\n  default(value: ValueType): DefaultType<BaseType<Schema, Props>, ValueType> {\n    return DefaultType.factory(\n      this,\n      this.params.encode?.(value) ?? value,\n    ) as any\n  }\n\n  description(description: string): BaseType<Schema, Props, ValueType> {\n    const ThisConstructor = this.constructor as any\n    return new ThisConstructor(\n      {\n        ...this.schema,\n        description,\n      },\n      this.props,\n      this.params,\n    ) as any\n  }\n\n  examples(...examples: ValueType[]): BaseType<Schema, Props, ValueType> {\n    const ThisConstructor = this.constructor as any\n    return new ThisConstructor(\n      {\n        ...this.schema,\n        examples,\n      },\n      this.props,\n      this.params,\n    ) as any\n  }\n}\n\nexport class OptionalType<\n  Type extends BaseTypeAny = BaseTypeAny,\n  ValueType = unknown,\n> extends BaseType<TOptional<Type['schema']>, { inner: Type }, ValueType> {\n  static factory<T extends BaseTypeAny>(type: T) {\n    return new OptionalType<T>(Optional(type.schema) as any, { inner: type }, {\n      ...type.params,\n      optional: true,\n    } as any)\n  }\n}\n\nexport class NullableType<\n  Type extends BaseTypeAny<any> = BaseTypeAny<any>,\n  ValueType = unknown,\n> extends BaseType<\n  TNullable<Type['schema']>,\n  { inner: Type },\n  ValueType | null\n> {\n  static factory<T extends BaseTypeAny<any>>(type: T) {\n    return new NullableType<T>(Nullable(type.schema), { inner: type }, {\n      ...type.params,\n      nullable: true,\n    } as any)\n  }\n}\n\nexport class DefaultType<\n  Type extends BaseTypeAny = BaseTypeAny,\n  ValueType = unknown,\n> extends BaseType<\n  TDefault<TOptional<Type['schema']>>,\n  { inner: Type },\n  ValueType\n> {\n  static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {\n    return new DefaultType<T>(\n      Default(Optional(type.schema), defaultValue) as any,\n      { inner: type },\n      { ...type.params, hasDefault: true } as any,\n    )\n  }\n}\n"],"names":["Optional","Default","Nullable","BaseType","schema","props","params","constructor","hasDefault","nullable","optional","OptionalType","factory","NullableType","nullish","default","value","DefaultType","encode","description","ThisConstructor","examples","type","inner","defaultValue"],"mappings":"AAAA,SAASA,QAAQ,QAAsC,oBAAmB;AAC1E,SAASC,OAAO,QAAuB,wBAAuB;AAC9D,SAASC,QAAQ,QAAwB,yBAAwB;AAwBjE,OAAO,MAAeC;IAKXC,OAAc;IACdC,MAAY;IACZC,OAAkB;IAE3BC,YACEH,MAAc,EACdC,QAAe,CAAC,CAAU,EAC1BC,SAAqB,CAAC,CAAe,CACrC;QACA,MAAM,EAAEE,aAAa,KAAK,EAAEC,WAAW,KAAK,EAAEC,WAAW,KAAK,EAAE,GAAGJ;QACnE,IAAI,CAACF,MAAM,GAAGA;QAEd,IAAI,CAACC,KAAK,GAAGA;QACb,IAAI,CAACC,MAAM,GAAG;YACZE;YACAC;YACAC;QACF;IACF;IAEAA,WAA6D;QAC3D,OAAOC,aAAaC,OAAO,CAAC,IAAI;IAClC;IAEAH,WAA6D;QAC3D,OAAOI,aAAaD,OAAO,CAAC,IAAI;IAClC;IAEAE,UAAU;QACR,OAAO,IAAI,CAACL,QAAQ,GAAGC,QAAQ;IACjC;IAEAK,QAAQC,KAAgB,EAAmD;QACzE,OAAOC,YAAYL,OAAO,CACxB,IAAI,EACJ,IAAI,CAACN,MAAM,CAACY,MAAM,GAAGF,UAAUA;IAEnC;IAEAG,YAAYA,WAAmB,EAAsC;QACnE,MAAMC,kBAAkB,IAAI,CAACb,WAAW;QACxC,OAAO,IAAIa,gBACT;YACE,GAAG,IAAI,CAAChB,MAAM;YACde;QACF,GACA,IAAI,CAACd,KAAK,EACV,IAAI,CAACC,MAAM;IAEf;IAEAe,SAAS,GAAGA,QAAqB,EAAsC;QACrE,MAAMD,kBAAkB,IAAI,CAACb,WAAW;QACxC,OAAO,IAAIa,gBACT;YACE,GAAG,IAAI,CAAChB,MAAM;YACdiB;QACF,GACA,IAAI,CAAChB,KAAK,EACV,IAAI,CAACC,MAAM;IAEf;AACF;AAEA,OAAO,MAAMK,qBAGHR;IACR,OAAOS,QAA+BU,IAAO,EAAE;QAC7C,OAAO,IAAIX,aAAgBX,SAASsB,KAAKlB,MAAM,GAAU;YAAEmB,OAAOD;QAAK,GAAG;YACxE,GAAGA,KAAKhB,MAAM;YACdI,UAAU;QACZ;IACF;AACF;AAEA,OAAO,MAAMG,qBAGHV;IAKR,OAAOS,QAAoCU,IAAO,EAAE;QAClD,OAAO,IAAIT,aAAgBX,SAASoB,KAAKlB,MAAM,GAAG;YAAEmB,OAAOD;QAAK,GAAG;YACjE,GAAGA,KAAKhB,MAAM;YACdG,UAAU;QACZ;IACF;AACF;AAEA,OAAO,MAAMQ,oBAGHd;IAKR,OAAOS,QAAoCU,IAAO,EAAEE,YAAiB,EAAE;QACrE,OAAO,IAAIP,YACThB,QAAQD,SAASsB,KAAKlB,MAAM,GAAGoB,eAC/B;YAAED,OAAOD;QAAK,GACd;YAAE,GAAGA,KAAKhB,MAAM;YAAEE,YAAY;QAAK;IAEvC;AACF"}
+{"mappings":"AAAA,SACE,UACA,MACA,UACA,UACA,gBAmBK,WAAW;AAkDlB,OAAO,MAAM,gBAAgB,UAAwB;AAErD,OAAO,MAAM,mBAAmB,KAAK;AAGrC,OAAO,MAAe,SAIpB;CACA,AAAS;CACT,AAAS;CACT,AAAS;CACT,AAAS;CAET,YAAY,EACV,gBACA,iBAAiB,gBACjB,QAAQ,CAAE,GACV,SAAS,CAAE,GAMZ,EAAE;AACD,OAAK,iBAAiB;AACtB,OAAK,iBAAiB;AAEtB,OAAK,QAAQ;AACb,OAAK,SAAS,OAAO,OAAO,EAAE,QAAQ,CAAE,EAAE,GAAE,OAAO;CACpD;CAED,WAA+B;AAC7B,SAAO,aAAa,QAAQ,KAAK;CAClC;CAED,WAA+B;AAC7B,SAAO,aAAa,QAAQ,KAAK;CAClC;CAED,UAAU;AACR,SAAO,KAAK,UAAU,CAAC,UAAU;CAClC;CAED,QAAQA,OAAmE;AACzE,SAAO,YAAY,QAAQ,MAAM,MAAM;CACxC;CAED,MAAMC,OAAqB;AACzB,SAAO,KAAK,KAAK,EAAE,MAAO,EAAC;CAC5B;CAED,YAAYC,aAA2B;AACrC,SAAO,KAAK,KAAK,EAAE,YAAa,EAAC;CAClC;CAED,SAAS,GAAG,UAA2D;AACrE,SAAO,KAAK,KAAK,EACf,UAAU,KAAK,OAAO,SAClB,SAAS,IAAI,KAAK,OAAO,OAAO,GAChC,SACL,EAAC;CACH;CAED,KAAKC,aAAiC;EACpC,MAAM,WAAW,cAAc,IAAI,KAAK,eAAe,IAAI,CAAE;AAC7D,SAAO,OAAO,UAAU,YAAY;AACpC,gBAAc,IAAI,KAAK,gBAAgB,SAAS;AAChD,SAAO;CACR;CAED,OACEC,MAC0C;AAC1C,SAAO,KAAK,eAAe,MAAM,MAAM,EAAE,aAAa,KAAM,EAAC;CAC9D;CAED,OACEC,MAC0C;AAC1C,SAAO,KAAK,eAAe,MAAM,MAAM,EAAE,aAAa,KAAM,EAAC;CAC9D;AACF;AAED,OAAO,MAAM,qBAEH,SAIR;CACA,OAAO,QAA+BC,MAAS;AAC7C,SAAO,IAAI,aAAgB;GACzB,gBAAgB,SAAS,KAAK,eAAe;GAC7C,OAAO,EAAE,OAAO,KAAM;EACvB;CACF;AACF;AAED,OAAO,MAAM,qBAEH,SAIR;CACA,OAAO,QAAoCA,MAAS;AAClD,SAAO,IAAI,aAAgB;GACzB,gBAAgB,SAAS,KAAK,eAAe;GAC7C,OAAO,EAAE,OAAO,KAAM;EACvB;CACF;AACF;AAED,OAAO,MAAM,oBAEH,SAIR;CACA,OAAO,QAAoCA,MAASC,cAAmB;AACrE,SAAO,IAAI,YAAe;GACxB,gBAAgB,SACd,KAAK,gBACL,KAAK,OAAO,SAAS,aAAa,IAAI,aACvC;GACD,gBAAgB,SAAS,KAAK,gBAAgB,aAAa;GAC3D,OAAO,EAAE,OAAO,KAAM;EACvB;CACF;AACF","names":["value: this['encodedZodType']['_zod']['input']","title: string","description: string","newMetadata: TypeMetadata","data: this['encodedZodType']['_zod']['input']","data: this['decodedZodType']['_zod']['input']","type: T","defaultValue: any"],"sources":["src/types/base.ts"],"sourcesContent":["import {\n  _default,\n  core,\n  nullable,\n  optional,\n  registry,\n  type ZodMiniAny,\n  type ZodMiniArray,\n  type ZodMiniBoolean,\n  type ZodMiniDefault,\n  type ZodMiniEnum,\n  type ZodMiniInterface,\n  type ZodMiniIntersection,\n  type ZodMiniLiteral,\n  type ZodMiniNever,\n  type ZodMiniNullable,\n  type ZodMiniNumber,\n  type ZodMiniObject,\n  type ZodMiniOptional,\n  type ZodMiniPipe,\n  type ZodMiniRecord,\n  type ZodMiniString,\n  type ZodMiniType,\n  type ZodMiniUnion,\n} from '@zod/mini'\n\nexport type PrimitiveValueType = string | number | boolean | null\n\nexport type SimpleZodType =\n  | ZodMiniNever\n  | ZodMiniDefault\n  | ZodMiniNullable\n  | ZodMiniOptional\n  | ZodMiniString\n  | ZodMiniObject\n  | ZodMiniAny\n  | ZodMiniArray\n  | ZodMiniBoolean\n  | ZodMiniNumber\n  | ZodMiniEnum<any>\n  | ZodMiniLiteral<PrimitiveValueType>\n  | ZodMiniUnion\n  | ZodMiniIntersection\n  | ZodMiniInterface\n  | ZodMiniRecord\n  | ZodMiniPipe\n\nexport type ZodType = SimpleZodType | ZodMiniType\n\nexport type TypeProps = Record<string, any>\n\nexport type TypeMetadata<T = any> = {\n  id?: string\n  description?: string\n  examples?: T[]\n  title?: string\n}\n\nexport type TypeParams = {\n  encode?: (value: any) => any\n  metadata?: TypeMetadata\n  checks: Array<core.CheckFn<any> | core.$ZodCheck<any>>\n}\n\nexport type DefaultTypeParams = {\n  encode?: TypeParams['encode']\n  metadata?: TypeMetadata\n}\n\nexport type BaseTypeAny<\n  EncodedZodType extends SimpleZodType = SimpleZodType,\n  DecodedZodType extends ZodType = ZodMiniType,\n> = BaseType<EncodedZodType, DecodedZodType, TypeProps>\n\nexport const typesRegistry = registry<TypeMetadata>()\n\nexport const NeemataTypeError = core.$ZodError\nexport type NeemataTypeError = core.$ZodError\n\nexport abstract class BaseType<\n  EncodedZodType extends SimpleZodType = SimpleZodType,\n  DecodedZodType extends ZodType = EncodedZodType,\n  Props extends TypeProps = TypeProps,\n> {\n  readonly encodedZodType: EncodedZodType\n  readonly decodedZodType: DecodedZodType\n  readonly props: Props\n  readonly params: TypeParams\n\n  constructor({\n    encodedZodType,\n    decodedZodType = encodedZodType as unknown as DecodedZodType,\n    props = {} as Props,\n    params = {} as Partial<TypeParams>,\n  }: {\n    encodedZodType: EncodedZodType\n    decodedZodType?: DecodedZodType\n    props?: Props\n    params?: Partial<TypeParams>\n  }) {\n    this.encodedZodType = encodedZodType\n    this.decodedZodType = decodedZodType\n\n    this.props = props\n    this.params = Object.assign({ checks: [] }, params)\n  }\n\n  optional(): OptionalType<this> {\n    return OptionalType.factory(this)\n  }\n\n  nullable(): NullableType<this> {\n    return NullableType.factory(this)\n  }\n\n  nullish() {\n    return this.nullable().optional()\n  }\n\n  default(value: this['encodedZodType']['_zod']['input']): DefaultType<this> {\n    return DefaultType.factory(this, value)\n  }\n\n  title(title: string): this {\n    return this.meta({ title })\n  }\n\n  description(description: string): this {\n    return this.meta({ description })\n  }\n\n  examples(...examples: this['decodedZodType']['_zod']['input'][]): this {\n    return this.meta({\n      examples: this.params.encode\n        ? examples.map(this.params.encode)\n        : examples,\n    })\n  }\n\n  meta(newMetadata: TypeMetadata): this {\n    const metadata = typesRegistry.get(this.encodedZodType) ?? {}\n    Object.assign(metadata, newMetadata)\n    typesRegistry.add(this.encodedZodType, metadata)\n    return this\n  }\n\n  encode(\n    data: this['encodedZodType']['_zod']['input'],\n  ): this['encodedZodType']['_zod']['output'] {\n    return this.encodedZodType.parse(data, { reportInput: true })\n  }\n\n  decode(\n    data: this['decodedZodType']['_zod']['input'],\n  ): this['decodedZodType']['_zod']['output'] {\n    return this.decodedZodType.parse(data, { reportInput: true })\n  }\n}\n\nexport class OptionalType<\n  Type extends BaseTypeAny = BaseTypeAny,\n> extends BaseType<\n  ZodMiniOptional<Type['encodedZodType']>,\n  ZodMiniOptional<Type['decodedZodType']>,\n  { inner: Type }\n> {\n  static factory<T extends BaseTypeAny>(type: T) {\n    return new OptionalType<T>({\n      encodedZodType: optional(type.encodedZodType) as any,\n      props: { inner: type },\n    })\n  }\n}\n\nexport class NullableType<\n  Type extends BaseTypeAny<any> = BaseTypeAny<any>,\n> extends BaseType<\n  ZodMiniNullable<Type['encodedZodType']>,\n  ZodMiniNullable<Type['decodedZodType']>,\n  { inner: Type }\n> {\n  static factory<T extends BaseTypeAny<any>>(type: T) {\n    return new NullableType<T>({\n      encodedZodType: nullable(type.encodedZodType),\n      props: { inner: type },\n    })\n  }\n}\n\nexport class DefaultType<\n  Type extends BaseTypeAny = BaseTypeAny,\n> extends BaseType<\n  ZodMiniDefault<Type['encodedZodType']>,\n  ZodMiniDefault<Type['decodedZodType']>,\n  { inner: Type }\n> {\n  static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {\n    return new DefaultType<T>({\n      encodedZodType: _default(\n        type.encodedZodType,\n        type.params.encode?.(defaultValue) ?? defaultValue,\n      ) as any,\n      decodedZodType: _default(type.decodedZodType, defaultValue) as any,\n      props: { inner: type },\n    })\n  }\n}\n"],"version":3}

package/dist/types/boolean.js

@@ -1,7 +1,7 @@
-import { Type } from '@sinclair/typebox';
+import { boolean } from "@zod/mini";
 import { BaseType } from "./base.js";
 export class BooleanType extends BaseType {
-    static factory() {
-        return new BooleanType(Type.Boolean());
-    }
+	static factory() {
+		return new BooleanType({ encodedZodType: boolean() });
+	}
 }

package/dist/types/boolean.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/boolean.ts"],"sourcesContent":["import { type TBoolean, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class BooleanType extends BaseType<TBoolean, {}, boolean> {\n  static factory() {\n    return new BooleanType(Type.Boolean())\n  }\n}\n"],"names":["Type","BaseType","BooleanType","factory","Boolean"],"mappings":"AAAA,SAAwBA,IAAI,QAAQ,oBAAmB;AACvD,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,oBAAoBD;IAC/B,OAAOE,UAAU;QACf,OAAO,IAAID,YAAYF,KAAKI,OAAO;IACrC;AACF"}
+{"mappings":"AAAA,SAAS,eAAoC,WAAW;AACxD,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,oBAAoB,SAAkC;CACjE,OAAO,UAAU;AACf,SAAO,IAAI,YAAY,EACrB,gBAAgB,SAAS,CAC1B;CACF;AACF","names":[],"sources":["src/types/boolean.ts"],"sourcesContent":["import { boolean, type ZodMiniBoolean } from '@zod/mini'\nimport { BaseType } from './base.ts'\n\nexport class BooleanType extends BaseType<ZodMiniBoolean<boolean>> {\n  static factory() {\n    return new BooleanType({\n      encodedZodType: boolean(),\n    })\n  }\n}\n"],"version":3}

package/dist/types/custom.js

@@ -1,11 +1,12 @@
-import { Type } from '@sinclair/typebox';
+import { any, custom, overwrite, pipe } from "@zod/mini";
 import { BaseType } from "./base.js";
-export class TransformType extends BaseType {
-}
+export class TransformType extends BaseType {}
 export class CustomType extends TransformType {
-    static factory(decode, encode, schema = Type.Any()) {
-        return new CustomType(Type.Transform(schema).Decode(decode).Encode(encode), {}, {
-            encode
-        });
-    }
+	static factory({ decode, encode, error, type = any() }) {
+		return new CustomType({
+			encodedZodType: pipe(custom().check(overwrite(encode)), type),
+			decodedZodType: pipe(type, custom(undefined, { error }).check(overwrite(decode))),
+			params: { encode }
+		});
+	}
 }

package/dist/types/custom.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/custom.ts"],"sourcesContent":["import {\n  type TAny,\n  type TSchema,\n  type TTransform,\n  Type,\n} from '@sinclair/typebox'\nimport type { StaticInputDecode, StaticOutputDecode } from '../inference.ts'\nimport { BaseType } from './base.ts'\n\nexport type CustomTypeDecode<T> = (value: any) => T\nexport type CustomTypeEncode<T> = (value: T) => any\n\nexport abstract class TransformType<\n  T,\n  S extends TSchema = TAny,\n> extends BaseType<TTransform<S, T>, {}, StaticInputDecode<TTransform<S, T>>> {}\n\nexport class CustomType<T, S extends TSchema = TAny> extends TransformType<\n  T,\n  S\n> {\n  static factory<T, S extends TSchema = TAny>(\n    decode: CustomTypeDecode<T>,\n    encode: CustomTypeEncode<T>,\n    schema: S = Type.Any() as S,\n  ) {\n    return new CustomType<T, S>(\n      Type.Transform(schema).Decode(decode).Encode(encode),\n      {},\n      { encode } as any,\n    )\n  }\n}\n"],"names":["Type","BaseType","TransformType","CustomType","factory","decode","encode","schema","Any","Transform","Decode","Encode"],"mappings":"AAAA,SAIEA,IAAI,QACC,oBAAmB;AAE1B,SAASC,QAAQ,QAAQ,YAAW;AAKpC,OAAO,MAAeC,sBAGZD;AAAqE;AAE/E,OAAO,MAAME,mBAAgDD;IAI3D,OAAOE,QACLC,MAA2B,EAC3BC,MAA2B,EAC3BC,SAAYP,KAAKQ,GAAG,EAAO,EAC3B;QACA,OAAO,IAAIL,WACTH,KAAKS,SAAS,CAACF,QAAQG,MAAM,CAACL,QAAQM,MAAM,CAACL,SAC7C,CAAC,GACD;YAAEA;QAAO;IAEb;AACF"}
+{"mappings":"AAAA,SACE,KAEA,QACA,WACA,YAIK,WAAW;AAClB,SAAS,gBAAkD,WAAW;AAKtE,OAAO,MAAe,sBAIZ,SASR,CAAE;AAEJ,OAAO,MAAM,mBAIH,cAA8C;CACtD,OAAO,QAIL,EACA,QACA,QACA,OACA,OAAO,KAAK,EAYb,EAAE;AACD,SAAO,IAAI,WAA2C;GACpD,gBAAgB,KAAK,QAAQ,CAAC,MAAM,UAAU,OAAO,CAAC,EAAE,KAAK;GAC7D,gBAAgB,KACd,MACA,OAAO,WAAW,EAAE,MAAO,EAAC,CAAC,MAAM,UAAU,OAAO,CAAC,CACtD;GACD,QAAQ,EAAE,OAAQ;EACnB;CACF;AACF","names":[],"sources":["src/types/custom.ts"],"sourcesContent":["import {\n  any,\n  type core,\n  custom,\n  overwrite,\n  pipe,\n  type ZodMiniAny,\n  type ZodMiniCustom,\n  type ZodMiniPipe,\n} from '@zod/mini'\nimport { BaseType, type SimpleZodType, type ZodType } from './base.ts'\n\nexport type CustomTypeDecode<I, O> = (value: I) => O\nexport type CustomTypeEncode<I, O> = (value: I) => O\n\nexport abstract class TransformType<\n  Type,\n  EncodedType extends SimpleZodType = ZodMiniAny,\n  DecodedType extends ZodType = ZodMiniCustom<Type, Type>,\n> extends BaseType<\n  ZodMiniPipe<\n    ZodMiniCustom<DecodedType['_zod']['output'], DecodedType['_zod']['input']>,\n    EncodedType\n  >,\n  ZodMiniPipe<\n    EncodedType,\n    ZodMiniCustom<EncodedType['_zod']['output'], EncodedType['_zod']['input']>\n  >\n> {}\n\nexport class CustomType<\n  Type,\n  EncodedType extends SimpleZodType = ZodMiniAny,\n  DecodedType extends ZodType = ZodMiniCustom<Type, Type>,\n> extends TransformType<Type, EncodedType, DecodedType> {\n  static factory<\n    Type,\n    EncodedType extends SimpleZodType = ZodMiniAny,\n    DecodedType extends ZodType = ZodMiniCustom<Type, Type>,\n  >({\n    decode,\n    encode,\n    error,\n    type = any() as unknown as EncodedType,\n  }: {\n    decode: CustomTypeDecode<\n      EncodedType['_zod']['input'],\n      DecodedType['_zod']['output']\n    >\n    encode: CustomTypeEncode<\n      DecodedType['_zod']['input'],\n      EncodedType['_zod']['output']\n    >\n    error?: string | core.$ZodErrorMap<core.$ZodIssueBase>\n    type?: EncodedType\n  }) {\n    return new CustomType<Type, EncodedType, DecodedType>({\n      encodedZodType: pipe(custom().check(overwrite(encode)), type),\n      decodedZodType: pipe(\n        type,\n        custom(undefined, { error }).check(overwrite(decode)),\n      ),\n      params: { encode },\n    })\n  }\n}\n"],"version":3}

package/dist/types/date.js

@@ -1,16 +1,11 @@
-import { Type } from '@sinclair/typebox';
+import { iso, union } from "@zod/mini";
 import { CustomType, TransformType } from "./custom.js";
-const decode = (value)=>new Date(value);
-const encode = (value)=>value.toISOString();
 export class DateType extends TransformType {
-    static factory() {
-        return CustomType.factory(decode, encode, Type.Union([
-            Type.String({
-                format: 'date'
-            }),
-            Type.String({
-                format: 'date-time'
-            })
-        ]));
-    }
+	static factory() {
+		return CustomType.factory({
+			decode: (value) => new Date(value),
+			encode: (value) => value.toISOString(),
+			type: union([iso.datetime(), iso.date()])
+		});
+	}
 }

package/dist/types/date.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/date.ts"],"sourcesContent":["import { type TString, Type } from '@sinclair/typebox'\nimport { CustomType, TransformType } from './custom.ts'\n\nconst decode = (value: any): Date => new Date(value)\nconst encode = (value: Date): any => value.toISOString()\n\nexport class DateType extends TransformType<Date> {\n  static factory() {\n    return CustomType.factory<Date, TString>(\n      decode,\n      encode,\n      Type.Union([\n        Type.String({\n          format: 'date',\n        }),\n        Type.String({\n          format: 'date-time',\n        }),\n      ]) as unknown as TString,\n    )\n  }\n}\n"],"names":["Type","CustomType","TransformType","decode","value","Date","encode","toISOString","DateType","factory","Union","String","format"],"mappings":"AAAA,SAAuBA,IAAI,QAAQ,oBAAmB;AACtD,SAASC,UAAU,EAAEC,aAAa,QAAQ,cAAa;AAEvD,MAAMC,SAAS,CAACC,QAAqB,IAAIC,KAAKD;AAC9C,MAAME,SAAS,CAACF,QAAqBA,MAAMG,WAAW;AAEtD,OAAO,MAAMC,iBAAiBN;IAC5B,OAAOO,UAAU;QACf,OAAOR,WAAWQ,OAAO,CACvBN,QACAG,QACAN,KAAKU,KAAK,CAAC;YACTV,KAAKW,MAAM,CAAC;gBACVC,QAAQ;YACV;YACAZ,KAAKW,MAAM,CAAC;gBACVC,QAAQ;YACV;SACD;IAEL;AACF"}
+{"mappings":"AAAA,SAAS,KAAK,aAAgC,WAAW;AACzD,SAAS,YAAY,qBAAqB,aAAa;AAEvD,OAAO,MAAM,iBAAiB,cAG5B;CACA,OAAO,UAAU;AACf,SAAO,WAAW,QAGhB;GACA,QAAQ,CAACA,UAAwB,IAAI,KAAK;GAC1C,QAAQ,CAACC,UAAwB,MAAM,aAAa;GACpD,MAAM,MAAM,CAAC,IAAI,UAAU,EAAE,IAAI,MAAM,AAAC,EAAC;EAC1C,EAAC;CACH;AACF","names":["value: string","value: Date"],"sources":["src/types/date.ts"],"sourcesContent":["import { iso, union, type ZodMiniUnion } from '@zod/mini'\nimport { CustomType, TransformType } from './custom.ts'\n\nexport class DateType extends TransformType<\n  Date,\n  ZodMiniUnion<[iso.ZodMiniISODate, iso.ZodMiniISODateTime]>\n> {\n  static factory() {\n    return CustomType.factory<\n      Date,\n      ZodMiniUnion<Array<iso.ZodMiniISODate | iso.ZodMiniISODateTime>>\n    >({\n      decode: (value: string): Date => new Date(value),\n      encode: (value: Date): string => value.toISOString(),\n      type: union([iso.datetime(), iso.date()]),\n    })\n  }\n}\n"],"version":3}

package/dist/types/enum.js

@@ -1,19 +1,10 @@
-import { Type } from '@sinclair/typebox';
+import { enum as enum_ } from "@zod/mini";
 import { BaseType } from "./base.js";
-export class ObjectEnumType extends BaseType {
-    static factory(values) {
-        return new ObjectEnumType(Type.Enum(values), {
-            values: Object.values(values)
-        });
-    }
-}
 export class EnumType extends BaseType {
-    static factory(values) {
-        return new EnumType(Type.Enum(Object.fromEntries(values.map((v)=>[
-                v,
-                v
-            ]))), {
-            values
-        });
-    }
+	static factory(values) {
+		return new EnumType({
+			encodedZodType: enum_(values),
+			props: { values }
+		});
+	}
 }

package/dist/types/enum.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/enum.ts"],"sourcesContent":["import { type TEnum, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class ObjectEnumType<\n  T extends { [K in string]: K } = { [K in string]: K },\n> extends BaseType<TEnum<T>, { values: T[keyof T] }, T[keyof T]> {\n  static factory<T extends { [K in string]: K }>(values: T) {\n    return new ObjectEnumType<T>(Type.Enum(values as any), {\n      values: Object.values(values) as unknown as T[keyof T],\n    })\n  }\n}\n\nexport class EnumType<\n  T extends (string | number)[] = (string | number)[],\n> extends BaseType<\n  TEnum<Record<string, T[number]>>,\n  { values: [...T] },\n  T[keyof T]\n> {\n  static factory<T extends (string | number)[]>(values: [...T]) {\n    return new EnumType<T>(\n      Type.Enum(Object.fromEntries(values.map((v) => [v, v])) as any),\n      { values },\n    )\n  }\n}\n"],"names":["Type","BaseType","ObjectEnumType","factory","values","Enum","Object","EnumType","fromEntries","map","v"],"mappings":"AAAA,SAAqBA,IAAI,QAAQ,oBAAmB;AACpD,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,uBAEHD;IACR,OAAOE,QAAwCC,MAAS,EAAE;QACxD,OAAO,IAAIF,eAAkBF,KAAKK,IAAI,CAACD,SAAgB;YACrDA,QAAQE,OAAOF,MAAM,CAACA;QACxB;IACF;AACF;AAEA,OAAO,MAAMG,iBAEHN;IAKR,OAAOE,QAAuCC,MAAc,EAAE;QAC5D,OAAO,IAAIG,SACTP,KAAKK,IAAI,CAACC,OAAOE,WAAW,CAACJ,OAAOK,GAAG,CAAC,CAACC,IAAM;gBAACA;gBAAGA;aAAE,KACrD;YAAEN;QAAO;IAEb;AACF"}
+{"mappings":"AAAA,SAAoB,QAAQ,aAA+B,WAAW;AACtE,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,iBAEH,SAAwD;CAKhE,OAAO,QAAkDA,QAAW;AAClE,SAAO,IAAI,SAAS;GAClB,gBAAgB,MAAM,OAAc;GACpC,OAAO,EAAE,OAAQ;EAClB;CACF;AACF","names":["values: T"],"sources":["src/types/enum.ts"],"sourcesContent":["import { type core, enum as enum_, type ZodMiniEnum } from '@zod/mini'\nimport { BaseType } from './base.ts'\n\nexport class EnumType<\n  T extends core.utils.EnumLike = core.utils.EnumLike,\n> extends BaseType<ZodMiniEnum<T>, ZodMiniEnum<T>, { values: T }> {\n  static factory<T extends core.utils.EnumLike>(values: T): EnumType<T>\n  static factory<T extends string[]>(\n    values: T,\n  ): EnumType<core.utils.ToEnum<T[number]>>\n  static factory<T extends core.utils.EnumLike | string[]>(values: T) {\n    return new EnumType({\n      encodedZodType: enum_(values as any),\n      props: { values },\n    })\n  }\n}\n"],"version":3}

package/dist/types/literal.js

@@ -1,9 +1,10 @@
-import { Type } from '@sinclair/typebox';
+import { literal } from "@zod/mini";
 import { BaseType } from "./base.js";
 export class LiteralType extends BaseType {
-    static factory(value) {
-        return new LiteralType(Type.Literal(value), {
-            value
-        });
-    }
+	static factory(value) {
+		return new LiteralType({
+			encodedZodType: literal(value),
+			props: { value }
+		});
+	}
 }

package/dist/types/literal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/literal.ts"],"sourcesContent":["import { type TLiteral, type TLiteralValue, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class LiteralType<\n  T extends TLiteralValue = TLiteralValue,\n> extends BaseType<TLiteral<T>, { value: TLiteralValue }, T> {\n  static factory<T extends TLiteralValue>(value: T) {\n    return new LiteralType<T>(Type.Literal(value), { value })\n  }\n}\n"],"names":["Type","BaseType","LiteralType","factory","value","Literal"],"mappings":"AAAA,SAA4CA,IAAI,QAAQ,oBAAmB;AAC3E,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,oBAEHD;IACR,OAAOE,QAAiCC,KAAQ,EAAE;QAChD,OAAO,IAAIF,YAAeF,KAAKK,OAAO,CAACD,QAAQ;YAAEA;QAAM;IACzD;AACF"}
+{"mappings":"AAAA,SAAS,eAAoC,WAAW;AACxD,SAAS,gBAAyC,WAAW;AAE7D,OAAO,MAAM,oBAEH,SAA6D;CACrE,OAAO,QAAsCA,OAAU;AACrD,SAAO,IAAI,YAAe;GACxB,gBAAgB,QAAQ,MAAM;GAC9B,OAAO,EAAE,MAAO;EACjB;CACF;AACF","names":["value: T"],"sources":["src/types/literal.ts"],"sourcesContent":["import { literal, type ZodMiniLiteral } from '@zod/mini'\nimport { BaseType, type PrimitiveValueType } from './base.ts'\n\nexport class LiteralType<\n  T extends PrimitiveValueType = PrimitiveValueType,\n> extends BaseType<ZodMiniLiteral<T>, ZodMiniLiteral<T>, { value: T }> {\n  static factory<T extends PrimitiveValueType>(value: T) {\n    return new LiteralType<T>({\n      encodedZodType: literal(value),\n      props: { value },\n    })\n  }\n}\n"],"version":3}

package/dist/types/never.js

@@ -1,7 +1,7 @@
-import { Type } from '@sinclair/typebox';
+import { never } from "@zod/mini";
 import { BaseType } from "./base.js";
 export class NeverType extends BaseType {
-    static factory() {
-        return new NeverType(Type.Never());
-    }
+	static factory() {
+		return new NeverType({ encodedZodType: never() });
+	}
 }

package/dist/types/never.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/never.ts"],"sourcesContent":["import { type TNever, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class NeverType extends BaseType<TNever, {}, never> {\n  static factory() {\n    return new NeverType(Type.Never())\n  }\n}\n"],"names":["Type","BaseType","NeverType","factory","Never"],"mappings":"AAAA,SAAsBA,IAAI,QAAQ,oBAAmB;AACrD,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,kBAAkBD;IAC7B,OAAOE,UAAU;QACf,OAAO,IAAID,UAAUF,KAAKI,KAAK;IACjC;AACF"}
+{"mappings":"AAAA,SAAS,aAAgC,WAAW;AACpD,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,kBAAkB,SAAuB;CACpD,OAAO,UAAU;AACf,SAAO,IAAI,UAAU,EACnB,gBAAgB,OAAO,CACxB;CACF;AACF","names":[],"sources":["src/types/never.ts"],"sourcesContent":["import { never, type ZodMiniNever } from '@zod/mini'\nimport { BaseType } from './base.ts'\n\nexport class NeverType extends BaseType<ZodMiniNever> {\n  static factory() {\n    return new NeverType({\n      encodedZodType: never(),\n    })\n  }\n}\n"],"version":3}