@nmtjs/type 0.2.1 → 0.3.1

package/src/types/union.ts

@@ -1,6 +1,13 @@
-import { type TIntersect, type TUnion, Type } from '@sinclair/typebox'
+import {
+  type SchemaOptions,
+  type TIntersect,
+  type TUnion,
+  Type,
+  // type UnionToTuple,
+} from '@sinclair/typebox'
+import type { typeStatic } from '../constants.ts'
 import type { UnionToTuple } from '../utils.ts'
-import { BaseType, typeFinalSchema } from './base.ts'
+import { BaseType, getTypeSchema } from './base.ts'
 
 export class UnionType<
   T extends [BaseType, BaseType, ...BaseType[]] = [
@@ -10,33 +17,64 @@ export class UnionType<
   ],
   N extends boolean = false,
   O extends boolean = false,
-  // @ts-expect-error
-> extends BaseType<TUnion<UnionToTuple<T[number][typeFinal]>>, N, O> {
+  D extends boolean = false,
+> extends BaseType<
+  //@ts-expect-error
+  TUnion<UnionToTuple<T[number][typeStatic]['schema']>>,
+  N,
+  O,
+  D
+> {
   constructor(
     readonly types: T,
-    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(
-      Type.Union(types.map((t) => t[typeFinalSchema])) as any,
-      nullable,
-      optional,
-    )
+    super(options, isNullable, isOptional, hasDefault)
+  }
+
+  protected _constructSchema(
+    options: SchemaOptions,
+    //@ts-expect-error
+  ): TUnion<UnionToTuple<T[number][typeStatic]['schema']>> {
+    return Type.Union(this.types.map(getTypeSchema), options) as any
   }
 
   nullable() {
-    const [_, ...args] = this._nullable()
-    return new UnionType(this.types, ...args)
+    return new UnionType(this.types, ...this._with({ isNullable: true }))
   }
 
   optional() {
-    const [_, ...args] = this._optional()
-    return new UnionType(this.types, ...args)
+    return new UnionType(this.types, ...this._with({ isOptional: true }))
   }
 
   nullish() {
-    const [_, ...args] = this._nullish()
-    return new UnionType(this.types, ...args)
+    return new UnionType(
+      this.types,
+      ...this._with({ isNullable: true, isOptional: true }),
+    )
+  }
+
+  default(value: this[typeStatic]['encoded']) {
+    return new UnionType(
+      this.types,
+      ...this._with({ options: { default: value }, hasDefault: true }),
+    )
+  }
+
+  description(description: string) {
+    return new UnionType(
+      this.types,
+      ...this._with({ options: { description } }),
+    )
+  }
+
+  examples(
+    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]
+  ) {
+    return new UnionType(this.types, ...this._with({ options: { examples } }))
   }
 }
 
@@ -48,32 +86,66 @@ export class IntersactionType<
   ],
   N extends boolean = false,
   O extends boolean = false,
+  D extends boolean = false,
+> extends BaseType<
   // @ts-expect-error
-> extends BaseType<TIntersect<UnionToTuple<T[number][typeFinal]>>, N, O> {
+  TIntersect<UnionToTuple<T[number][typeStatic]['schema']>>,
+  N,
+  O,
+  D
+> {
   constructor(
     readonly types: T,
-    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(
-      Type.Intersect(types.map((t) => t[typeFinalSchema])) as any,
-      nullable,
-      optional,
-    )
+    super(options, isNullable, isOptional, hasDefault)
+  }
+
+  protected _constructSchema(
+    options: SchemaOptions,
+    // @ts-expect-error
+  ): TIntersect<UnionToTuple<T[number][typeStatic]['schema']>> {
+    return Type.Intersect(this.types.map(getTypeSchema), options) as any
   }
 
   nullable() {
-    const [_, ...args] = this._nullable()
-    return new IntersactionType(this.types, ...args)
+    return new IntersactionType(this.types, ...this._with({ isNullable: true }))
   }
 
   optional() {
-    const [_, ...args] = this._optional()
-    return new IntersactionType(this.types, ...args)
+    return new IntersactionType(this.types, ...this._with({ isOptional: true }))
   }
 
   nullish() {
-    const [_, ...args] = this._nullish()
-    return new IntersactionType(this.types, ...args)
+    return new IntersactionType(
+      this.types,
+      ...this._with({ isNullable: true, isOptional: true }),
+    )
+  }
+
+  default(value: this[typeStatic]['encoded']) {
+    return new IntersactionType(
+      this.types,
+      ...this._with({ options: { default: value }, hasDefault: true }),
+    )
+  }
+
+  description(description: string) {
+    return new IntersactionType(
+      this.types,
+      ...this._with({ options: { description } }),
+    )
+  }
+
+  examples(
+    ...values: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]
+  ) {
+    return new IntersactionType(
+      this.types,
+      ...this._with({ options: { examples: values } }),
+    )
   }
 }