@nmtjs/type 0.4.7 → 0.5.0

package/src/types/enum.ts

@@ -1,119 +1,30 @@
-import { Enum, type SchemaOptions, type TEnum } from '@sinclair/typebox'
-import { BaseType } from './base.ts'
+import {
+  Enum,
+  type SchemaOptions,
+  type StaticDecode,
+  type TEnum,
+  Type,
+} from '@sinclair/typebox'
+import { BaseType, type ConstantType } from './base.ts'
 
-export type AnyObjectEnumType<T extends { [K in string]: K } = any> =
-  ObjectEnumType<T, boolean, boolean, boolean>
 export class ObjectEnumType<
-  T extends { [K in string]: K },
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TEnum<T>, N, O, D> {
-  constructor(
-    private readonly values: T,
-    options: SchemaOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault, values)
-  }
-
-  protected _constructSchema(options: SchemaOptions, values: T): TEnum<T> {
-    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: keyof T) {
-    return new ObjectEnumType(
-      this.values,
-      ...this._with({ options: { default: value }, hasDefault: true }),
-    )
-  }
-
-  description(description: string) {
-    return new ObjectEnumType(
-      this.values,
-      ...this._with({ options: { description } }),
-    )
-  }
+  T extends { [K in string]: K } = { [K in string]: K },
+> extends BaseType<TEnum<T>> {
+  _!: ConstantType<this['schema']>
 
-  examples(...examples: (keyof T)[]) {
-    return new ObjectEnumType(
-      this.values,
-      ...this._with({ options: { examples } }),
-    )
+  static factory<T extends { [K in string]: K }>(values: T) {
+    return new ObjectEnumType<T>(Type.Enum(values as any))
   }
 }
 
-export type AnyEnumType = EnumType<any, boolean, boolean, boolean>
 export class EnumType<
   T extends (string | number)[] = (string | number)[],
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TEnum<Record<string, T[number]>>, N, O, D> {
-  constructor(
-    private readonly values: [...T],
-    options: SchemaOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault, values)
-  }
-
-  protected _constructSchema(
-    options: SchemaOptions,
-    values: [...T],
-  ): TEnum<Record<string, T[number]>> {
-    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 }))
-  }
+> extends BaseType<TEnum<Record<string, T[number]>>> {
+  _!: ConstantType<this['schema']>
 
-  nullish() {
-    return new EnumType(
-      this.values,
-      ...this._with({ isNullable: true, isOptional: true }),
+  static factory<T extends (string | number)[]>(values: [...T]) {
+    return new EnumType<T>(
+      Type.Enum(Object.fromEntries(values.map((v) => [v, v])) as any),
     )
   }
-
-  default(value: T[number]) {
-    return new EnumType(
-      this.values,
-      ...this._with({ options: { default: value }, hasDefault: true }),
-    )
-  }
-
-  description(description: string) {
-    return new EnumType(
-      this.values,
-      ...this._with({ options: { description } }),
-    )
-  }
-
-  examples(...examples: [T[number], ...T[number][]]) {
-    return new EnumType(this.values, ...this._with({ options: { examples } }))
-  }
 }

package/src/types/literal.ts

@@ -1,68 +1,12 @@
-import {
-  Extends,
-  type SchemaOptions,
-  type TLiteral,
-  type TLiteralValue,
-  Type,
-} from '@sinclair/typebox'
-import { BaseType } from './base.ts'
+import { type TLiteral, type TLiteralValue, Type } from '@sinclair/typebox'
+import { BaseType, type ConstantType } from './base.ts'
 
-export type AnyLiteralType<T extends TLiteralValue = any> = LiteralType<
-  T,
-  boolean,
-  boolean,
-  boolean
->
 export class LiteralType<
-  T extends TLiteralValue,
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TLiteral<T>, N, O, D> {
-  constructor(
-    protected readonly value: T,
-    options: SchemaOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault, value)
-  }
-
-  protected _constructSchema(options: SchemaOptions, value: T): TLiteral<T> {
-    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: T = this.value) {
-    return new LiteralType(
-      this.value,
-      ...this._with({ options: { default: value }, hasDefault: true }),
-    )
-  }
-
-  description(description: string) {
-    return new LiteralType(
-      this.value,
-      ...this._with({ options: { description } }),
-    )
-  }
+  T extends TLiteralValue = TLiteralValue,
+> extends BaseType<TLiteral<T>> {
+  _!: ConstantType<this['schema']>
 
-  examples(...examples: [T, ...T[]]) {
-    return new LiteralType(this.value, ...this._with({ options: { examples } }))
+  static factory<T extends TLiteralValue>(value: T) {
+    return new LiteralType<T>(Type.Literal(value))
   }
 }

package/src/types/never.ts

@@ -1,40 +1,10 @@
-import { type SchemaOptions, type TNever, Type } from '@sinclair/typebox'
-import { BaseType } from './base.ts'
+import { type TNever, Type } from '@sinclair/typebox'
+import { BaseType, type ConstantType } from './base.ts'
 
-export class NeverType<
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TNever, N, O, D> {
-  constructor(options: SchemaOptions = {}) {
-    super(options, false as N, false as O, false as D)
-  }
-
-  protected _constructSchema(options: SchemaOptions): TNever {
-    return Type.Never(options)
-  }
-
-  nullable(): NeverType<true, O, D> {
-    throw new Error('NeverType cannot be nullable')
-  }
-
-  optional(): NeverType<N, true, D> {
-    throw new Error('NeverType cannot be optional')
-  }
-
-  nullish(): NeverType<true, true, D> {
-    throw new Error('NeverType cannot be nullish')
-  }
-
-  default(): NeverType<N, O, true> {
-    throw new Error('NeverType cannot have a default value')
-  }
-
-  description(description: string): NeverType<N, O, D> {
-    return new NeverType({ ...this.options, description })
-  }
+export class NeverType extends BaseType<TNever> {
+  _!: ConstantType<this['schema']>
 
-  examples(): NeverType<N, O, D> {
-    throw new Error('NeverType cannot have examples')
+  static factory() {
+    return new NeverType(Type.Never())
   }
 }

package/src/types/number.ts

@@ -1,7 +1,11 @@
 import {
+  type BigIntOptions,
   type IntegerOptions,
   type NumberOptions,
+  type Static,
+  type StaticDecode,
   type StringOptions,
+  type TBigInt,
   type TInteger,
   type TNumber,
   type TString,
@@ -9,50 +13,14 @@ import {
   Type,
   TypeBoxError,
 } from '@sinclair/typebox'
-import { BaseType } from './base.ts'
-
-export class NumberType<
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TNumber, N, O, D, NumberOptions> {
-  constructor(
-    protected readonly options: NumberOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault)
-  }
-
-  protected _constructSchema(options: NumberOptions): TNumber {
-    return Type.Number(options)
-  }
-
-  nullable() {
-    return new NumberType(...this._with({ isNullable: true }))
-  }
-
-  optional() {
-    return new NumberType(...this._with({ isOptional: true }))
-  }
-
-  nullish() {
-    return new NumberType(...this._with({ isNullable: true, isOptional: true }))
-  }
-
-  default(value: number) {
-    return new NumberType(
-      ...this._with({ options: { default: value }, hasDefault: true }),
-    )
-  }
+import { BaseType, type ConstantType } from './base.ts'
+import { CustomType, TransformType } from './custom.ts'
 
-  description(description: string) {
-    return new NumberType(...this._with({ options: { description } }))
-  }
+export class NumberType extends BaseType<TNumber, { options: NumberOptions }> {
+  _!: ConstantType<this['schema']>
 
-  examples(...examples: [number, ...number[]]) {
-    return new NumberType(...this._with({ options: { examples } }))
+  static factory(options: NumberOptions = {}) {
+    return new NumberType(Type.Number(options), { options })
   }
 
   positive() {
@@ -64,72 +32,30 @@ export class NumberType<
   }
 
   max(value: number, exclusive?: true) {
-    return new NumberType(
-      ...this._with({
-        options: {
-          maximum: value,
-          ...(!exclusive ? {} : { exclusiveMaximum: value }),
-        },
-      }),
-    )
+    return NumberType.factory({
+      ...this.props.options,
+      maximum: value,
+      ...(!exclusive ? {} : { exclusiveMaximum: value }),
+    })
   }
 
   min(value: number, exclusive?: true) {
-    return new NumberType(
-      ...this._with({
-        options: {
-          minimum: value,
-          ...(!exclusive ? {} : { exclusiveMinimum: value }),
-        },
-      }),
-    )
+    return NumberType.factory({
+      ...this.props.options,
+      minimum: value,
+      ...(!exclusive ? {} : { exclusiveMinimum: value }),
+    })
   }
 }
 
-export class IntegerType<
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TInteger, N, O, D, IntegerOptions> {
-  constructor(
-    options: IntegerOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault)
-  }
-
-  protected _constructSchema(options: IntegerOptions): TInteger {
-    return Type.Integer(options)
-  }
-
-  nullable() {
-    return new IntegerType(...this._with({ isNullable: true }))
-  }
-
-  optional() {
-    return new IntegerType(...this._with({ isOptional: true }))
-  }
-
-  nullish() {
-    return new IntegerType(
-      ...this._with({ isNullable: true, isOptional: true }),
-    )
-  }
-
-  default(value: number) {
-    return new IntegerType(
-      ...this._with({ options: { default: value }, hasDefault: true }),
-    )
-  }
-
-  description(description: string) {
-    return new IntegerType(...this._with({ options: { description } }))
-  }
+export class IntegerType extends BaseType<
+  TInteger,
+  { options: IntegerOptions }
+> {
+  _!: ConstantType<this['schema']>
 
-  examples(...examples: [number, ...number[]]) {
-    return new IntegerType(...this._with({ options: { examples } }))
+  static factory(options: IntegerOptions = {}) {
+    return new IntegerType(Type.Integer(options), { options })
   }
 
   positive() {
@@ -141,84 +67,28 @@ export class IntegerType<
   }
 
   max(value: number, exclusive?: true) {
-    return new IntegerType(
-      ...this._with({
-        options: {
-          maximum: value,
-          ...(!exclusive ? {} : { exclusiveMaximum: value }),
-        },
-      }),
-    )
+    return IntegerType.factory({
+      ...this.props.options,
+      maximum: value,
+      ...(!exclusive ? {} : { exclusiveMaximum: value }),
+    })
   }
 
   min(value: number, exclusive?: true) {
-    return new IntegerType(
-      ...this._with({
-        options: {
-          minimum: value,
-          ...(!exclusive ? {} : { exclusiveMinimum: value }),
-        },
-      }),
-    )
+    return IntegerType.factory({
+      ...this.props.options,
+      minimum: value,
+      ...(!exclusive ? {} : { exclusiveMinimum: value }),
+    })
   }
 }
 
-export class BigIntType<
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TTransform<TString, bigint>, N, O, D, StringOptions> {
-  constructor(
-    options: StringOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault)
-  }
-
-  protected _constructSchema(options: StringOptions) {
-    return Type.Transform(Type.String({ ...options, pattern: '^\\d$' }))
-      .Decode((v: string) => {
-        try {
-          return BigInt(v)
-        } catch (error) {
-          throw new TypeBoxError('Invalid bigint value')
-        }
-      })
-      .Encode(this.encode)
-  }
-
-  protected encode = (value: bigint): string => {
-    return value.toString()
-  }
-
-  nullable() {
-    return new BigIntType(...this._with({ isNullable: true }))
-  }
-
-  optional() {
-    return new BigIntType(...this._with({ isOptional: true }))
-  }
-
-  nullish() {
-    return new BigIntType(...this._with({ isNullable: true, isOptional: true }))
-  }
-
-  default(value: bigint) {
-    return new BigIntType(
-      ...this._with({ options: { default: value }, hasDefault: true }),
-    )
-  }
-
-  description(description: string) {
-    return new BigIntType(...this._with({ options: { description } }))
-  }
+// TODO: this is not json schema compatible
+export class BigIntType extends BaseType<TBigInt, { options: BigIntOptions }> {
+  _!: ConstantType<this['schema']>
 
-  examples(...examples: [bigint, ...bigint[]]) {
-    return new BigIntType(
-      ...this._with({ options: { examples: examples.map(this.encode) } }),
-    )
+  static factory(options: BigIntOptions = {}) {
+    return new BigIntType(Type.BigInt(options), { options })
   }
 
   positive() {
@@ -230,24 +100,18 @@ export class BigIntType<
   }
 
   max(value: bigint, exclusive?: true) {
-    return new BigIntType(
-      ...this._with({
-        options: {
-          maximum: this.encode(value),
-          ...(!exclusive ? {} : { exclusiveMaximum: this.encode(value) }),
-        },
-      }),
-    )
+    return BigIntType.factory({
+      ...this.props.options,
+      maximum: value,
+      ...(!exclusive ? {} : { exclusiveMaximum: value }),
+    })
   }
 
   min(value: bigint, exclusive?: true) {
-    return new BigIntType(
-      ...this._with({
-        options: {
-          minimum: `${value}`,
-          ...(!exclusive ? {} : { exclusiveMinimum: `${value}` }),
-        },
-      }),
-    )
+    return BigIntType.factory({
+      ...this.props.options,
+      minimum: value,
+      ...(!exclusive ? {} : { exclusiveMinimum: value }),
+    })
   }
 }