@nmtjs/type 0.4.8 → 0.5.0

package/dist/types/base.js

@@ -1,46 +1,83 @@
-import { Type } from '@sinclair/typebox';
-import { typeSchema, typeStatic } from "../constants.js";
+import { Optional } from '@sinclair/typebox';
 import { Nullable } from "../schemas/nullable.js";
 export class BaseType {
-    options;
-    isNullable;
-    isOptional;
-    hasDefault;
-    [typeStatic];
-    constructor(options = {}, isNullable = false, isOptional = false, hasDefault = false, ...contstructArgs){
-        this.options = options;
-        this.isNullable = isNullable;
-        this.isOptional = isOptional;
-        this.hasDefault = hasDefault;
-        let schema = this._constructSchema(options, ...contstructArgs);
-        if (this.isNullable) {
-            schema = Nullable(schema);
-        }
-        if (this.isOptional) {
-            schema = Type.Optional(schema);
-        }
-        this[typeSchema] = schema;
-    }
-    [typeSchema];
-    get _args() {
-        return [
-            this.isNullable,
-            this.isOptional,
-            this.hasDefault
-        ];
-    }
-    _with({ options = this.options, isNullable = this.isNullable, isOptional = this.isOptional, hasDefault = this.hasDefault } = {}) {
-        return [
-            {
-                ...this.options,
-                ...options
-            },
-            isNullable,
-            isOptional,
-            hasDefault
-        ];
+    schema;
+    final;
+    props;
+    params;
+    constructor(schema, props = {}, params = {}){
+        const { hasDefault = false, nullable = false, optional = false } = params;
+        this.schema = schema;
+        this.final = schema;
+        if (nullable) this.final = Nullable(this.final);
+        if (optional || hasDefault) this.final = Optional(this.final);
+        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);
     }
 }
