@nmtjs/type 0.2.1 → 0.3.1

package/dist/types/union.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/union.ts"],"sourcesContent":["import { type TIntersect, type TUnion, Type } from '@sinclair/typebox'\nimport type { UnionToTuple } from '../utils.ts'\nimport { BaseType, typeFinalSchema } from './base.ts'\n\nexport class UnionType<\n  T extends [BaseType, BaseType, ...BaseType[]] = [\n    BaseType,\n    BaseType,\n    ...BaseType[],\n  ],\n  N extends boolean = false,\n  O extends boolean = false,\n  // @ts-expect-error\n> extends BaseType<TUnion<UnionToTuple<T[number][typeFinal]>>, N, O> {\n  constructor(\n    readonly types: T,\n    nullable: N = false as N,\n    optional: O = false as O,\n  ) {\n    super(\n      Type.Union(types.map((t) => t[typeFinalSchema])) as any,\n      nullable,\n      optional,\n    )\n  }\n\n  nullable() {\n    const [_, ...args] = this._nullable()\n    return new UnionType(this.types, ...args)\n  }\n\n  optional() {\n    const [_, ...args] = this._optional()\n    return new UnionType(this.types, ...args)\n  }\n\n  nullish() {\n    const [_, ...args] = this._nullish()\n    return new UnionType(this.types, ...args)\n  }\n}\n\nexport class IntersactionType<\n  T extends [BaseType, BaseType, ...BaseType[]] = [\n    BaseType,\n    BaseType,\n    ...BaseType[],\n  ],\n  N extends boolean = false,\n  O extends boolean = false,\n  // @ts-expect-error\n> extends BaseType<TIntersect<UnionToTuple<T[number][typeFinal]>>, N, O> {\n  constructor(\n    readonly types: T,\n    nullable: N = false as N,\n    optional: O = false as O,\n  ) {\n    super(\n      Type.Intersect(types.map((t) => t[typeFinalSchema])) as any,\n      nullable,\n      optional,\n    )\n  }\n\n  nullable() {\n    const [_, ...args] = this._nullable()\n    return new IntersactionType(this.types, ...args)\n  }\n\n  optional() {\n    const [_, ...args] = this._optional()\n    return new IntersactionType(this.types, ...args)\n  }\n\n  nullish() {\n    const [_, ...args] = this._nullish()\n    return new IntersactionType(this.types, ...args)\n  }\n}\n"],"names":["Type","BaseType","typeFinalSchema","UnionType","constructor","types","nullable","optional","Union","map","t","_","args","_nullable","_optional","nullish","_nullish","IntersactionType","Intersect"],"mappings":"AAAA,SAAuCA,IAAI,QAAQ,oBAAmB;AAEtE,SAASC,QAAQ,EAAEC,eAAe,QAAQ,YAAW;AAErD,OAAO,MAAMC,kBASHF;;IACRG,YACE,AAASC,KAAQ,EACjBC,WAAc,KAAU,EACxBC,WAAc,KAAU,CACxB;QACA,KAAK,CACHP,KAAKQ,KAAK,CAACH,MAAMI,GAAG,CAAC,CAACC,IAAMA,CAAC,CAACR,gBAAgB,IAC9CI,UACAC;aAPOF,QAAAA;IASX;IAEAC,WAAW;QACT,MAAM,CAACK,GAAG,GAAGC,KAAK,GAAG,IAAI,CAACC,SAAS;QACnC,OAAO,IAAIV,UAAU,IAAI,CAACE,KAAK,KAAKO;IACtC;IAEAL,WAAW;QACT,MAAM,CAACI,GAAG,GAAGC,KAAK,GAAG,IAAI,CAACE,SAAS;QACnC,OAAO,IAAIX,UAAU,IAAI,CAACE,KAAK,KAAKO;IACtC;IAEAG,UAAU;QACR,MAAM,CAACJ,GAAG,GAAGC,KAAK,GAAG,IAAI,CAACI,QAAQ;QAClC,OAAO,IAAIb,UAAU,IAAI,CAACE,KAAK,KAAKO;IACtC;AACF;AAEA,OAAO,MAAMK,yBASHhB;;IACRG,YACE,AAASC,KAAQ,EACjBC,WAAc,KAAU,EACxBC,WAAc,KAAU,CACxB;QACA,KAAK,CACHP,KAAKkB,SAAS,CAACb,MAAMI,GAAG,CAAC,CAACC,IAAMA,CAAC,CAACR,gBAAgB,IAClDI,UACAC;aAPOF,QAAAA;IASX;IAEAC,WAAW;QACT,MAAM,CAACK,GAAG,GAAGC,KAAK,GAAG,IAAI,CAACC,SAAS;QACnC,OAAO,IAAII,iBAAiB,IAAI,CAACZ,KAAK,KAAKO;IAC7C;IAEAL,WAAW;QACT,MAAM,CAACI,GAAG,GAAGC,KAAK,GAAG,IAAI,CAACE,SAAS;QACnC,OAAO,IAAIG,iBAAiB,IAAI,CAACZ,KAAK,KAAKO;IAC7C;IAEAG,UAAU;QACR,MAAM,CAACJ,GAAG,GAAGC,KAAK,GAAG,IAAI,CAACI,QAAQ;QAClC,OAAO,IAAIC,iBAAiB,IAAI,CAACZ,KAAK,KAAKO;IAC7C;AACF"}
+{"version":3,"sources":["../../../src/types/union.ts"],"sourcesContent":["import {\n  type SchemaOptions,\n  type TIntersect,\n  type TUnion,\n  Type,\n  // type UnionToTuple,\n} from '@sinclair/typebox'\nimport type { typeStatic } from '../constants.ts'\nimport type { UnionToTuple } from '../utils.ts'\nimport { BaseType, getTypeSchema } from './base.ts'\n\nexport class UnionType<\n  T extends [BaseType, BaseType, ...BaseType[]] = [\n    BaseType,\n    BaseType,\n    ...BaseType[],\n  ],\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<\n  //@ts-expect-error\n  TUnion<UnionToTuple<T[number][typeStatic]['schema']>>,\n  N,\n  O,\n  D\n> {\n  constructor(\n    readonly types: 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)\n  }\n\n  protected _constructSchema(\n    options: SchemaOptions,\n    //@ts-expect-error\n  ): TUnion<UnionToTuple<T[number][typeStatic]['schema']>> {\n    return Type.Union(this.types.map(getTypeSchema), options) as any\n  }\n\n  nullable() {\n    return new UnionType(this.types, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new UnionType(this.types, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new UnionType(\n      this.types,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: this[typeStatic]['encoded']) {\n    return new UnionType(\n      this.types,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new UnionType(\n      this.types,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(\n    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]\n  ) {\n    return new UnionType(this.types, ...this._with({ options: { examples } }))\n  }\n}\n\nexport class IntersactionType<\n  T extends [BaseType, BaseType, ...BaseType[]] = [\n    BaseType,\n    BaseType,\n    ...BaseType[],\n  ],\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<\n  // @ts-expect-error\n  TIntersect<UnionToTuple<T[number][typeStatic]['schema']>>,\n  N,\n  O,\n  D\n> {\n  constructor(\n    readonly types: 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)\n  }\n\n  protected _constructSchema(\n    options: SchemaOptions,\n    // @ts-expect-error\n  ): TIntersect<UnionToTuple<T[number][typeStatic]['schema']>> {\n    return Type.Intersect(this.types.map(getTypeSchema), options) as any\n  }\n\n  nullable() {\n    return new IntersactionType(this.types, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new IntersactionType(this.types, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new IntersactionType(\n      this.types,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: this[typeStatic]['encoded']) {\n    return new IntersactionType(\n      this.types,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new IntersactionType(\n      this.types,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(\n    ...values: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]\n  ) {\n    return new IntersactionType(\n      this.types,\n      ...this._with({ options: { examples: values } }),\n    )\n  }\n}\n"],"names":["Type","BaseType","getTypeSchema","UnionType","constructor","types","options","isNullable","isOptional","hasDefault","_constructSchema","Union","map","nullable","_with","optional","nullish","default","value","description","examples","IntersactionType","Intersect","values"],"mappings":"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"}

