@nmtjs/type 0.4.7 → 0.5.0

package/src/types/union.ts

@@ -1,159 +1,119 @@
 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, getTypeSchema } from './base.ts'
+import {
+  DiscriminatedUnion,
+  type TDiscriminatedUnion,
+} from '../schemas/discriminated-union.ts'
+import { BaseType, type BaseTypeAny } from './base.ts'
+import type { LiteralType } from './literal.ts'
+import type { ObjectType, ObjectTypeProps } from './object.ts'
 
-export type AnyUnionType<
-  T extends [BaseType, BaseType, ...BaseType[]] = [
-    BaseType,
-    BaseType,
-    ...BaseType[],
-  ],
-> = UnionType<T, boolean, boolean, boolean>
 export class UnionType<
-  T extends [BaseType, BaseType, ...BaseType[]] = [
-    BaseType,
-    BaseType,
-    ...BaseType[],
-  ],
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<
-  //@ts-expect-error
-  TUnion<UnionToTuple<T[number][typeStatic]['schema']>>,
-  N,
-  O,
-  D
-> {
-  constructor(
-    protected readonly types: T,
-    options: SchemaOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
+  T extends readonly BaseType[] = readonly BaseType[],
+> extends BaseType<TUnion<UnionToTuple<T[number]['schema']>>> {
+  _!: {
+    encoded: {
+      input: TUnion<UnionToTuple<T[number]['_']['encoded']['input']>>
+      output: TUnion<UnionToTuple<T[number]['_']['encoded']['output']>>
+    }
+    decoded: {
+      input: TUnion<UnionToTuple<T[number]['_']['decoded']['input']>>
+      output: TUnion<UnionToTuple<T[number]['_']['decoded']['output']>>
+    }
+  }
+
+  static factory<T extends readonly BaseType[] = readonly BaseType[]>(
+    ...types: T
   ) {
-    super(options, isNullable, isOptional, hasDefault, types)
-  }
-
-  protected _constructSchema(
-    options: SchemaOptions,
-    types: T,
-    //@ts-expect-error
-  ): TUnion<UnionToTuple<T[number][typeStatic]['schema']>> {
-    return Type.Union(types.map(getTypeSchema), options) as any
-  }
-
-  nullable() {
-    return new UnionType(this.types, ...this._with({ isNullable: true }))
-  }
-
-  optional() {
-    return new UnionType(this.types, ...this._with({ isOptional: true }))
-  }
-
-  nullish() {
-    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 } }))
+    return new UnionType<T>(Type.Union(types.map((t) => t.schema)) as any)
   }
 }
 
 export class IntersactionType<