-export function getTypeSchema(type) {
-    return type[typeSchema];
+export class OptionalType extends BaseType {
+    _;
+    static factory(type) {
+        return new OptionalType(type.schema, {
+            inner: type
+        }, {
+            ...type.params,
+            optional: true
+        });
+    }
+}
+export class NullableType extends BaseType {
+    _;
+    static factory(type) {
+        return new NullableType(type.schema, {
+            inner: type
+        }, {
+            ...type.params,
+            nullable: true
+        });
+    }
+}
+export class DefaultType extends BaseType {
+    _;
+    static factory(type, defaultValue) {
+        return new DefaultType({
+            ...type.schema,
+            default: defaultValue
+        }, {
+            inner: type
+        }, {
+            ...type.params,
+            hasDefault: true
+        });
+    }
 }

package/dist/types/base.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/base.ts"],"sourcesContent":["import {\n  type SchemaOptions,\n  type StaticDecode,\n  type StaticEncode,\n  type TAny,\n  type TOptional,\n  type TSchema,\n  Type,\n} from '@sinclair/typebox'\nimport { typeSchema, typeStatic } from '../constants.ts'\nimport { Nullable, type TNullable } from '../schemas/nullable.ts'\n\ntype ResolveNullable<T extends TSchema, Is extends boolean> = Is extends true\n  ? TNullable<T>\n  : T\n\ntype ResolveOptional<T extends TSchema, Is extends boolean> = Is extends true\n  ? TOptional<T>\n  : T\n\ntype Resolve<\n  Schema extends TSchema,\n  IsNullable extends boolean,\n  IsOptional extends boolean,\n> = ResolveOptional<ResolveNullable<Schema, IsNullable>, IsOptional>\n\nexport abstract class BaseType<\n  Schema extends TSchema = TSchema,\n  IsNullable extends boolean = boolean,\n  IsOptional extends boolean = boolean,\n  HasDefault extends boolean = boolean,\n  Options extends SchemaOptions = SchemaOptions,\n> {\n  protected abstract _constructSchema(\n    options: Options,\n    ...constructArgs: any[]\n  ): Schema\n\n  [typeStatic]!: {\n    schema: Resolve<\n      Schema,\n      IsNullable,\n      HasDefault extends true ? false : IsOptional\n    >\n    isOptional: IsOptional\n    isNullable: IsNullable\n    hasDefault: HasDefault\n    encoded: StaticEncode<Resolve<Schema, IsNullable, IsOptional>>\n    decoded: StaticDecode<\n      Resolve<Schema, IsNullable, HasDefault extends true ? false : IsOptional>\n    >\n  }\n\n  constructor(\n    protected options: Options = {} as Options,\n    protected isNullable: IsNullable = false as IsNullable,\n    protected isOptional: IsOptional = false as IsOptional,\n    protected hasDefault: HasDefault = false as HasDefault,\n    ...contstructArgs: any[]\n  ) {\n    let schema: TSchema = this._constructSchema(options, ...contstructArgs)\n    if (this.isNullable) {\n      schema = Nullable(schema)\n    }\n    if (this.isOptional) {\n      schema = Type.Optional(schema)\n    }\n    this[typeSchema] = schema as Schema\n  }\n  protected [typeSchema]: Schema\n\n  protected get _args(): [IsNullable, IsOptional, HasDefault] {\n    return [this.isNullable, this.isOptional, this.hasDefault]\n  }\n\n  protected _with<\n    _IsNullable extends boolean = IsNullable,\n    _IsOptional extends boolean = IsOptional,\n    _HasDefault extends boolean = HasDefault,\n  >({\n    options = this.options as Options,\n    isNullable = this.isNullable as unknown as _IsNullable,\n    isOptional = this.isOptional as unknown as _IsOptional,\n    hasDefault = this.hasDefault as unknown as _HasDefault,\n  }: {\n    options?: Options\n    isNullable?: _IsNullable\n    isOptional?: _IsOptional\n    hasDefault?: _HasDefault\n  } = {}): [Options, _IsNullable, _IsOptional, _HasDefault] {\n    return [{ ...this.options, ...options }, isNullable, isOptional, hasDefault]\n  }\n\n  abstract optional(): BaseType<Schema, IsNullable, true, HasDefault>\n  abstract nullish(): BaseType<Schema, true, true, HasDefault>\n  abstract default(value: any): BaseType<Schema, IsNullable, IsOptional, true>\n  abstract description(\n    value: string,\n  ): BaseType<Schema, IsNullable, IsOptional, HasDefault>\n  abstract examples(\n    ...values: any[]\n  ): BaseType<Schema, IsNullable, IsOptional, HasDefault>\n}\n\nexport function getTypeSchema<T extends BaseType>(\n  type: T,\n): T[typeStatic]['schema'] {\n  return type[typeSchema]\n}\n"],"names":["Type","typeSchema","typeStatic","Nullable","BaseType","constructor","options","isNullable","isOptional","hasDefault","contstructArgs","schema","_constructSchema","Optional","_args","_with","getTypeSchema","type"],"mappings":"AAAA,SAOEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,UAAU,EAAEC,UAAU,QAAQ,kBAAiB;AACxD,SAASC,QAAQ,QAAwB,yBAAwB;AAgBjE,OAAO,MAAeC;;;;;IAYpB,CAACF,WAAW,CAaX;IAEDG,YACE,AAAUC,UAAmB,CAAC,CAAY,EAC1C,AAAUC,aAAyB,KAAmB,EACtD,AAAUC,aAAyB,KAAmB,EACtD,AAAUC,aAAyB,KAAmB,EACtD,GAAGC,cAAqB,CACxB;aALUJ,UAAAA;aACAC,aAAAA;aACAC,aAAAA;aACAC,aAAAA;QAGV,IAAIE,SAAkB,IAAI,CAACC,gBAAgB,CAACN,YAAYI;QACxD,IAAI,IAAI,CAACH,UAAU,EAAE;YACnBI,SAASR,SAASQ;QACpB;QACA,IAAI,IAAI,CAACH,UAAU,EAAE;YACnBG,SAASX,KAAKa,QAAQ,CAACF;QACzB;QACA,IAAI,CAACV,WAAW,GAAGU;IACrB;IACU,CAACV,WAAW,CAAQ;IAE9B,IAAca,QAA8C;QAC1D,OAAO;YAAC,IAAI,CAACP,UAAU;YAAE,IAAI,CAACC,UAAU;YAAE,IAAI,CAACC,UAAU;SAAC;IAC5D;IAEUM,MAIR,EACAT,UAAU,IAAI,CAACA,OAAO,AAAW,EACjCC,aAAa,IAAI,CAACA,UAAU,AAA0B,EACtDC,aAAa,IAAI,CAACA,UAAU,AAA0B,EACtDC,aAAa,IAAI,CAACA,UAAU,AAA0B,EAMvD,GAAG,CAAC,CAAC,EAAoD;QACxD,OAAO;YAAC;gBAAE,GAAG,IAAI,CAACH,OAAO;gBAAE,GAAGA,OAAO;YAAC;YAAGC;YAAYC;YAAYC;SAAW;IAC9E;AAWF;AAEA,OAAO,SAASO,cACdC,IAAO;IAEP,OAAOA,IAAI,CAAChB,WAAW;AACzB"}
+{"version":3,"sources":["../../../src/types/base.ts"],"sourcesContent":["import {\n  Optional,\n  type SchemaOptions,\n  type StaticDecode,\n  type StaticEncode,\n  type TSchema,\n} from '@sinclair/typebox'\nimport {\n  Nullable,\n  type TNullable,\n  type TOptionalUndefined,\n} from '../schemas/nullable.ts'\nimport type { Merge } from '../utils.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<T, any, any>\n\ntype ResolveNullable<\n  T extends TSchema,\n  P extends TypeParams,\n> = P['nullable'] extends true\n  ? T extends TNullable<infer S>\n    ? TNullable<S>\n    : TNullable<T>\n  : T\n\ntype ResolveOptional<\n  T extends TSchema,\n  P extends TypeParams,\n> = P['optional'] extends true\n  ? T extends TOptionalUndefined<infer S>\n    ? TOptionalUndefined<S>\n    : TOptionalUndefined<T>\n  : T\n\ntype ResolveDefault<\n  T extends TSchema,\n  P extends TypeParams,\n> = P['hasDefault'] extends true\n  ? T extends TOptionalUndefined<infer U>\n    ? U\n    : T\n  : T\n\nexport abstract class BaseType<\n  Schema extends TSchema = TSchema,\n  Props extends TypeProps = TypeProps,\n  Params extends TypeParams = DefaultTypeParams,\n> {\n  abstract _: {\n    encoded: {\n      input: TSchema\n      output: TSchema\n    }\n    decoded: {\n      input: TSchema\n      output: TSchema\n    }\n  }\n\n  readonly schema: Schema\n  readonly final: TSchema\n  readonly props: Props\n  readonly params: Params\n\n  constructor(\n    schema: Schema,\n    props: Props = {} as Props,\n    params: Params = {} as Params,\n  ) {\n    const { hasDefault = false, nullable = false, optional = false } = params\n    this.schema = schema\n    this.final = schema\n    if (nullable) this.final = Nullable(this.final) as any\n    if (optional || hasDefault) this.final = Optional(this.final) as any\n\n    this.props = props\n    this.params = {\n      hasDefault,\n      nullable,\n      optional,\n    } as Params\n  }\n\n  optional(): OptionalType<this> {\n    return OptionalType.factory(this) as any\n  }\n\n  nullable(): NullableType<this> {\n    return NullableType.factory(this) as any\n  }\n\n  nullish() {\n    return this.nullable().optional()\n  }\n\n  default(\n    value: StaticDecode<this['_']['decoded']['output']>,\n  ): DefaultType<this> {\n    return DefaultType.factory(\n      this,\n      this.params.encode?.(value) ?? value,\n    ) as any\n  }\n\n  description(description: string): this {\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: any[]): this {\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 type ConstantType<T extends TSchema> = {\n  encoded: {\n    input: T\n    output: T\n  }\n  decoded: {\n    input: T\n    output: T\n  }\n}\n\nexport type Static<\n  T extends BaseTypeAny,\n  P extends TypeProps,\n  Params extends Merge<T['params'], P> = Merge<T['params'], P>,\n> = {\n  encoded: {\n    input: ResolveOptional<\n      ResolveNullable<T['_']['encoded']['input'], Params>,\n      Params\n    >\n    output: ResolveDefault<\n      ResolveOptional<\n        ResolveNullable<T['_']['encoded']['output'], Params>,\n        Params\n      >,\n      Params\n    >\n  }\n  decoded: {\n    input: ResolveOptional<\n      ResolveNullable<T['_']['decoded']['input'], Params>,\n      Params\n    >\n    output: ResolveDefault<\n      ResolveOptional<\n        ResolveNullable<T['_']['decoded']['output'], Params>,\n        Params\n      >,\n      Params\n    >\n  }\n}\n\nexport class OptionalType<\n  Type extends BaseTypeAny<any>,\n  Params extends TypeParams = DefaultTypeParams,\n> extends BaseType<Type['schema'], { inner: Type }, Params> {\n  _!: Static<Type, Params>\n\n  static factory<T extends BaseTypeAny<any>>(type: T) {\n    return new OptionalType<T, Merge<T['params'], { optional: true }>>(\n      type.schema,\n      { inner: type },\n      { ...type.params, optional: true } as any,\n    )\n  }\n}\n\nexport class NullableType<\n  Type extends BaseTypeAny<any>,\n  Params extends TypeParams = DefaultTypeParams,\n> extends BaseType<Type['schema'], { inner: Type }, Params> {\n  _!: Static<Type, Params>\n\n  static factory<T extends BaseTypeAny<any>>(type: T) {\n    return new NullableType<T, Merge<T['params'], { nullable: true }>>(\n      type.schema,\n      { inner: type },\n      { ...type.params, nullable: true } as any,\n    )\n  }\n}\n\nexport class DefaultType<\n  Type extends BaseTypeAny<any>,\n  Params extends TypeParams = DefaultTypeParams,\n> extends BaseType<Type['schema'], { inner: Type }, Params> {\n  _!: Static<Type, Params>\n\n  static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {\n    return new DefaultType<T, Merge<T['params'], { hasDefault: true }>>(\n      { ...type.schema, default: defaultValue },\n      { inner: type },\n      { ...type.params, hasDefault: true } as any,\n    )\n  }\n}\n"],"names":["Optional","Nullable","BaseType","schema","final","props","params","constructor","hasDefault","nullable","optional","OptionalType","factory","NullableType","nullish","default","value","DefaultType","encode","description","ThisConstructor","examples","_","type","inner","defaultValue"],"mappings":"AAAA,SACEA,QAAQ,QAKH,oBAAmB;AAC1B,SACEC,QAAQ,QAGH,yBAAwB;AAgD/B,OAAO,MAAeC;IAgBXC,OAAc;IACdC,MAAc;IACdC,MAAY;IACZC,OAAc;IAEvBC,YACEJ,MAAc,EACdE,QAAe,CAAC,CAAU,EAC1BC,SAAiB,CAAC,CAAW,CAC7B;QACA,MAAM,EAAEE,aAAa,KAAK,EAAEC,WAAW,KAAK,EAAEC,WAAW,KAAK,EAAE,GAAGJ;QACnE,IAAI,CAACH,MAAM,GAAGA;QACd,IAAI,CAACC,KAAK,GAAGD;QACb,IAAIM,UAAU,IAAI,CAACL,KAAK,GAAGH,SAAS,IAAI,CAACG,KAAK;QAC9C,IAAIM,YAAYF,YAAY,IAAI,CAACJ,KAAK,GAAGJ,SAAS,IAAI,CAACI,KAAK;QAE5D,IAAI,CAACC,KAAK,GAAGA;QACb,IAAI,CAACC,MAAM,GAAG;YACZE;YACAC;YACAC;QACF;IACF;IAEAA,WAA+B;QAC7B,OAAOC,aAAaC,OAAO,CAAC,IAAI;IAClC;IAEAH,WAA+B;QAC7B,OAAOI,aAAaD,OAAO,CAAC,IAAI;IAClC;IAEAE,UAAU;QACR,OAAO,IAAI,CAACL,QAAQ,GAAGC,QAAQ;IACjC;IAEAK,QACEC,KAAmD,EAChC;QACnB,OAAOC,YAAYL,OAAO,CACxB,IAAI,EACJ,IAAI,CAACN,MAAM,CAACY,MAAM,GAAGF,UAAUA;IAEnC;IAEAG,YAAYA,WAAmB,EAAQ;QACrC,MAAMC,kBAAkB,IAAI,CAACb,WAAW;QACxC,OAAO,IAAIa,gBACT;YACE,GAAG,IAAI,CAACjB,MAAM;YACdgB;QACF,GACA,IAAI,CAACd,KAAK,EACV,IAAI,CAACC,MAAM;IAEf;IAEAe,SAAS,GAAGA,QAAe,EAAQ;QACjC,MAAMD,kBAAkB,IAAI,CAACb,WAAW;QACxC,OAAO,IAAIa,gBACT;YACE,GAAG,IAAI,CAACjB,MAAM;YACdkB;QACF,GACA,IAAI,CAAChB,KAAK,EACV,IAAI,CAACC,MAAM;IAEf;AACF;AA8CA,OAAO,MAAMK,qBAGHT;IACRoB,EAAwB;IAExB,OAAOV,QAAoCW,IAAO,EAAE;QAClD,OAAO,IAAIZ,aACTY,KAAKpB,MAAM,EACX;YAAEqB,OAAOD;QAAK,GACd;YAAE,GAAGA,KAAKjB,MAAM;YAAEI,UAAU;QAAK;IAErC;AACF;AAEA,OAAO,MAAMG,qBAGHX;IACRoB,EAAwB;IAExB,OAAOV,QAAoCW,IAAO,EAAE;QAClD,OAAO,IAAIV,aACTU,KAAKpB,MAAM,EACX;YAAEqB,OAAOD;QAAK,GACd;YAAE,GAAGA,KAAKjB,MAAM;YAAEG,UAAU;QAAK;IAErC;AACF;AAEA,OAAO,MAAMQ,oBAGHf;IACRoB,EAAwB;IAExB,OAAOV,QAAoCW,IAAO,EAAEE,YAAiB,EAAE;QACrE,OAAO,IAAIR,YACT;YAAE,GAAGM,KAAKpB,MAAM;YAAEY,SAASU;QAAa,GACxC;YAAED,OAAOD;QAAK,GACd;YAAE,GAAGA,KAAKjB,MAAM;YAAEE,YAAY;QAAK;IAEvC;AACF"}

package/dist/types/boolean.js

@@ -1,48 +1,8 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class BooleanType extends BaseType {
-    constructor(options = {}, isNullable = false, isOptional = false, hasDefault = false){
-        super(options, isNullable, isOptional, hasDefault);
-    }
-    _constructSchema(options) {
-        return Type.Boolean(options);
-    }
-    nullable() {
-        return new BooleanType(...this._with({
-            isNullable: true
-        }));
-    }
-    optional() {
-        return new BooleanType(...this._with({
-            isOptional: true
-        }));
-    }
-    nullish() {
-        return new BooleanType(...this._with({
-            isNullable: true,
-            isOptional: true
-        }));
-    }
-    default(value) {
-        return new BooleanType(...this._with({
-            options: {
-                default: value
-            },
-            hasDefault: true
-        }));
-    }
-    description(description) {
-        return new BooleanType(...this._with({
-            options: {
-                description
-            }
-        }));
-    }
-    examples(...examples) {
-        return new BooleanType(...this._with({
-            options: {
-                examples
-            }
-        }));
+    _;
+    static factory() {
+        return new BooleanType(Type.Boolean());
     }
 }

package/dist/types/boolean.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/boolean.ts"],"sourcesContent":["import { type SchemaOptions, type TBoolean, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class BooleanType<\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TBoolean, N, O, D> {\n  constructor(\n    options: SchemaOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault)\n  }\n\n  protected _constructSchema(options: SchemaOptions): TBoolean {\n    return Type.Boolean(options)\n  }\n\n  nullable() {\n    return new BooleanType(...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new BooleanType(...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new BooleanType(\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: boolean) {\n    return new BooleanType(\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new BooleanType(...this._with({ options: { description } }))\n  }\n\n  examples(...examples: [boolean, ...boolean[]]) {\n    return new BooleanType(...this._with({ options: { examples } }))\n  }\n}\n"],"names":["Type","BaseType","BooleanType","constructor","options","isNullable","isOptional","hasDefault","_constructSchema","Boolean","nullable","_with","optional","nullish","default","value","description","examples"],"mappings":"AAAA,SAA4CA,IAAI,QAAQ,oBAAmB;AAC3E,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,oBAIHD;IACRE,YACEC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC;IACzC;IAEUC,iBAAiBJ,OAAsB,EAAY;QAC3D,OAAOJ,KAAKS,OAAO,CAACL;IACtB;IAEAM,WAAW;QACT,OAAO,IAAIR,eAAe,IAAI,CAACS,KAAK,CAAC;YAAEN,YAAY;QAAK;IAC1D;IAEAO,WAAW;QACT,OAAO,IAAIV,eAAe,IAAI,CAACS,KAAK,CAAC;YAAEL,YAAY;QAAK;IAC1D;IAEAO,UAAU;QACR,OAAO,IAAIX,eACN,IAAI,CAACS,KAAK,CAAC;YAAEN,YAAY;YAAMC,YAAY;QAAK;IAEvD;IAEAQ,QAAQC,KAAc,EAAE;QACtB,OAAO,IAAIb,eACN,IAAI,CAACS,KAAK,CAAC;YAAEP,SAAS;gBAAEU,SAASC;YAAM;YAAGR,YAAY;QAAK;IAElE;IAEAS,YAAYA,WAAmB,EAAE;QAC/B,OAAO,IAAId,eAAe,IAAI,CAACS,KAAK,CAAC;YAAEP,SAAS;gBAAEY;YAAY;QAAE;IAClE;IAEAC,SAAS,GAAGA,QAAiC,EAAE;QAC7C,OAAO,IAAIf,eAAe,IAAI,CAACS,KAAK,CAAC;YAAEP,SAAS;gBAAEa;YAAS;QAAE;IAC/D;AACF"}
+{"version":3,"sources":["../../../src/types/boolean.ts"],"sourcesContent":["import {\n  type SchemaOptions,\n  type StaticDecode,\n  type TBoolean,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\n\nexport class BooleanType extends BaseType<TBoolean> {\n  _!: ConstantType<this['schema']>\n\n  static factory() {\n    return new BooleanType(Type.Boolean())\n  }\n}\n"],"names":["Type","BaseType","BooleanType","_","factory","Boolean"],"mappings":"AAAA,SAIEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAA2B,YAAW;AAEvD,OAAO,MAAMC,oBAAoBD;IAC/BE,EAAgC;IAEhC,OAAOC,UAAU;QACf,OAAO,IAAIF,YAAYF,KAAKK,OAAO;IACrC;AACF"}

package/dist/types/custom.js

@@ -1,52 +1,12 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
-export class CustomType extends BaseType {
-    decode;
-    encode;
-    constructor(decode, encode, options = {}, isNullable = false, isOptional = false, hasDefault = false){
-        super(options, isNullable, isOptional, hasDefault, decode, encode);
-        this.decode = decode;
-        this.encode = encode;
-    }
-    _constructSchema(options, decode, encode) {
-        return Type.Transform(Type.Any(options)).Decode(decode).Encode(encode);
-    }
-    nullable() {
-        return new CustomType(this.decode, this.encode, ...this._with({
-            isNullable: true
-        }));
-    }
-    optional() {
-        return new CustomType(this.decode, this.encode, ...this._with({
-            isOptional: true
-        }));
-    }
-    nullish() {
-        return new CustomType(this.decode, this.encode, ...this._with({
-            isNullable: true,
-            isOptional: true
-        }));
-    }
-    default(value) {
-        return new CustomType(this.decode, this.encode, ...this._with({
-            options: {
-                default: this.encode(value)
-            },
-            hasDefault: true
-        }));
-    }
-    description(description) {
-        return new CustomType(this.decode, this.encode, ...this._with({
-            options: {
-                description
-            }
-        }));
-    }
-    examples(...examples) {
-        return new CustomType(this.decode, this.encode, ...this._with({
-            options: {
-                examples: examples.map(this.encode)
-            }
-        }));
+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
+        });
     }
 }

package/dist/types/custom.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/custom.ts"],"sourcesContent":["import {\n  type SchemaOptions,\n  type TTransform,\n  type TUnsafe,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\ntype CustomDecode<T> = (value: any) => T\ntype CustomEncode<T> = (value: T) => any\n\nexport class CustomType<\n  T,\n  S = T,\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TTransform<TUnsafe<S>, T>, N, O, D> {\n  constructor(\n    protected readonly decode: CustomDecode<T>,\n    protected readonly encode: CustomEncode<T>,\n    options: SchemaOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault, decode, encode)\n  }\n\n  protected _constructSchema(\n    options: SchemaOptions,\n    decode: CustomDecode<T>,\n    encode: CustomEncode<T>,\n  ): TTransform<TUnsafe<S>, T> {\n    return Type.Transform(Type.Any(options) as unknown as TUnsafe<S>)\n      .Decode(decode)\n      .Encode(encode)\n  }\n\n  nullable() {\n    return new CustomType<T, S, true, O, D>(\n      this.decode,\n      this.encode,\n      ...this._with({ isNullable: true }),\n    )\n  }\n\n  optional() {\n    return new CustomType<T, S, N, true, D>(\n      this.decode,\n      this.encode,\n      ...this._with({ isOptional: true }),\n    )\n  }\n\n  nullish() {\n    return new CustomType<T, S, true, true, D>(\n      this.decode,\n      this.encode,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: T) {\n    return new CustomType<T, S, N, O, true>(\n      this.decode,\n      this.encode,\n      ...this._with({\n        options: { default: this.encode(value) },\n        hasDefault: true,\n      }),\n    )\n  }\n\n  description(description: string) {\n    return new CustomType<T, S, N, O, D>(\n      this.decode,\n      this.encode,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(...examples: [T, ...T[]]) {\n    return new CustomType<T, S, N, O, D>(\n      this.decode,\n      this.encode,\n      ...this._with({ options: { examples: examples.map(this.encode) } }),\n    )\n  }\n}\n"],"names":["Type","BaseType","CustomType","constructor","decode","encode","options","isNullable","isOptional","hasDefault","_constructSchema","Transform","Any","Decode","Encode","nullable","_with","optional","nullish","default","value","description","examples","map"],"mappings":"AAAA,SAIEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAAQ,YAAW;AAKpC,OAAO,MAAMC,mBAMHD;;;IACRE,YACE,AAAmBC,MAAuB,EAC1C,AAAmBC,MAAuB,EAC1CC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC,YAAYL,QAAQC;aAPxCD,SAAAA;aACAC,SAAAA;IAOrB;IAEUK,iBACRJ,OAAsB,EACtBF,MAAuB,EACvBC,MAAuB,EACI;QAC3B,OAAOL,KAAKW,SAAS,CAACX,KAAKY,GAAG,CAACN,UAC5BO,MAAM,CAACT,QACPU,MAAM,CAACT;IACZ;IAEAU,WAAW;QACT,OAAO,IAAIb,WACT,IAAI,CAACE,MAAM,EACX,IAAI,CAACC,MAAM,KACR,IAAI,CAACW,KAAK,CAAC;YAAET,YAAY;QAAK;IAErC;IAEAU,WAAW;QACT,OAAO,IAAIf,WACT,IAAI,CAACE,MAAM,EACX,IAAI,CAACC,MAAM,KACR,IAAI,CAACW,KAAK,CAAC;YAAER,YAAY;QAAK;IAErC;IAEAU,UAAU;QACR,OAAO,IAAIhB,WACT,IAAI,CAACE,MAAM,EACX,IAAI,CAACC,MAAM,KACR,IAAI,CAACW,KAAK,CAAC;YAAET,YAAY;YAAMC,YAAY;QAAK;IAEvD;IAEAW,QAAQC,KAAQ,EAAE;QAChB,OAAO,IAAIlB,WACT,IAAI,CAACE,MAAM,EACX,IAAI,CAACC,MAAM,KACR,IAAI,CAACW,KAAK,CAAC;YACZV,SAAS;gBAAEa,SAAS,IAAI,CAACd,MAAM,CAACe;YAAO;YACvCX,YAAY;QACd;IAEJ;IAEAY,YAAYA,WAAmB,EAAE;QAC/B,OAAO,IAAInB,WACT,IAAI,CAACE,MAAM,EACX,IAAI,CAACC,MAAM,KACR,IAAI,CAACW,KAAK,CAAC;YAAEV,SAAS;gBAAEe;YAAY;QAAE;IAE7C;IAEAC,SAAS,GAAGA,QAAqB,EAAE;QACjC,OAAO,IAAIpB,WACT,IAAI,CAACE,MAAM,EACX,IAAI,CAACC,MAAM,KACR,IAAI,CAACW,KAAK,CAAC;YAAEV,SAAS;gBAAEgB,UAAUA,SAASC,GAAG,CAAC,IAAI,CAAClB,MAAM;YAAE;QAAE;IAErE;AACF"}
+{"version":3,"sources":["../../../src/types/custom.ts"],"sourcesContent":["import {\n  type TAny,\n  type TTransform,\n  type TUnsafe,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\n\nexport type CustomTypeDecode<T> = (value: any) => T\nexport type CustomTypeEncode<T> = (value: T) => any\n\nexport abstract class TransformType<T, S = TAny> extends BaseType<\n  TTransform<TUnsafe<S>, T>\n> {\n  _!: ConstantType<this['schema']>\n}\n\nexport class CustomType<T, S = TAny> extends TransformType<T, S> {\n  static factory<T, S = TAny>(\n    decode: CustomTypeDecode<T>,\n    encode: CustomTypeEncode<T>,\n    schema = Type.Any() as unknown as TUnsafe<S>,\n  ) {\n    return new CustomType<T, S>(\n      Type.Transform(schema as unknown as TUnsafe<S>)\n        .Decode(decode)\n        .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;AAC1B,SAASC,QAAQ,QAA2B,YAAW;AAKvD,OAAO,MAAeC,sBAAmCD;IAGvDE,EAAgC;AAClC;AAEA,OAAO,MAAMC,mBAAgCF;IAC3C,OAAOG,QACLC,MAA2B,EAC3BC,MAA2B,EAC3BC,SAASR,KAAKS,GAAG,EAA2B,EAC5C;QACA,OAAO,IAAIL,WACTJ,KAAKU,SAAS,CAACF,QACZG,MAAM,CAACL,QACPM,MAAM,CAACL,SACV,CAAC,GACD;YAAEA;QAAO;IAEb;AACF"}

package/dist/types/date.js

@@ -0,0 +1,8 @@
+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);
+    }
+}

package/dist/types/date.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/types/date.ts"],"sourcesContent":["import { 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>(decode, encode)\n  }\n}\n"],"names":["CustomType","TransformType","decode","value","Date","encode","toISOString","DateType","factory"],"mappings":"AAAA,SAASA,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,CAAON,QAAQG;IAC1C;AACF"}

package/dist/types/enum.js

@@ -1,101 +1,17 @@
-import { Enum } from '@sinclair/typebox';
+import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class ObjectEnumType extends BaseType {
-    values;
-    constructor(values, options = {}, isNullable = false, isOptional = false, hasDefault = false){
-        super(options, isNullable, isOptional, hasDefault, values);
-        this.values = values;
-    }
-    _constructSchema(options, values) {
-        return Enum(values, options);
-    }
-    nullable() {
-        return new ObjectEnumType(this.values, ...this._with({
-            isNullable: true
-        }));
-    }
-    optional() {
-        return new ObjectEnumType(this.values, ...this._with({
-            isOptional: true
-        }));
-    }
-    nullish() {
-        return new ObjectEnumType(this.values, ...this._with({
-            isNullable: true,
-            isOptional: true
-        }));
-    }
-    default(value) {
-        return new ObjectEnumType(this.values, ...this._with({
-            options: {
-                default: value
-            },
-            hasDefault: true
-        }));
-    }
-    description(description) {
-        return new ObjectEnumType(this.values, ...this._with({
-            options: {
-                description
-            }
-        }));
-    }
-    examples(...examples) {
-        return new ObjectEnumType(this.values, ...this._with({
-            options: {
-                examples
-            }
-        }));
+    _;
+    static factory(values) {
+        return new ObjectEnumType(Type.Enum(values));
     }
 }
 export class EnumType extends BaseType {
-    values;
-    constructor(values, options = {}, isNullable = false, isOptional = false, hasDefault = false){
-        super(options, isNullable, isOptional, hasDefault, values);
-        this.values = values;
-    }
-    _constructSchema(options, values) {
-        return Enum(Object.fromEntries(values.map((k)=>[
-                k,
-                k
-            ])), options);
-    }
-    nullable() {
-        return new EnumType(this.values, ...this._with({
-            isNullable: true
-        }));
-    }
-    optional() {
-        return new EnumType(this.values, ...this._with({
-            isOptional: true
-        }));
-    }
-    nullish() {
-        return new EnumType(this.values, ...this._with({
-            isNullable: true,
-            isOptional: true
-        }));
-    }
-    default(value) {
-        return new EnumType(this.values, ...this._with({
-            options: {
-                default: value
-            },
-            hasDefault: true
-        }));
-    }
-    description(description) {
-        return new EnumType(this.values, ...this._with({
-            options: {
-                description
-            }
-        }));
-    }
-    examples(...examples) {
-        return new EnumType(this.values, ...this._with({
-            options: {
-                examples
-            }
-        }));
+    _;
+    static factory(values) {
+        return new EnumType(Type.Enum(Object.fromEntries(values.map((v)=>[
+                v,
+                v
+            ]))));
     }
 }

package/dist/types/enum.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/enum.ts"],"sourcesContent":["import { Enum, type SchemaOptions, type TEnum } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport type AnyObjectEnumType<T extends { [K in string]: K } = any> =\n  ObjectEnumType<T, boolean, boolean, boolean>\nexport class ObjectEnumType<\n  T extends { [K in string]: K },\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TEnum<T>, N, O, D> {\n  constructor(\n    private readonly values: T,\n    options: SchemaOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault, values)\n  }\n\n  protected _constructSchema(options: SchemaOptions, values: T): TEnum<T> {\n    return Enum(values, options)\n  }\n\n  nullable() {\n    return new ObjectEnumType(this.values, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new ObjectEnumType(this.values, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new ObjectEnumType(\n      this.values,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: keyof T) {\n    return new ObjectEnumType(\n      this.values,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new ObjectEnumType(\n      this.values,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(...examples: (keyof T)[]) {\n    return new ObjectEnumType(\n      this.values,\n      ...this._with({ options: { examples } }),\n    )\n  }\n}\n\nexport type AnyEnumType = EnumType<any, boolean, boolean, boolean>\nexport class EnumType<\n  T extends (string | number)[] = (string | number)[],\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TEnum<Record<string, T[number]>>, N, O, D> {\n  constructor(\n    private readonly values: [...T],\n    options: SchemaOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault, values)\n  }\n\n  protected _constructSchema(\n    options: SchemaOptions,\n    values: [...T],\n  ): TEnum<Record<string, T[number]>> {\n    return Enum(Object.fromEntries(values.map((k) => [k, k])), options)\n  }\n\n  nullable() {\n    return new EnumType(this.values, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new EnumType(this.values, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new EnumType(\n      this.values,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: T[number]) {\n    return new EnumType(\n      this.values,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new EnumType(\n      this.values,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(...examples: [T[number], ...T[number][]]) {\n    return new EnumType(this.values, ...this._with({ options: { examples } }))\n  }\n}\n"],"names":["Enum","BaseType","ObjectEnumType","constructor","values","options","isNullable","isOptional","hasDefault","_constructSchema","nullable","_with","optional","nullish","default","value","description","examples","EnumType","Object","fromEntries","map","k"],"mappings":"AAAA,SAASA,IAAI,QAAwC,oBAAmB;AACxE,SAASC,QAAQ,QAAQ,YAAW;AAIpC,OAAO,MAAMC,uBAKHD;;IACRE,YACE,AAAiBC,MAAS,EAC1BC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC,YAAYJ;aANlCA,SAAAA;IAOnB;IAEUK,iBAAiBJ,OAAsB,EAAED,MAAS,EAAY;QACtE,OAAOJ,KAAKI,QAAQC;IACtB;IAEAK,WAAW;QACT,OAAO,IAAIR,eAAe,IAAI,CAACE,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEL,YAAY;QAAK;IAC1E;IAEAM,WAAW;QACT,OAAO,IAAIV,eAAe,IAAI,CAACE,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEJ,YAAY;QAAK;IAC1E;IAEAM,UAAU;QACR,OAAO,IAAIX,eACT,IAAI,CAACE,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEL,YAAY;YAAMC,YAAY;QAAK;IAEvD;IAEAO,QAAQC,KAAc,EAAE;QACtB,OAAO,IAAIb,eACT,IAAI,CAACE,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAES,SAASC;YAAM;YAAGP,YAAY;QAAK;IAElE;IAEAQ,YAAYA,WAAmB,EAAE;QAC/B,OAAO,IAAId,eACT,IAAI,CAACE,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAEW;YAAY;QAAE;IAE7C;IAEAC,SAAS,GAAGA,QAAqB,EAAE;QACjC,OAAO,IAAIf,eACT,IAAI,CAACE,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAEY;YAAS;QAAE;IAE1C;AACF;AAGA,OAAO,MAAMC,iBAKHjB;;IACRE,YACE,AAAiBC,MAAc,EAC/BC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC,YAAYJ;aANlCA,SAAAA;IAOnB;IAEUK,iBACRJ,OAAsB,EACtBD,MAAc,EACoB;QAClC,OAAOJ,KAAKmB,OAAOC,WAAW,CAAChB,OAAOiB,GAAG,CAAC,CAACC,IAAM;gBAACA;gBAAGA;aAAE,IAAIjB;IAC7D;IAEAK,WAAW;QACT,OAAO,IAAIQ,SAAS,IAAI,CAACd,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEL,YAAY;QAAK;IACpE;IAEAM,WAAW;QACT,OAAO,IAAIM,SAAS,IAAI,CAACd,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEJ,YAAY;QAAK;IACpE;IAEAM,UAAU;QACR,OAAO,IAAIK,SACT,IAAI,CAACd,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEL,YAAY;YAAMC,YAAY;QAAK;IAEvD;IAEAO,QAAQC,KAAgB,EAAE;QACxB,OAAO,IAAIG,SACT,IAAI,CAACd,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAES,SAASC;YAAM;YAAGP,YAAY;QAAK;IAElE;IAEAQ,YAAYA,WAAmB,EAAE;QAC/B,OAAO,IAAIE,SACT,IAAI,CAACd,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAEW;YAAY;QAAE;IAE7C;IAEAC,SAAS,GAAGA,QAAqC,EAAE;QACjD,OAAO,IAAIC,SAAS,IAAI,CAACd,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAEY;YAAS;QAAE;IACzE;AACF"}
+{"version":3,"sources":["../../../src/types/enum.ts"],"sourcesContent":["import {\n  Enum,\n  type SchemaOptions,\n  type StaticDecode,\n  type TEnum,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\n\nexport class ObjectEnumType<\n  T extends { [K in string]: K } = { [K in string]: K },\n> extends BaseType<TEnum<T>> {\n  _!: ConstantType<this['schema']>\n\n  static factory<T extends { [K in string]: K }>(values: T) {\n    return new ObjectEnumType<T>(Type.Enum(values as any))\n  }\n}\n\nexport class EnumType<\n  T extends (string | number)[] = (string | number)[],\n> extends BaseType<TEnum<Record<string, T[number]>>> {\n  _!: ConstantType<this['schema']>\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    )\n  }\n}\n"],"names":["Type","BaseType","ObjectEnumType","_","factory","values","Enum","EnumType","Object","fromEntries","map","v"],"mappings":"AAAA,SAKEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAA2B,YAAW;AAEvD,OAAO,MAAMC,uBAEHD;IACRE,EAAgC;IAEhC,OAAOC,QAAwCC,MAAS,EAAE;QACxD,OAAO,IAAIH,eAAkBF,KAAKM,IAAI,CAACD;IACzC;AACF;AAEA,OAAO,MAAME,iBAEHN;IACRE,EAAgC;IAEhC,OAAOC,QAAuCC,MAAc,EAAE;QAC5D,OAAO,IAAIE,SACTP,KAAKM,IAAI,CAACE,OAAOC,WAAW,CAACJ,OAAOK,GAAG,CAAC,CAACC,IAAM;gBAACA;gBAAGA;aAAE;IAEzD;AACF"}

package/dist/types/literal.js

@@ -1,48 +1,8 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class LiteralType extends BaseType {
-    value;
-    constructor(value, options = {}, isNullable = false, isOptional = false, hasDefault = false){
-        super(options, isNullable, isOptional, hasDefault, value);
-        this.value = value;
-    }
-    _constructSchema(options, value) {
-        return Type.Literal(value, options);
-    }
-    nullable() {
-        return new LiteralType(this.value, this.options, true, this.isOptional);
-    }
-    optional() {
-        return new LiteralType(this.value, ...this._with({
-            isOptional: true
-        }));
-    }
-    nullish() {
-        return new LiteralType(this.value, ...this._with({
-            isNullable: true,
-            isOptional: true
-        }));
-    }
-    default(value = this.value) {
-        return new LiteralType(this.value, ...this._with({
-            options: {
-                default: value
-            },
-            hasDefault: true
-        }));
-    }
-    description(description) {
-        return new LiteralType(this.value, ...this._with({
-            options: {
-                description
-            }
-        }));
-    }
-    examples(...examples) {
-        return new LiteralType(this.value, ...this._with({
-            options: {
-                examples
-            }
-        }));
+    _;
+    static factory(value) {
+        return new LiteralType(Type.Literal(value));
     }
 }

package/dist/types/literal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/literal.ts"],"sourcesContent":["import {\n  Extends,\n  type SchemaOptions,\n  type TLiteral,\n  type TLiteralValue,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport type AnyLiteralType<T extends TLiteralValue = any> = LiteralType<\n  T,\n  boolean,\n  boolean,\n  boolean\n>\nexport class LiteralType<\n  T extends TLiteralValue,\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TLiteral<T>, N, O, D> {\n  constructor(\n    protected readonly value: T,\n    options: SchemaOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault, value)\n  }\n\n  protected _constructSchema(options: SchemaOptions, value: T): TLiteral<T> {\n    return Type.Literal(value, options)\n  }\n\n  nullable() {\n    return new LiteralType(this.value, this.options, true, this.isOptional)\n  }\n\n  optional() {\n    return new LiteralType(this.value, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new LiteralType(\n      this.value,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: T = this.value) {\n    return new LiteralType(\n      this.value,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new LiteralType(\n      this.value,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(...examples: [T, ...T[]]) {\n    return new LiteralType(this.value, ...this._with({ options: { examples } }))\n  }\n}\n"],"names":["Type","BaseType","LiteralType","constructor","value","options","isNullable","isOptional","hasDefault","_constructSchema","Literal","nullable","optional","_with","nullish","default","description","examples"],"mappings":"AAAA,SAKEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAAQ,YAAW;AAQpC,OAAO,MAAMC,oBAKHD;;IACRE,YACE,AAAmBC,KAAQ,EAC3BC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC,YAAYJ;aANhCA,QAAAA;IAOrB;IAEUK,iBAAiBJ,OAAsB,EAAED,KAAQ,EAAe;QACxE,OAAOJ,KAAKU,OAAO,CAACN,OAAOC;IAC7B;IAEAM,WAAW;QACT,OAAO,IAAIT,YAAY,IAAI,CAACE,KAAK,EAAE,IAAI,CAACC,OAAO,EAAE,MAAM,IAAI,CAACE,UAAU;IACxE;IAEAK,WAAW;QACT,OAAO,IAAIV,YAAY,IAAI,CAACE,KAAK,KAAK,IAAI,CAACS,KAAK,CAAC;YAAEN,YAAY;QAAK;IACtE;IAEAO,UAAU;QACR,OAAO,IAAIZ,YACT,IAAI,CAACE,KAAK,KACP,IAAI,CAACS,KAAK,CAAC;YAAEP,YAAY;YAAMC,YAAY;QAAK;IAEvD;IAEAQ,QAAQX,QAAW,IAAI,CAACA,KAAK,EAAE;QAC7B,OAAO,IAAIF,YACT,IAAI,CAACE,KAAK,KACP,IAAI,CAACS,KAAK,CAAC;YAAER,SAAS;gBAAEU,SAASX;YAAM;YAAGI,YAAY;QAAK;IAElE;IAEAQ,YAAYA,WAAmB,EAAE;QAC/B,OAAO,IAAId,YACT,IAAI,CAACE,KAAK,KACP,IAAI,CAACS,KAAK,CAAC;YAAER,SAAS;gBAAEW;YAAY;QAAE;IAE7C;IAEAC,SAAS,GAAGA,QAAqB,EAAE;QACjC,OAAO,IAAIf,YAAY,IAAI,CAACE,KAAK,KAAK,IAAI,CAACS,KAAK,CAAC;YAAER,SAAS;gBAAEY;YAAS;QAAE;IAC3E;AACF"}
+{"version":3,"sources":["../../../src/types/literal.ts"],"sourcesContent":["import { type TLiteral, type TLiteralValue, Type } from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\n\nexport class LiteralType<\n  T extends TLiteralValue = TLiteralValue,\n> extends BaseType<TLiteral<T>> {\n  _!: ConstantType<this['schema']>\n\n  static factory<T extends TLiteralValue>(value: T) {\n    return new LiteralType<T>(Type.Literal(value))\n  }\n}\n"],"names":["Type","BaseType","LiteralType","_","factory","value","Literal"],"mappings":"AAAA,SAA4CA,IAAI,QAAQ,oBAAmB;AAC3E,SAASC,QAAQ,QAA2B,YAAW;AAEvD,OAAO,MAAMC,oBAEHD;IACRE,EAAgC;IAEhC,OAAOC,QAAiCC,KAAQ,EAAE;QAChD,OAAO,IAAIH,YAAeF,KAAKM,OAAO,CAACD;IACzC;AACF"}

package/dist/types/never.js

@@ -1,31 +1,8 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class NeverType extends BaseType {
-    constructor(options = {}){
-        super(options, false, false, false);
-    }
-    _constructSchema(options) {
-        return Type.Never(options);
-    }
-    nullable() {
-        throw new Error('NeverType cannot be nullable');
-    }
-    optional() {
-        throw new Error('NeverType cannot be optional');
-    }
-    nullish() {
-        throw new Error('NeverType cannot be nullish');
-    }
-    default() {
-        throw new Error('NeverType cannot have a default value');
-    }
-    description(description) {
-        return new NeverType({
-            ...this.options,
-            description
-        });
-    }
-    examples() {
-        throw new Error('NeverType cannot have examples');
+    _;
+    static factory() {
+        return new NeverType(Type.Never());
     }
 }

package/dist/types/never.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/never.ts"],"sourcesContent":["import { type SchemaOptions, type TNever, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class NeverType<\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TNever, N, O, D> {\n  constructor(options: SchemaOptions = {}) {\n    super(options, false as N, false as O, false as D)\n  }\n\n  protected _constructSchema(options: SchemaOptions): TNever {\n    return Type.Never(options)\n  }\n\n  nullable(): NeverType<true, O, D> {\n    throw new Error('NeverType cannot be nullable')\n  }\n\n  optional(): NeverType<N, true, D> {\n    throw new Error('NeverType cannot be optional')\n  }\n\n  nullish(): NeverType<true, true, D> {\n    throw new Error('NeverType cannot be nullish')\n  }\n\n  default(): NeverType<N, O, true> {\n    throw new Error('NeverType cannot have a default value')\n  }\n\n  description(description: string): NeverType<N, O, D> {\n    return new NeverType({ ...this.options, description })\n  }\n\n  examples(): NeverType<N, O, D> {\n    throw new Error('NeverType cannot have examples')\n  }\n}\n"],"names":["Type","BaseType","NeverType","constructor","options","_constructSchema","Never","nullable","Error","optional","nullish","default","description","examples"],"mappings":"AAAA,SAA0CA,IAAI,QAAQ,oBAAmB;AACzE,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,kBAIHD;IACRE,YAAYC,UAAyB,CAAC,CAAC,CAAE;QACvC,KAAK,CAACA,SAAS,OAAY,OAAY;IACzC;IAEUC,iBAAiBD,OAAsB,EAAU;QACzD,OAAOJ,KAAKM,KAAK,CAACF;IACpB;IAEAG,WAAkC;QAChC,MAAM,IAAIC,MAAM;IAClB;IAEAC,WAAkC;QAChC,MAAM,IAAID,MAAM;IAClB;IAEAE,UAAoC;QAClC,MAAM,IAAIF,MAAM;IAClB;IAEAG,UAAiC;QAC/B,MAAM,IAAIH,MAAM;IAClB;IAEAI,YAAYA,WAAmB,EAAsB;QACnD,OAAO,IAAIV,UAAU;YAAE,GAAG,IAAI,CAACE,OAAO;YAAEQ;QAAY;IACtD;IAEAC,WAA+B;QAC7B,MAAM,IAAIL,MAAM;IAClB;AACF"}
+{"version":3,"sources":["../../../src/types/never.ts"],"sourcesContent":["import { type TNever, Type } from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\n\nexport class NeverType extends BaseType<TNever> {\n  _!: ConstantType<this['schema']>\n\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,QAA2B,YAAW;AAEvD,OAAO,MAAMC,kBAAkBD;IAC7BE,EAAgC;IAEhC,OAAOC,UAAU;QACf,OAAO,IAAIF,UAAUF,KAAKK,KAAK;IACjC;AACF"}