package/package.json

@@ -21,12 +21,12 @@
   "peerDependencies": {
     "@sinclair/typebox": "^0.33.7",
     "temporal-polyfill": "^0.2.5",
-    "@nmtjs/common": "0.2.1"
+    "@nmtjs/common": "0.3.1"
   },
   "devDependencies": {
     "@sinclair/typebox": "^0.33.7",
     "temporal-polyfill": "^0.2.5",
-    "@nmtjs/common": "0.2.1"
+    "@nmtjs/common": "0.3.1"
   },
   "files": [
     "src",
@@ -35,7 +35,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.2.1",
+  "version": "0.3.1",
   "scripts": {
     "build": "neemata-build -p neutral --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"

package/src/compiler.ts

@@ -3,7 +3,7 @@ import {
   type ValueErrorIterator,
 } from '@sinclair/typebox/compiler'
 import { Value } from '@sinclair/typebox/value'
-import { type BaseType, typeFinalSchema } from './types/base.ts'
+import { type BaseType, getTypeSchema } from './types/base.ts'
 
 export type Compiled = {
   check: (val: unknown) => boolean
@@ -19,7 +19,7 @@ export type Compiled = {
 }
 
 const compileType = (type: BaseType) => {
-  const schema = type[typeFinalSchema]
+  const schema = getTypeSchema(type)
   const compiled = TypeCompiler.Compile(schema)
   const prepare = (value: any) => {
     for (const fn of [Value.Clean, Value.Default]) {

package/src/constants.ts

@@ -0,0 +1,5 @@
+export const typeStatic: unique symbol = Symbol()
+export type typeStatic = typeof typeStatic
+
+export const typeSchema: unique symbol = Symbol()
+export type typeSchema = typeof typeSchema

package/src/index.ts

@@ -1,9 +1,9 @@
 import type { TLiteralValue } from '@sinclair/typebox'
 import { ArrayType } from './types/array.ts'
-import type { BaseType, staticType } from './types/base.ts'
+import type { BaseType } from './types/base.ts'
 import { BooleanType } from './types/boolean.ts'
 import { CustomType } from './types/custom.ts'
-import { DateTimeType, DateType } from './types/datetime.ts'
+import { DateType } from './types/datetime.ts'
 import { EnumType, NativeEnumType } from './types/enum.ts'
 import { LiteralType } from './types/literal.ts'
 import { IntegerType, NumberType } from './types/number.ts'
@@ -11,6 +11,7 @@ import { ObjectType } from './types/object.ts'
 import { StringType } from './types/string.ts'
 import { IntersactionType, UnionType } from './types/union.ts'
 
+import type { typeStatic } from './constants.ts'
 // register ajv formats
 import { register } from './formats.ts'
 import { AnyType } from './types/any.ts'
@@ -29,7 +30,6 @@ export {
   ArrayType,
   BooleanType,
   CustomType,
-  DateTimeType,
   DateType,
   EnumType,
   LiteralType,
@@ -45,8 +45,8 @@ export {
 
 export namespace t {
   export namespace infer {
-    export type decoded<T extends BaseType> = T[staticType]['decoded']
-    export type encoded<T extends BaseType> = T[staticType]['encoded']
+    export type decoded<T extends BaseType> = T[typeStatic]['decoded']
+    export type encoded<T extends BaseType> = T[typeStatic]['encoded']
   }
   export const never = () => new NeverType()
   export const boolean = () => new BooleanType()
@@ -60,7 +60,6 @@ export namespace t {
   export const arrayEnum = <T extends (string | number)[]>(enumLike: [...T]) =>
     new EnumType(enumLike)
   export const date = () => new DateType()
-  export const datetime = () => new DateTimeType()
   export const array = <T extends BaseType>(element: T) =>
     new ArrayType(element)
   export const object = <T extends Record<string, BaseType>>(properties: T) =>

package/src/temporal.ts

@@ -1,4 +1,4 @@
-import type { t } from './index.ts'
+import { t as baseT } from './index.ts'
 import {
   DurationType,
   PlainDateTimeType,
@@ -9,7 +9,7 @@ import {
   ZonedDateTimeType,
 } from './types/temporal.ts'
 
-export function extend<T extends typeof t>(value: T) {
+function extend<T extends typeof baseT>(value: T) {
   return Object.assign({}, value, {
     temporal: {
       plainDate: () => new PlainDateType(),
@@ -23,6 +23,8 @@ export function extend<T extends typeof t>(value: T) {
   })
 }
 
+export const t = extend(baseT)
+
 export {
   DurationType,
   PlainDateTimeType,

package/src/types/any.ts

@@ -1,27 +1,50 @@
-import { type TAny, Type } from '@sinclair/typebox'
+import { type SchemaOptions, type TAny, Type } from '@sinclair/typebox'
 import { BaseType } from './base.ts'
 
 export class AnyType<
   N extends boolean = false,
   O extends boolean = false,
-> extends BaseType<TAny, N, O> {
+  D extends boolean = false,
+> extends BaseType<TAny, N, O, D, SchemaOptions> {
   constructor(
-    schema = Type.Any(),
-    nullable: N = false as N,
-    optional: O = false as O,
+    options: SchemaOptions = {},
+    isNullable: N = false as N,
+    isOptional: O = false as O,
+    hasDefault: D = false as D,
   ) {
-    super(schema, nullable, optional)
+    super(options, isNullable, isOptional, hasDefault)
+  }
+
+  protected _constructSchema(options: SchemaOptions): TAny {
+    return Type.Any(options)
   }
 
   nullable() {
-    return new AnyType(...this._nullable())
+    return new AnyType(...this._with({ isNullable: true }))
   }
 
   optional() {
-    return new AnyType(...this._optional())
+    return new AnyType(...this._with({ isOptional: true }))
   }
 
   nullish() {
-    return new AnyType(...this._nullish())
+    return new AnyType(...this._with({ isNullable: true, isOptional: true }))
+  }
+
+  default(value: any) {
+    return new AnyType(
+      ...this._with({
+        options: { default: value },
+        hasDefault: true,
+      }),
+    )
+  }
+
+  description(description: string) {
+    return new AnyType(...this._with({ options: { description } }))
+  }
+
+  examples(...examples: [any, ...any[]]) {
+    return new AnyType(...this._with({ options: { examples } }))
   }
 }

package/src/types/array.ts

@@ -1,66 +1,97 @@
 import { type ArrayOptions, type TArray, Type } from '@sinclair/typebox'
-import { BaseType, typeFinalSchema } from './base.ts'
+import type { typeStatic } from '../constants.ts'
+import { BaseType, getTypeSchema } from './base.ts'
 
 export class ArrayType<
   T extends BaseType = BaseType,
   N extends boolean = false,
   O extends boolean = false,
-> extends BaseType<TArray<T[typeFinalSchema]>, N, O> {
+  D extends boolean = false,
+> extends BaseType<TArray<T[typeStatic]['schema']>, N, O, D, ArrayOptions> {
   constructor(
     readonly element: T,
-    readonly options: ArrayOptions = {},
-    nullable: N = false as N,
-    optional: O = false as O,
+    options: ArrayOptions = {},
+    isNullable: N = false as N,
+    isOptional: O = false as O,
+    hasDefault: D = false as D,
   ) {
-    super(Type.Array(element[typeFinalSchema]), nullable, optional)
+    super(options, isNullable, isOptional, hasDefault, element)
+  }
+
+  protected _constructSchema(
+    options: ArrayOptions,
+    element: T,
+  ): TArray<T[typeStatic]['schema']> {
+    return Type.Array(getTypeSchema(element), options)
   }
 
   nullable() {
-    const [_, ...args] = this._nullable()
-    return new ArrayType(this.element, this.options, ...args)
+    return new ArrayType(this.element, ...this._with({ isNullable: true }))
   }
 
   optional() {
-    const [_, ...args] = this._optional()
-    return new ArrayType(this.element, this.options, ...args)
+    return new ArrayType(this.element, ...this._with({ isOptional: true }))
   }
 
   nullish() {
-    const [_, ...args] = this._nullish()
-    return new ArrayType(this.element, this.options, ...args)
+    return new ArrayType(
+      this.element,
+      ...this._with({ isNullable: true, isOptional: true }),
+    )
+  }
+
+  default(value: this[typeStatic]['encoded']) {
+    return new ArrayType(
+      this.element,
+      ...this._with({
+        options: { default: value },
+        hasDefault: true,
+      }),
+    )
+  }
+
+  description(description: string) {
+    return new ArrayType(
+      this.element,
+      ...this._with({ options: { description } }),
+    )
+  }
+
+  examples(
+    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]
+  ) {
+    return new ArrayType(
+      this.element,
+      ...this._with({
+        options: { example: examples[0], examples },
+      }),
+    )
   }
 
   min(value: number) {
     return new ArrayType(
       this.element,
-      {
-        ...this.options,
-        minItems: value,
-      },
-      ...this._isNullableOptional,
+      ...this._with({
+        options: { minItems: value },
+      }),
     )
   }
 
   max(value: number) {
     return new ArrayType(
       this.element,
-      {
-        ...this.options,
-        maxItems: value,
-      },
-      ...this._isNullableOptional,
+      ...this._with({
+        options: { maxItems: value },
+      }),
     )
   }
 
   length(value: number) {
     return new ArrayType(
       this.element,
-      {
-        ...this.options,
-        minItems: value,
-        maxItems: value,
-      },
-      ...this._isNullableOptional,
+      ...this._with({
+        options: { minItems: value, maxItems: value },
+      }),
     )
   }
 }

package/src/types/base.ts

@@ -1,4 +1,5 @@
 import {
+  type SchemaOptions,
   type StaticDecode,
   type StaticEncode,
   type TAny,
@@ -6,32 +7,15 @@ import {
   type TSchema,
   Type,
 } from '@sinclair/typebox'
+import { typeSchema, typeStatic } from '../constants.ts'
 import { Nullable, type TNullable } from '../schemas/nullable.ts'
 
-export const typeSchema: unique symbol = Symbol()
-export type typeSchema = typeof typeSchema
-
-export const typeOptions: unique symbol = Symbol()
-export type typeOptions = typeof typeOptions
-
-export const typeOptional: unique symbol = Symbol()
-export type typeOptional = typeof typeOptional
-
-export const typeNullable: unique symbol = Symbol()
-export type typeNullable = typeof typeNullable
-
-export const staticType: unique symbol = Symbol()
-export type staticType = typeof staticType
-
-export const typeFinalSchema: unique symbol = Symbol()
-export type typeFinalSchema = typeof typeFinalSchema
-
 type ResolveNullable<T extends TSchema, Is extends boolean> = Is extends true
-  ? T | TNullable<T>
+  ? TNullable<T>
   : T
 
 type ResolveOptional<T extends TSchema, Is extends boolean> = Is extends true
-  ? T | TOptional<T>
+  ? TOptional<T>
   : T
 
 type Resolve<
@@ -41,118 +25,81 @@ type Resolve<
 > = ResolveOptional<ResolveNullable<Schema, IsNullable>, IsOptional>
 
 export abstract class BaseType<
-  Schema extends TSchema = any,
+  Schema extends TSchema = TSchema,
   IsNullable extends boolean = boolean,
   IsOptional extends boolean = boolean,
-  Final extends Resolve<Schema, IsNullable, IsOptional> = Resolve<
-    Schema,
-    IsNullable,
-    IsOptional
-  >,
+  HasDefault extends boolean = boolean,
+  Options extends SchemaOptions = SchemaOptions,
 > {
-  [typeSchema]: Schema;
-  [typeNullable]: IsNullable;
-  [typeOptional]: IsOptional;
+  protected abstract _constructSchema(
+    options: Options,
+    ...constructArgs: any[]
+  ): Schema
 
-  [staticType]!: {
-    final: Final
+  [typeStatic]!: {
+    schema: Resolve<Schema, IsNullable, IsOptional>
     isOptional: IsOptional
     isNullable: IsNullable
-    encoded: StaticEncode<Final>
-    decoded: StaticDecode<Final>
+    hasDefault: HasDefault
+    encoded: StaticEncode<Resolve<Schema, IsNullable, IsOptional>>
+    decoded: StaticDecode<
+      Resolve<Schema, IsNullable, HasDefault extends false ? false : IsOptional>
+    >
   }
 
   constructor(
-    schema: Schema,
-    nullable: IsNullable = false as IsNullable,
-    optional: IsOptional = false as IsOptional,
+    protected options: Options = {} as Options,
+    protected isNullable: IsNullable = false as IsNullable,
+    protected isOptional: IsOptional = false as IsOptional,
+    protected hasDefault: HasDefault = false as HasDefault,
+    ...contstructArgs: any[]
   ) {
-    this[typeSchema] = schema
-    this[typeNullable] = nullable
-    this[typeOptional] = optional
-  }
-
-  get [typeFinalSchema](): Final {
-    let schema: TSchema = this._schema
-    if (this._isNullable) {
+    let schema: TSchema = this._constructSchema(options, ...contstructArgs)
+    if (this.isNullable) {
       schema = Nullable(schema)
     }
-    if (this._isOptional) {
+    if (this.isOptional) {
       schema = Type.Optional(schema)
     }
-    return schema as Final
-  }
-
-  protected get _schema() {
-    return this[typeSchema]
-  }
-
-  protected get _isNullable(): IsNullable {
-    return this[typeNullable]
-  }
-
-  protected get _isOptional(): IsOptional {
-    return this[typeOptional]
-  }
-
-  protected get _isNullableOptional(): [IsNullable, IsOptional] {
-    return [this._isNullable, this._isOptional]
-  }
-
-  protected _contructSelf<T extends any[]>(...args: T) {
-    return args
-  }
-
-  protected _nullable() {
-    return this._contructSelf(this._schema, true as const, this[typeOptional])
+    this[typeSchema] = schema as Schema
   }
+  protected [typeSchema]: Schema
 
-  protected _optional() {
-    return this._contructSelf(this._schema, this[typeNullable], true as const)
+  protected get _args(): [IsNullable, IsOptional, HasDefault] {
+    return [this.isNullable, this.isOptional, this.hasDefault]
   }
 
-  protected _nullish() {
-    return this._contructSelf(this._schema, true as const, true as const)
+  protected _with<
+    _IsNullable extends boolean = IsNullable,
+    _IsOptional extends boolean = IsOptional,
+    _HasDefault extends boolean = HasDefault,
+  >({
+    options = this.options as Options,
+    isNullable = this.isNullable as unknown as _IsNullable,
+    isOptional = this.isOptional as unknown as _IsOptional,
+    hasDefault = this.hasDefault as unknown as _HasDefault,
+  }: {
+    options?: Options
+    isNullable?: _IsNullable
+    isOptional?: _IsOptional
+    hasDefault?: _HasDefault
+  } = {}): [Options, _IsNullable, _IsOptional, _HasDefault] {
+    return [{ ...this.options, ...options }, isNullable, isOptional, hasDefault]
   }
 
-  abstract nullable(): BaseType<Schema, true, IsOptional>
-  abstract optional(): BaseType<Schema, IsNullable, true>
-  abstract nullish(): BaseType<Schema, true, true>
-
-  default(value: StaticDecode<Schema>): this {
-    return this._contructSelf(
-      {
-        ...this._schema,
-        default: value,
-      },
-      this[typeNullable],
-      this[typeOptional],
-    ) as unknown as this
-  }
-
-  description(description: string): this {
-    return this._contructSelf(
-      {
-        ...this._schema,
-        description,
-      },
-      this[typeNullable],
-      this[typeOptional],
-    ) as unknown as this
-  }
-
-  examples(...examples: StaticDecode<Schema>[]): this {
-    return this._contructSelf(
-      {
-        ...this._schema,
-        examples,
-      },
-      this[typeNullable],
-      this[typeOptional],
-    ) as unknown as this
-  }
+  abstract optional(): BaseType<Schema, IsNullable, true, HasDefault>
+  abstract nullish(): BaseType<Schema, true, true, HasDefault>
+  abstract default(value: any): BaseType<Schema, IsNullable, IsOptional, true>
+  abstract description(
+    value: string,
+  ): BaseType<Schema, IsNullable, IsOptional, HasDefault>
+  abstract examples(
+    ...values: any[]
+  ): BaseType<Schema, IsNullable, IsOptional, HasDefault>
 }
 
-export function getTypeSchema<T extends BaseType>(type: T): T[typeFinalSchema] {
-  return type[typeFinalSchema]
+export function getTypeSchema<T extends BaseType>(
+  type: T,
+): T[typeStatic]['schema'] {
+  return type[typeSchema]
 }

package/src/types/boolean.ts

@@ -1,27 +1,49 @@
-import { type TBoolean, Type } from '@sinclair/typebox'
+import { type SchemaOptions, type TBoolean, Type } from '@sinclair/typebox'
 import { BaseType } from './base.ts'
 
 export class BooleanType<
   N extends boolean = false,
   O extends boolean = false,
-> extends BaseType<TBoolean, N, O> {
+  D extends boolean = false,
+> extends BaseType<TBoolean, N, O, D> {
   constructor(
-    schema: TBoolean = Type.Boolean(),
-    nullable: N = false as N,
-    optional: O = false as O,
+    options: SchemaOptions = {},
+    isNullable: N = false as N,
+    isOptional: O = false as O,
+    hasDefault: D = false as D,
   ) {
-    super(schema, nullable, optional)
+    super(options, isNullable, isOptional, hasDefault)
+  }
+
+  protected _constructSchema(options: SchemaOptions): TBoolean {
+    return Type.Boolean(options)
   }
 
   nullable() {
-    return new BooleanType(...this._nullable())
+    return new BooleanType(...this._with({ isNullable: true }))
   }
 
   optional() {
-    return new BooleanType(...this._optional())
+    return new BooleanType(...this._with({ isOptional: true }))
   }
 
   nullish() {
-    return new BooleanType(...this._nullish())
+    return new BooleanType(
+      ...this._with({ isNullable: true, isOptional: true }),
+    )
+  }
+
+  default(value: boolean) {
+    return new BooleanType(
+      ...this._with({ options: { default: value }, hasDefault: true }),
+    )
+  }
+
+  description(description: string) {
+    return new BooleanType(...this._with({ options: { description } }))
+  }
+
+  examples(...examples: [boolean, ...boolean[]]) {
+    return new BooleanType(...this._with({ options: { examples } }))
   }
 }