-  T extends [BaseType, BaseType, ...BaseType[]] = [
-    BaseType,
-    BaseType,
-    ...BaseType[],
-  ],
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<
-  // @ts-expect-error
-  TIntersect<UnionToTuple<T[number][typeStatic]['schema']>>,
-  N,
-  O,
-  D
-> {
-  constructor(
-    protected readonly types: T,
-    options: SchemaOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
+  T extends readonly BaseType[] = readonly BaseType[],
+> extends BaseType<TIntersect<UnionToTuple<T[number]['schema']>>> {
+  _!: {
+    encoded: {
+      input: TIntersect<UnionToTuple<T[number]['_']['encoded']['input']>>
+      output: TIntersect<UnionToTuple<T[number]['_']['encoded']['output']>>
+    }
+    decoded: {
+      input: TIntersect<UnionToTuple<T[number]['_']['decoded']['input']>>
+      output: TIntersect<UnionToTuple<T[number]['_']['decoded']['output']>>
+    }
+  }
+
+  static factory<T extends readonly BaseType[] = readonly BaseType[]>(
+    ...types: T
   ) {
-    super(options, isNullable, isOptional, hasDefault, types)
-  }
-
-  protected _constructSchema(
-    options: SchemaOptions,
-    types: T,
-    // @ts-expect-error
-  ): TIntersect<UnionToTuple<T[number][typeStatic]['schema']>> {
-    return Type.Intersect(types.map(getTypeSchema), options) as any
-  }
-
-  nullable() {
-    return new IntersactionType(this.types, ...this._with({ isNullable: true }))
-  }
-
-  optional() {
-    return new IntersactionType(this.types, ...this._with({ isOptional: true }))
-  }
-
-  nullish() {
-    return new IntersactionType(
-      this.types,
-      ...this._with({ isNullable: true, isOptional: true }),
+    return new IntersactionType<T>(
+      Type.Intersect(types.map((t) => t.schema)) as any,
     )
   }
+}
 
-  default(value: this[typeStatic]['encoded']) {
-    return new IntersactionType(
-      this.types,
-      ...this._with({ options: { default: value }, hasDefault: true }),
-    )
-  }
+export type DiscriminatedUnionOptionType<K extends string> = ObjectType<
+  ObjectTypeProps & { [_ in K]: BaseTypeAny }
+>
 
-  description(description: string) {
-    return new IntersactionType(
-      this.types,
-      ...this._with({ options: { description } }),
-    )
+export class DiscriminatedUnionType<
+  K extends string,
+  T extends readonly [
+    DiscriminatedUnionOptionType<K>,
+    ...DiscriminatedUnionOptionType<K>[],
+  ],
+> extends BaseType<
+  TDiscriminatedUnion<
+    K,
+    //@ts-expect-error
+    UnionToTuple<T[number]['schema']>
+  >,
+  {
+    key: K
+    options: T
   }
-
-  examples(
-    ...values: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]
-  ) {
-    return new IntersactionType(
-      this.types,
-      ...this._with({ options: { examples: values } }),
+> {
+  _!: {
+    encoded: {
+      input: TDiscriminatedUnion<
+        K,
+        //@ts-expect-error
+        UnionToTuple<T[number]['_']['encoded']['input']>
+      >
+      output: TDiscriminatedUnion<
+        K,
+        //@ts-expect-error
+        UnionToTuple<T[number]['_']['encoded']['output']>
+      >
+    }
+    decoded: {
+      input: TDiscriminatedUnion<
+        K,
+        //@ts-expect-error
+        UnionToTuple<T[number]['_']['decoded']['input']>
+      >
+      output: TDiscriminatedUnion<
+        K,
+        //@ts-expect-error
+        UnionToTuple<T[number]['_']['decoded']['output']>
+      >
+    }
+  }
+
+  static factory<
+    K extends string,
+    T extends readonly [
+      DiscriminatedUnionOptionType<K>,
+      ...DiscriminatedUnionOptionType<K>[],
+    ],
+  >(key: K, ...options: T) {
+    return new DiscriminatedUnionType<K, T>(
+      DiscriminatedUnion(key, options.map((t) => t.schema) as any),
+      { key, options },
     )
   }
 }

package/src/utils.ts

@@ -14,3 +14,11 @@ export type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never]
 export type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never
 
 export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>
+
+export type Merge<T, U> = {
+  [K in keyof T | keyof U]: K extends keyof U
+    ? U[K]
+    : K extends keyof T
+      ? T[K]
+      : never
+}

package/dist/constants.js

@@ -1,2 +0,0 @@
-export const typeStatic = Symbol.for('neemataType:typeStatic');
-export const typeSchema = Symbol.for('neemataType:typeSchema');

package/dist/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/constants.ts"],"sourcesContent":["export const typeStatic: unique symbol = Symbol.for('neemataType:typeStatic')\nexport type typeStatic = typeof typeStatic\n\nexport const typeSchema: unique symbol = Symbol.for('neemataType:typeSchema')\nexport type typeSchema = typeof typeSchema\n"],"names":["typeStatic","Symbol","for","typeSchema"],"mappings":"AAAA,OAAO,MAAMA,aAA4BC,OAAOC,GAAG,CAAC,0BAAyB;AAG7E,OAAO,MAAMC,aAA4BF,OAAOC,GAAG,CAAC,0BAAyB"}

package/dist/types/datetime.js

@@ -1,53 +0,0 @@
-import { Type } from '@sinclair/typebox';
-import { BaseType } from "./base.js";
-const decode = (value)=>new Date(value);
-const encode = (value)=>value.toISOString();
-export class DateType extends BaseType {
-    constructor(options = {}, isNullable = false, isOptional = false, hasDefault = false){
-        super(options, isNullable, isOptional, hasDefault);
-    }
-    _constructSchema(options) {
-        return Type.Transform(Type.String({
-            ...options,
-            format: 'date-time'
-        })).Decode(decode).Encode(encode);
-    }
-    nullable() {
-        return new DateType(...this._with({
-            isNullable: true
-        }));
-    }
-    optional() {
-        return new DateType(...this._with({
-            isOptional: true
-        }));
-    }
-    nullish() {
-        return new DateType(...this._with({
-            isNullable: true,
-            isOptional: true
-        }));
-    }
-    default(value) {
-        return new DateType(...this._with({
-            options: {
-                default: encode(value)
-            },
-            hasDefault: true
-        }));
-    }
-    description(value) {
-        return new DateType(...this._with({
-            options: {
-                description: value
-            }
-        }));
-    }
-    examples(...values) {
-        return new DateType(...this._with({
-            options: {
-                examples: values.map(encode)
-            }
-        }));
-    }
-}

package/dist/types/datetime.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/types/datetime.ts"],"sourcesContent":["import {\n  type SchemaOptions,\n  type StringOptions,\n  type TString,\n  type TTransform,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nconst decode = (value: any): Date => new Date(value)\nconst encode = (value: Date): any => value.toISOString()\n\nexport class DateType<\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TTransform<TString, Date>, N, O, D, StringOptions> {\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(\n    options: StringOptions,\n  ): TTransform<TString, Date> {\n    return Type.Transform(Type.String({ ...options, format: 'date-time' }))\n      .Decode(decode)\n      .Encode(encode)\n  }\n\n  nullable() {\n    return new DateType(...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new DateType(...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new DateType(...this._with({ isNullable: true, isOptional: true }))\n  }\n\n  default(value: Date) {\n    return new DateType(\n      ...this._with({\n        options: { default: encode(value) },\n        hasDefault: true,\n      }),\n    )\n  }\n\n  description(value: string) {\n    return new DateType(...this._with({ options: { description: value } }))\n  }\n\n  examples(...values: [Date, ...Date[]]) {\n    return new DateType(\n      ...this._with({ options: { examples: values.map(encode) } }),\n    )\n  }\n}\n"],"names":["Type","BaseType","decode","value","Date","encode","toISOString","DateType","constructor","options","isNullable","isOptional","hasDefault","_constructSchema","Transform","String","format","Decode","Encode","nullable","_with","optional","nullish","default","description","examples","values","map"],"mappings":"AAAA,SAKEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAAQ,YAAW;AAEpC,MAAMC,SAAS,CAACC,QAAqB,IAAIC,KAAKD;AAC9C,MAAME,SAAS,CAACF,QAAqBA,MAAMG,WAAW;AAEtD,OAAO,MAAMC,iBAIHN;IACRO,YACEC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC;IACzC;IAEUC,iBACRJ,OAAsB,EACK;QAC3B,OAAOT,KAAKc,SAAS,CAACd,KAAKe,MAAM,CAAC;YAAE,GAAGN,OAAO;YAAEO,QAAQ;QAAY,IACjEC,MAAM,CAACf,QACPgB,MAAM,CAACb;IACZ;IAEAc,WAAW;QACT,OAAO,IAAIZ,YAAY,IAAI,CAACa,KAAK,CAAC;YAAEV,YAAY;QAAK;IACvD;IAEAW,WAAW;QACT,OAAO,IAAId,YAAY,IAAI,CAACa,KAAK,CAAC;YAAET,YAAY;QAAK;IACvD;IAEAW,UAAU;QACR,OAAO,IAAIf,YAAY,IAAI,CAACa,KAAK,CAAC;YAAEV,YAAY;YAAMC,YAAY;QAAK;IACzE;IAEAY,QAAQpB,KAAW,EAAE;QACnB,OAAO,IAAII,YACN,IAAI,CAACa,KAAK,CAAC;YACZX,SAAS;gBAAEc,SAASlB,OAAOF;YAAO;YAClCS,YAAY;QACd;IAEJ;IAEAY,YAAYrB,KAAa,EAAE;QACzB,OAAO,IAAII,YAAY,IAAI,CAACa,KAAK,CAAC;YAAEX,SAAS;gBAAEe,aAAarB;YAAM;QAAE;IACtE;IAEAsB,SAAS,GAAGC,MAAyB,EAAE;QACrC,OAAO,IAAInB,YACN,IAAI,CAACa,KAAK,CAAC;YAAEX,SAAS;gBAAEgB,UAAUC,OAAOC,GAAG,CAACtB;YAAQ;QAAE;IAE9D;AACF"}

package/src/constants.ts

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

package/src/types/datetime.ts

@@ -1,65 +0,0 @@
-import {
-  type SchemaOptions,
-  type StringOptions,
-  type TString,
-  type TTransform,
-  Type,
-} from '@sinclair/typebox'
-import { BaseType } from './base.ts'
-
-const decode = (value: any): Date => new Date(value)
-const encode = (value: Date): any => value.toISOString()
-
-export class DateType<
-  N extends boolean = false,
-  O extends boolean = false,
-  D extends boolean = false,
-> extends BaseType<TTransform<TString, Date>, N, O, D, StringOptions> {
-  constructor(
-    options: SchemaOptions = {},
-    isNullable: N = false as N,
-    isOptional: O = false as O,
-    hasDefault: D = false as D,
-  ) {
-    super(options, isNullable, isOptional, hasDefault)
-  }
-
-  protected _constructSchema(
-    options: StringOptions,
-  ): TTransform<TString, Date> {
-    return Type.Transform(Type.String({ ...options, format: 'date-time' }))
-      .Decode(decode)
-      .Encode(encode)
-  }
-
-  nullable() {
-    return new DateType(...this._with({ isNullable: true }))
-  }
-
-  optional() {
-    return new DateType(...this._with({ isOptional: true }))
-  }
-
-  nullish() {
-    return new DateType(...this._with({ isNullable: true, isOptional: true }))
-  }
-
-  default(value: Date) {
-    return new DateType(
-      ...this._with({
-        options: { default: encode(value) },
-        hasDefault: true,
-      }),
-    )
-  }
-
-  description(value: string) {
-    return new DateType(...this._with({ options: { description: value } }))
-  }
-
-  examples(...values: [Date, ...Date[]]) {
-    return new DateType(
-      ...this._with({ options: { examples: values.map(encode) } }),
-    )
-  }
-}