@nmtjs/type 0.4.1 → 0.4.3

package/dist/constants.js

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

package/dist/constants.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/constants.ts"],"sourcesContent":["export const typeStatic: unique symbol = Symbol()\nexport type typeStatic = typeof typeStatic\n\nexport const typeSchema: unique symbol = Symbol()\nexport type typeSchema = typeof typeSchema\n"],"names":["typeStatic","Symbol","typeSchema"],"mappings":"AAAA,OAAO,MAAMA,aAA4BC,SAAQ;AAGjD,OAAO,MAAMC,aAA4BD,SAAQ"}
+{"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/index.js

@@ -12,8 +12,6 @@ import { AnyType } from "./types/any.js";
 import { NeverType } from "./types/never.js";
 import { register } from "./formats.js";
 register();
-export * from "./schemas/native-enum.js";
-export * from "./schemas/union-enum.js";
 export * from "./schemas/nullable.js";
 export { BaseType, getTypeSchema } from "./types/base.js";
 export { ArrayType, BooleanType, CustomType, DateType, EnumType, LiteralType, IntegerType, NumberType, ObjectType, StringType, IntersactionType, UnionType, AnyType, NeverType,  };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import type { TLiteralValue } from '@sinclair/typebox'\nimport { ArrayType } from './types/array.ts'\nimport type { BaseType } from './types/base.ts'\nimport { BooleanType } from './types/boolean.ts'\nimport { CustomType } from './types/custom.ts'\nimport { DateType } from './types/datetime.ts'\nimport {\n  type AnyEnumType,\n  type AnyObjectEnumType,\n  EnumType,\n  ObjectEnumType,\n} from './types/enum.ts'\nimport { type AnyLiteralType, LiteralType } from './types/literal.ts'\nimport { BigIntType, IntegerType, NumberType } from './types/number.ts'\nimport { ObjectType, RecordType } from './types/object.ts'\nimport { type AnyStringType, StringType } from './types/string.ts'\nimport {\n  type AnyUnionType,\n  IntersactionType,\n  UnionType,\n} from './types/union.ts'\n\nimport type { typeStatic } from './constants.ts'\nimport { AnyType } from './types/any.ts'\nimport { NeverType } from './types/never.ts'\n\n// register ajv formats\nimport { register } from './formats.ts'\nregister()\n\nexport * from './schemas/native-enum.ts'\nexport * from './schemas/union-enum.ts'\nexport * from './schemas/nullable.ts'\nexport {\n  BaseType,\n  getTypeSchema,\n} from './types/base.ts'\nexport { type TSchema } from '@sinclair/typebox'\nexport {\n  ArrayType,\n  BooleanType,\n  CustomType,\n  DateType,\n  EnumType,\n  LiteralType,\n  IntegerType,\n  NumberType,\n  ObjectType,\n  StringType,\n  IntersactionType,\n  UnionType,\n  AnyType,\n  NeverType,\n}\n\nexport namespace t {\n  export namespace infer {\n    export type staticType<T extends BaseType> = T[typeStatic]\n    export type decoded<T extends BaseType> = staticType<T>['decoded']\n    export type encoded<T extends BaseType> = staticType<T>['encoded']\n  }\n  export const never = () => new NeverType()\n  export const boolean = () => new BooleanType()\n  export const string = () => new StringType()\n  export const number = () => new NumberType()\n  export const integer = () => new IntegerType()\n  export const bitint = () => new BigIntType()\n  export const literal = <T extends TLiteralValue>(value: T) =>\n    new LiteralType(value)\n  export const objectEnum = <T extends { [K in string]: K }>(enumLike: T) =>\n    new ObjectEnumType(enumLike)\n  export const arrayEnum = <T extends (string | number)[]>(enumLike: [...T]) =>\n    new EnumType(enumLike)\n  export const date = () => new DateType()\n  export const array = <T extends BaseType>(element: T) =>\n    new ArrayType(element)\n  export const object = <T extends Record<string, BaseType>>(properties: T) =>\n    new ObjectType(properties)\n  export const record = <\n    K extends\n      | AnyLiteralType\n      | AnyEnumType\n      | AnyObjectEnumType\n      | AnyStringType\n      | AnyUnionType,\n    E extends BaseType,\n  >(\n    key: K,\n    value: E,\n  ) => new RecordType(key, value)\n  export const any = () => new AnyType()\n  export const or = <T extends [BaseType, BaseType, ...BaseType[]]>(\n    ...types: T\n  ) => new UnionType(types)\n  export const and = <T extends [BaseType, BaseType, ...BaseType[]]>(\n    ...types: T\n  ) => new IntersactionType(types)\n  export const custom = <T>(\n    decode: (value: any) => T,\n    encode: (value: T) => any,\n  ) => new CustomType<T>(decode, encode)\n}\n"],"names":["ArrayType","BooleanType","CustomType","DateType","EnumType","ObjectEnumType","LiteralType","BigIntType","IntegerType","NumberType","ObjectType","RecordType","StringType","IntersactionType","UnionType","AnyType","NeverType","register","BaseType","getTypeSchema","t","never","boolean","string","number","integer","bitint","literal","value","objectEnum","enumLike","arrayEnum","date","array","element","object","properties","record","key","any","or","types","and","custom","decode","encode"],"mappings":"AACA,SAASA,SAAS,QAAQ,mBAAkB;AAE5C,SAASC,WAAW,QAAQ,qBAAoB;AAChD,SAASC,UAAU,QAAQ,oBAAmB;AAC9C,SAASC,QAAQ,QAAQ,sBAAqB;AAC9C,SAGEC,QAAQ,EACRC,cAAc,QACT,kBAAiB;AACxB,SAA8BC,WAAW,QAAQ,qBAAoB;AACrE,SAASC,UAAU,EAAEC,WAAW,EAAEC,UAAU,QAAQ,oBAAmB;AACvE,SAASC,UAAU,EAAEC,UAAU,QAAQ,oBAAmB;AAC1D,SAA6BC,UAAU,QAAQ,oBAAmB;AAClE,SAEEC,gBAAgB,EAChBC,SAAS,QACJ,mBAAkB;AAGzB,SAASC,OAAO,QAAQ,iBAAgB;AACxC,SAASC,SAAS,QAAQ,mBAAkB;AAG5C,SAASC,QAAQ,QAAQ,eAAc;AACvCA;AAEA,cAAc,2BAA0B;AACxC,cAAc,0BAAyB;AACvC,cAAc,wBAAuB;AACrC,SACEC,QAAQ,EACRC,aAAa,QACR,kBAAiB;AAExB,SACEnB,SAAS,EACTC,WAAW,EACXC,UAAU,EACVC,QAAQ,EACRC,QAAQ,EACRE,WAAW,EACXE,WAAW,EACXC,UAAU,EACVC,UAAU,EACVE,UAAU,EACVC,gBAAgB,EAChBC,SAAS,EACTC,OAAO,EACPC,SAAS,KACV;;UAEgBI;MAMFC,QAAQ,IAAM,IAAIL;MAClBM,UAAU,IAAM,IAAIrB;MACpBsB,SAAS,IAAM,IAAIX;MACnBY,SAAS,IAAM,IAAIf;MACnBgB,UAAU,IAAM,IAAIjB;MACpBkB,SAAS,IAAM,IAAInB;MACnBoB,UAAU,CAA0BC,QAC/C,IAAItB,YAAYsB;MACLC,aAAa,CAAiCC,WACzD,IAAIzB,eAAeyB;MACRC,YAAY,CAAgCD,WACvD,IAAI1B,SAAS0B;MACFE,OAAO,IAAM,IAAI7B;MACjB8B,QAAQ,CAAqBC,UACxC,IAAIlC,UAAUkC;MACHC,SAAS,CAAqCC,aACzD,IAAI1B,WAAW0B;MACJC,SAAS,CASpBC,KACAV,QACG,IAAIjB,WAAW2B,KAAKV;MACZW,MAAM,IAAM,IAAIxB;MAChByB,KAAK,CAChB,GAAGC,QACA,IAAI3B,UAAU2B;MACNC,MAAM,CACjB,GAAGD,QACA,IAAI5B,iBAAiB4B;MACbE,SAAS,CACpBC,QACAC,SACG,IAAI3C,WAAc0C,QAAQC;AACjC,GA9CiBzB,MAAAA"}
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import type { TLiteralValue } from '@sinclair/typebox/type'\nimport { ArrayType } from './types/array.ts'\nimport type { BaseType } from './types/base.ts'\nimport { BooleanType } from './types/boolean.ts'\nimport { CustomType } from './types/custom.ts'\nimport { DateType } from './types/datetime.ts'\nimport {\n  type AnyEnumType,\n  type AnyObjectEnumType,\n  EnumType,\n  ObjectEnumType,\n} from './types/enum.ts'\nimport { type AnyLiteralType, LiteralType } from './types/literal.ts'\nimport { BigIntType, IntegerType, NumberType } from './types/number.ts'\nimport { ObjectType, RecordType } from './types/object.ts'\nimport { type AnyStringType, StringType } from './types/string.ts'\nimport {\n  type AnyUnionType,\n  IntersactionType,\n  UnionType,\n} from './types/union.ts'\n\nimport type { typeStatic } from './constants.ts'\nimport { AnyType } from './types/any.ts'\nimport { NeverType } from './types/never.ts'\n\n// register ajv formats\nimport { register } from './formats.ts'\nregister()\n\nexport * from './schemas/nullable.ts'\nexport {\n  BaseType,\n  getTypeSchema,\n} from './types/base.ts'\nexport { type TSchema } from '@sinclair/typebox'\nexport {\n  ArrayType,\n  BooleanType,\n  CustomType,\n  DateType,\n  EnumType,\n  LiteralType,\n  IntegerType,\n  NumberType,\n  ObjectType,\n  StringType,\n  IntersactionType,\n  UnionType,\n  AnyType,\n  NeverType,\n}\n\nexport namespace t {\n  export namespace infer {\n    export type staticType<T extends BaseType> = T[typeStatic]\n    export type decoded<T extends BaseType> = staticType<T>['decoded']\n    export type encoded<T extends BaseType> = staticType<T>['encoded']\n  }\n  export const never = () => new NeverType()\n  export const boolean = () => new BooleanType()\n  export const string = () => new StringType()\n  export const number = () => new NumberType()\n  export const integer = () => new IntegerType()\n  export const bitint = () => new BigIntType()\n  export const literal = <T extends TLiteralValue>(value: T) =>\n    new LiteralType(value)\n  export const objectEnum = <T extends { [K in string]: K }>(enumLike: T) =>\n    new ObjectEnumType(enumLike)\n  export const arrayEnum = <T extends (string | number)[]>(enumLike: [...T]) =>\n    new EnumType(enumLike)\n  export const date = () => new DateType()\n  export const array = <T extends BaseType>(element: T) =>\n    new ArrayType(element)\n  export const object = <T extends Record<string, BaseType>>(properties: T) =>\n    new ObjectType(properties)\n  export const record = <\n    K extends\n      | AnyLiteralType\n      | AnyEnumType\n      | AnyObjectEnumType\n      | AnyStringType\n      | AnyUnionType,\n    E extends BaseType,\n  >(\n    key: K,\n    value: E,\n  ) => new RecordType(key, value)\n  export const any = () => new AnyType()\n  export const or = <T extends [BaseType, BaseType, ...BaseType[]]>(\n    ...types: T\n  ) => new UnionType(types)\n  export const and = <T extends [BaseType, BaseType, ...BaseType[]]>(\n    ...types: T\n  ) => new IntersactionType(types)\n  export const custom = <T>(\n    decode: (value: any) => T,\n    encode: (value: T) => any,\n  ) => new CustomType<T>(decode, encode)\n}\n"],"names":["ArrayType","BooleanType","CustomType","DateType","EnumType","ObjectEnumType","LiteralType","BigIntType","IntegerType","NumberType","ObjectType","RecordType","StringType","IntersactionType","UnionType","AnyType","NeverType","register","BaseType","getTypeSchema","t","never","boolean","string","number","integer","bitint","literal","value","objectEnum","enumLike","arrayEnum","date","array","element","object","properties","record","key","any","or","types","and","custom","decode","encode"],"mappings":"AACA,SAASA,SAAS,QAAQ,mBAAkB;AAE5C,SAASC,WAAW,QAAQ,qBAAoB;AAChD,SAASC,UAAU,QAAQ,oBAAmB;AAC9C,SAASC,QAAQ,QAAQ,sBAAqB;AAC9C,SAGEC,QAAQ,EACRC,cAAc,QACT,kBAAiB;AACxB,SAA8BC,WAAW,QAAQ,qBAAoB;AACrE,SAASC,UAAU,EAAEC,WAAW,EAAEC,UAAU,QAAQ,oBAAmB;AACvE,SAASC,UAAU,EAAEC,UAAU,QAAQ,oBAAmB;AAC1D,SAA6BC,UAAU,QAAQ,oBAAmB;AAClE,SAEEC,gBAAgB,EAChBC,SAAS,QACJ,mBAAkB;AAGzB,SAASC,OAAO,QAAQ,iBAAgB;AACxC,SAASC,SAAS,QAAQ,mBAAkB;AAG5C,SAASC,QAAQ,QAAQ,eAAc;AACvCA;AAEA,cAAc,wBAAuB;AACrC,SACEC,QAAQ,EACRC,aAAa,QACR,kBAAiB;AAExB,SACEnB,SAAS,EACTC,WAAW,EACXC,UAAU,EACVC,QAAQ,EACRC,QAAQ,EACRE,WAAW,EACXE,WAAW,EACXC,UAAU,EACVC,UAAU,EACVE,UAAU,EACVC,gBAAgB,EAChBC,SAAS,EACTC,OAAO,EACPC,SAAS,KACV;;UAEgBI;MAMFC,QAAQ,IAAM,IAAIL;MAClBM,UAAU,IAAM,IAAIrB;MACpBsB,SAAS,IAAM,IAAIX;MACnBY,SAAS,IAAM,IAAIf;MACnBgB,UAAU,IAAM,IAAIjB;MACpBkB,SAAS,IAAM,IAAInB;MACnBoB,UAAU,CAA0BC,QAC/C,IAAItB,YAAYsB;MACLC,aAAa,CAAiCC,WACzD,IAAIzB,eAAeyB;MACRC,YAAY,CAAgCD,WACvD,IAAI1B,SAAS0B;MACFE,OAAO,IAAM,IAAI7B;MACjB8B,QAAQ,CAAqBC,UACxC,IAAIlC,UAAUkC;MACHC,SAAS,CAAqCC,aACzD,IAAI1B,WAAW0B;MACJC,SAAS,CASpBC,KACAV,QACG,IAAIjB,WAAW2B,KAAKV;MACZW,MAAM,IAAM,IAAIxB;MAChByB,KAAK,CAChB,GAAGC,QACA,IAAI3B,UAAU2B;MACNC,MAAM,CACjB,GAAGD,QACA,IAAI5B,iBAAiB4B;MACbE,SAAS,CACpBC,QACAC,SACG,IAAI3C,WAAc0C,QAAQC;AACjC,GA9CiBzB,MAAAA"}

package/dist/schemas/nullable.js

@@ -1,5 +1,16 @@
 import { Type } from '@sinclair/typebox/type';
-export const Nullable = (schema, options = {})=>Type.Union([
+export const Nullable = (schema, options = {})=>{
+    const { default: _default, description, examples, readOnly, title, writeOnly } = schema;
+    return Type.Union([
         schema,
         Type.Null()
-    ], options);
+    ], {
+        default: _default,
+        description,
+        examples,
+        readOnly,
+        title,
+        writeOnly,
+        ...options
+    });
+};

package/dist/schemas/nullable.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/schemas/nullable.ts"],"sourcesContent":["import {\n  type SchemaOptions,\n  type TNull,\n  type TSchema,\n  type TUnion,\n  Type,\n} from '@sinclair/typebox/type'\n\nexport type TNullable<T extends TSchema> = TUnion<[T, TNull]>\nexport const Nullable = <T extends TSchema>(\n  schema: T,\n  options: SchemaOptions = {},\n) => Type.Union([schema, Type.Null()], options)\n"],"names":["Type","Nullable","schema","options","Union","Null"],"mappings":"AAAA,SAKEA,IAAI,QACC,yBAAwB;AAG/B,OAAO,MAAMC,WAAW,CACtBC,QACAC,UAAyB,CAAC,CAAC,GACxBH,KAAKI,KAAK,CAAC;QAACF;QAAQF,KAAKK,IAAI;KAAG,EAAEF,SAAQ"}
+{"version":3,"sources":["../../../src/schemas/nullable.ts"],"sourcesContent":["import {\n  type SchemaOptions,\n  type TNull,\n  type TSchema,\n  type TUnion,\n  Type,\n} from '@sinclair/typebox/type'\n\nexport type TNullable<T extends TSchema> = TUnion<[T, TNull]>\nexport const Nullable = <T extends TSchema>(\n  schema: T,\n  options: SchemaOptions = {},\n) => {\n  const {\n    default: _default,\n    description,\n    examples,\n    readOnly,\n    title,\n    writeOnly,\n  } = schema\n\n  return Type.Union([schema, Type.Null()], {\n    default: _default,\n    description,\n    examples,\n    readOnly,\n    title,\n    writeOnly,\n    ...options,\n  })\n}\n"],"names":["Type","Nullable","schema","options","default","_default","description","examples","readOnly","title","writeOnly","Union","Null"],"mappings":"AAAA,SAKEA,IAAI,QACC,yBAAwB;AAG/B,OAAO,MAAMC,WAAW,CACtBC,QACAC,UAAyB,CAAC,CAAC;IAE3B,MAAM,EACJC,SAASC,QAAQ,EACjBC,WAAW,EACXC,QAAQ,EACRC,QAAQ,EACRC,KAAK,EACLC,SAAS,EACV,GAAGR;IAEJ,OAAOF,KAAKW,KAAK,CAAC;QAACT;QAAQF,KAAKY,IAAI;KAAG,EAAE;QACvCR,SAASC;QACTC;QACAC;QACAC;QACAC;QACAC;QACA,GAAGP,OAAO;IACZ;AACF,EAAC"}

package/dist/types/enum.js

@@ -1,5 +1,4 @@
-import { NativeEnum } from "../schemas/native-enum.js";
-import { UnionEnum } from "../schemas/union-enum.js";
+import { Enum } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class ObjectEnumType extends BaseType {
     values;
@@ -8,7 +7,7 @@ export class ObjectEnumType extends BaseType {
         this.values = values;
     }
     _constructSchema(options, values) {
-        return NativeEnum(values, options);
+        return Enum(values, options);
     }
     nullable() {
         return new ObjectEnumType(this.values, ...this._with({
@@ -56,7 +55,10 @@ export class EnumType extends BaseType {
         this.values = values;
     }
     _constructSchema(options, values) {
-        return UnionEnum(values, options);
+        return Enum(Object.fromEntries(values.map((k)=>[
+                k,
+                k
+            ])), options);
     }
     nullable() {
         return new EnumType(this.values, ...this._with({

package/dist/types/enum.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/enum.ts"],"sourcesContent":["import type { SchemaOptions } from '@sinclair/typebox'\nimport type { TNativeEnum } from '../schemas/native-enum.ts'\nimport { NativeEnum } from '../schemas/native-enum.ts'\nimport { type TUnionEnum, UnionEnum } from '../schemas/union-enum.ts'\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<TNativeEnum<T>, N, O, D> {\n  constructor(\n    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  ): TNativeEnum<T> {\n    return NativeEnum(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<TUnionEnum<T>, N, O, D> {\n  constructor(\n    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  ): TUnionEnum<T> {\n    return UnionEnum(values, 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":["NativeEnum","UnionEnum","BaseType","ObjectEnumType","constructor","values","options","isNullable","isOptional","hasDefault","_constructSchema","nullable","_with","optional","nullish","default","value","description","examples","EnumType"],"mappings":"AAEA,SAASA,UAAU,QAAQ,4BAA2B;AACtD,SAA0BC,SAAS,QAAQ,2BAA0B;AACrE,SAASC,QAAQ,QAAQ,YAAW;AAIpC,OAAO,MAAMC,uBAKHD;;IACRE,YACE,AAASC,MAAS,EAClBC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC,YAAYJ;aAN1CA,SAAAA;IAOX;IAEUK,iBACRJ,OAAsB,EACtBD,MAAS,EACO;QAChB,OAAOL,WAAWK,QAAQC;IAC5B;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,AAASC,MAAc,EACvBC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC,YAAYJ;aAN1CA,SAAAA;IAOX;IAEUK,iBACRJ,OAAsB,EACtBD,MAAc,EACC;QACf,OAAOJ,UAAUI,QAAQC;IAC3B;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 { 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":"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"}

package/dist/types/object.js

@@ -1,6 +1,6 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType, getTypeSchema } from "./base.js";
-import { EnumType, ObjectEnumType } from "./enum.js";
+import { EnumType } from "./enum.js";
 export class ObjectType extends BaseType {
     properties;
     constructor(properties = {}, options = {}, isNullable = false, isOptional = false, hasDefault = false){
@@ -97,15 +97,7 @@ export class RecordType extends BaseType {
         this.element = element;
     }
     _constructSchema(options, key, element) {
-        let keySchema;
-        if (key instanceof EnumType) {
-            keySchema = Type.Union(key.values.map((value)=>Type.Literal(value)));
-        } else if (key instanceof ObjectEnumType) {
-            keySchema = Type.Union(Object.values(key.values).map((value)=>Type.Literal(value)));
-        } else {
-            keySchema = getTypeSchema(key);
-        }
-        return Type.Record(keySchema, getTypeSchema(element), options);
+        return Type.Record(getTypeSchema(key), getTypeSchema(element), options);
     }
     nullable() {
         return new RecordType(this.key, this.element, ...this._with({

package/dist/types/object.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/object.ts"],"sourcesContent":["import {\n  type ObjectOptions,\n  type TObject,\n  type TRecord,\n  type TSchema,\n  Type,\n} from '@sinclair/typebox'\nimport type { typeStatic } from '../constants.ts'\nimport type { UnionToTupleString } from '../utils.ts'\nimport { BaseType, getTypeSchema } from './base.ts'\nimport {\n  type AnyEnumType,\n  type AnyObjectEnumType,\n  EnumType,\n  ObjectEnumType,\n} from './enum.ts'\nimport type { AnyLiteralType } from './literal.ts'\nimport type { AnyStringType } from './string.ts'\nimport type { AnyUnionType } from './union.ts'\n\nexport class ObjectType<\n  T extends Record<string, BaseType>,\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<\n  TObject<{ [K in keyof T]: T[K][typeStatic]['schema'] }>,\n  N,\n  O,\n  D\n> {\n  constructor(\n    protected readonly properties: T = {} as T,\n    options: ObjectOptions = {},\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, properties)\n  }\n\n  protected _constructSchema(\n    options: ObjectOptions,\n    properties: T,\n  ): TObject<{ [K in keyof T]: T[K][typeStatic]['schema'] }> {\n    const schemaProperties = {} as {\n      [K in keyof T]: T[K][typeStatic]['schema']\n    }\n\n    for (const [key, value] of Object.entries(properties)) {\n      // @ts-expect-error\n      schemaProperties[key] = getTypeSchema(value)\n    }\n    return Type.Object(schemaProperties, options)\n  }\n\n  nullable() {\n    return new ObjectType(this.properties, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new ObjectType(this.properties, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: this[typeStatic]['encoded']) {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(\n    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]\n  ) {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ options: { examples } }),\n    )\n  }\n\n  pick<P extends { [K in keyof T]?: true }>(pick: P) {\n    const properties = Object.fromEntries(\n      Object.entries(this.properties).filter(([key]) => pick[key]),\n    )\n    const [_, ...args] = this._with()\n    return new ObjectType(\n      properties as Pick<T, Extract<keyof P, keyof T>>,\n      {},\n      ...args,\n    )\n  }\n\n  omit<P extends { [K in keyof T]?: true }>(omit: P) {\n    const properties = Object.fromEntries(\n      Object.entries(this.properties).filter(([key]) => !omit[key]),\n    )\n    const [_, ...args] = this._with()\n    return new ObjectType(\n      properties as Omit<T, Extract<keyof P, keyof T>>,\n      {},\n      ...args,\n    )\n  }\n\n  extend<P extends Record<string, BaseType>>(properties: P) {\n    const [_, ...args] = this._with()\n    return new ObjectType({ ...this.properties, ...properties }, {}, ...args)\n  }\n\n  merge<T extends ObjectType<Record<string, BaseType>>>(object: T) {\n    const [_, ...args] = this._with()\n    return new ObjectType(\n      { ...this.properties, ...object.properties },\n      {},\n      ...args,\n    )\n  }\n\n  partial() {\n    const properties: { [K in keyof T]: ReturnType<T[K]['optional']> } =\n      {} as any\n    for (const [key, value] of Object.entries(this.properties)) {\n      // @ts-expect-error\n      properties[key] = value.optional()\n    }\n    const [_, ...args] = this._with()\n    return new ObjectType(properties, {}, ...args)\n  }\n\n  keyof(): EnumType<UnionToTupleString<keyof T>> {\n    return new EnumType(Object.keys(this.properties) as any)\n  }\n}\n\nexport class RecordType<\n  K extends\n    | AnyLiteralType\n    | AnyEnumType\n    | AnyObjectEnumType\n    | AnyStringType\n    | AnyUnionType,\n  E extends BaseType,\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<\n  TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>,\n  N,\n  O,\n  D,\n  ObjectOptions\n> {\n  constructor(\n    protected readonly key: K,\n    protected readonly element: E,\n    options: ObjectOptions = {},\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, key, element)\n  }\n\n  protected _constructSchema(options: ObjectOptions, key: K, element: E) {\n    let keySchema: TSchema\n\n    if (key instanceof EnumType) {\n      keySchema = Type.Union(key.values.map((value) => Type.Literal(value)))\n    } else if (key instanceof ObjectEnumType) {\n      keySchema = Type.Union(\n        Object.values(key.values).map((value) => Type.Literal(value as string)),\n      )\n    } else {\n      keySchema = getTypeSchema(key)\n    }\n\n    return Type.Record(\n      keySchema,\n      getTypeSchema(element),\n      options,\n    ) as unknown as TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>\n  }\n\n  nullable() {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ isNullable: true }),\n    )\n  }\n\n  optional() {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ isOptional: true }),\n    )\n  }\n\n  nullish() {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: this[typeStatic]['encoded']) {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(\n    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]\n  ) {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ options: { examples } }),\n    )\n  }\n}\n"],"names":["Type","BaseType","getTypeSchema","EnumType","ObjectEnumType","ObjectType","constructor","properties","options","isNullable","isOptional","hasDefault","_constructSchema","schemaProperties","key","value","Object","entries","nullable","_with","optional","nullish","default","description","examples","pick","fromEntries","filter","_","args","omit","extend","merge","object","partial","keyof","keys","RecordType","element","keySchema","Union","values","map","Literal","Record"],"mappings":"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"}
+{"version":3,"sources":["../../../src/types/object.ts"],"sourcesContent":["import {\n  type ObjectOptions,\n  type TObject,\n  type TRecord,\n  Type,\n} from '@sinclair/typebox'\nimport type { typeStatic } from '../constants.ts'\nimport type { UnionToTupleString } from '../utils.ts'\nimport { BaseType, getTypeSchema } from './base.ts'\nimport { type AnyEnumType, type AnyObjectEnumType, EnumType } from './enum.ts'\nimport type { AnyLiteralType } from './literal.ts'\nimport type { AnyStringType } from './string.ts'\nimport type { AnyUnionType } from './union.ts'\n\nexport class ObjectType<\n  T extends Record<string, BaseType>,\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<\n  TObject<{ [K in keyof T]: T[K][typeStatic]['schema'] }>,\n  N,\n  O,\n  D\n> {\n  constructor(\n    protected readonly properties: T = {} as T,\n    options: ObjectOptions = {},\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, properties)\n  }\n\n  protected _constructSchema(\n    options: ObjectOptions,\n    properties: T,\n  ): TObject<{ [K in keyof T]: T[K][typeStatic]['schema'] }> {\n    const schemaProperties = {} as {\n      [K in keyof T]: T[K][typeStatic]['schema']\n    }\n\n    for (const [key, value] of Object.entries(properties)) {\n      // @ts-expect-error\n      schemaProperties[key] = getTypeSchema(value)\n    }\n    return Type.Object(schemaProperties, options)\n  }\n\n  nullable() {\n    return new ObjectType(this.properties, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new ObjectType(this.properties, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: this[typeStatic]['encoded']) {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(\n    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]\n  ) {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ options: { examples } }),\n    )\n  }\n\n  pick<P extends { [K in keyof T]?: true }>(pick: P) {\n    const properties = Object.fromEntries(\n      Object.entries(this.properties).filter(([key]) => pick[key]),\n    )\n    const [_, ...args] = this._with()\n    return new ObjectType(\n      properties as Pick<T, Extract<keyof P, keyof T>>,\n      {},\n      ...args,\n    )\n  }\n\n  omit<P extends { [K in keyof T]?: true }>(omit: P) {\n    const properties = Object.fromEntries(\n      Object.entries(this.properties).filter(([key]) => !omit[key]),\n    )\n    const [_, ...args] = this._with()\n    return new ObjectType(\n      properties as Omit<T, Extract<keyof P, keyof T>>,\n      {},\n      ...args,\n    )\n  }\n\n  extend<P extends Record<string, BaseType>>(properties: P) {\n    const [_, ...args] = this._with()\n    return new ObjectType({ ...this.properties, ...properties }, {}, ...args)\n  }\n\n  merge<T extends ObjectType<Record<string, BaseType>>>(object: T) {\n    const [_, ...args] = this._with()\n    return new ObjectType(\n      { ...this.properties, ...object.properties },\n      {},\n      ...args,\n    )\n  }\n\n  partial() {\n    const properties: { [K in keyof T]: ReturnType<T[K]['optional']> } =\n      {} as any\n    for (const [key, value] of Object.entries(this.properties)) {\n      // @ts-expect-error\n      properties[key] = value.optional()\n    }\n    const [_, ...args] = this._with()\n    return new ObjectType(properties, {}, ...args)\n  }\n\n  keyof(): EnumType<UnionToTupleString<keyof T>> {\n    return new EnumType(Object.keys(this.properties) as any)\n  }\n}\n\nexport class RecordType<\n  K extends\n    | AnyLiteralType\n    | AnyEnumType\n    | AnyObjectEnumType\n    | AnyStringType\n    | AnyUnionType,\n  E extends BaseType,\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<\n  TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>,\n  N,\n  O,\n  D,\n  ObjectOptions\n> {\n  constructor(\n    protected readonly key: K,\n    protected readonly element: E,\n    options: ObjectOptions = {},\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, key, element)\n  }\n\n  protected _constructSchema(options: ObjectOptions, key: K, element: E) {\n    return Type.Record(\n      getTypeSchema(key),\n      getTypeSchema(element),\n      options,\n    ) as unknown as TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>\n  }\n\n  nullable() {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ isNullable: true }),\n    )\n  }\n\n  optional() {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ isOptional: true }),\n    )\n  }\n\n  nullish() {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: this[typeStatic]['encoded']) {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(\n    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]\n  ) {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ options: { examples } }),\n    )\n  }\n}\n"],"names":["Type","BaseType","getTypeSchema","EnumType","ObjectType","constructor","properties","options","isNullable","isOptional","hasDefault","_constructSchema","schemaProperties","key","value","Object","entries","nullable","_with","optional","nullish","default","description","examples","pick","fromEntries","filter","_","args","omit","extend","merge","object","partial","keyof","keys","RecordType","element","Record"],"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.4.1"
+    "@nmtjs/common": "0.4.3"
   },
   "devDependencies": {
     "@sinclair/typebox": "^0.33.7",
     "temporal-polyfill": "^0.2.5",
-    "@nmtjs/common": "0.4.1"
+    "@nmtjs/common": "0.4.3"
   },
   "files": [
     "src",
@@ -35,7 +35,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.4.1",
+  "version": "0.4.3",
   "scripts": {
     "build": "neemata-build -p neutral --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"

package/src/constants.ts

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

package/src/index.ts

@@ -1,4 +1,4 @@
-import type { TLiteralValue } from '@sinclair/typebox'
+import type { TLiteralValue } from '@sinclair/typebox/type'
 import { ArrayType } from './types/array.ts'
 import type { BaseType } from './types/base.ts'
 import { BooleanType } from './types/boolean.ts'
@@ -28,8 +28,6 @@ import { NeverType } from './types/never.ts'
 import { register } from './formats.ts'
 register()
 
-export * from './schemas/native-enum.ts'
-export * from './schemas/union-enum.ts'
 export * from './schemas/nullable.ts'
 export {
   BaseType,

package/src/schemas/nullable.ts

@@ -10,4 +10,23 @@ export type TNullable<T extends TSchema> = TUnion<[T, TNull]>
 export const Nullable = <T extends TSchema>(
   schema: T,
   options: SchemaOptions = {},
-) => Type.Union([schema, Type.Null()], options)
+) => {
+  const {
+    default: _default,
+    description,
+    examples,
+    readOnly,
+    title,
+    writeOnly,
+  } = schema
+
+  return Type.Union([schema, Type.Null()], {
+    default: _default,
+    description,
+    examples,
+    readOnly,
+    title,
+    writeOnly,
+    ...options,
+  })
+}

package/src/types/enum.ts

@@ -1,7 +1,4 @@
-import type { SchemaOptions } from '@sinclair/typebox'
-import type { TNativeEnum } from '../schemas/native-enum.ts'
-import { NativeEnum } from '../schemas/native-enum.ts'
-import { type TUnionEnum, UnionEnum } from '../schemas/union-enum.ts'
+import { Enum, type SchemaOptions, type TEnum } from '@sinclair/typebox'
 import { BaseType } from './base.ts'
 
 export type AnyObjectEnumType<T extends { [K in string]: K } = any> =
@@ -11,9 +8,9 @@ export class ObjectEnumType<
   N extends boolean = false,
   O extends boolean = false,
   D extends boolean = false,
-> extends BaseType<TNativeEnum<T>, N, O, D> {
+> extends BaseType<TEnum<T>, N, O, D> {
   constructor(
-    readonly values: T,
+    private readonly values: T,
     options: SchemaOptions = {},
     isNullable: N = false as N,
     isOptional: O = false as O,
@@ -22,11 +19,8 @@ export class ObjectEnumType<
     super(options, isNullable, isOptional, hasDefault, values)
   }
 
-  protected _constructSchema(
-    options: SchemaOptions,
-    values: T,
-  ): TNativeEnum<T> {
-    return NativeEnum(values, options)
+  protected _constructSchema(options: SchemaOptions, values: T): TEnum<T> {
+    return Enum(values, options)
   }
 
   nullable() {
@@ -66,15 +60,15 @@ export class ObjectEnumType<
   }
 }
 
-export type AnyEnumType = EnumType<any[], boolean, boolean, boolean>
+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<TUnionEnum<T>, N, O, D> {
+> extends BaseType<TEnum<Record<string, T[number]>>, N, O, D> {
   constructor(
-    readonly values: [...T],
+    private readonly values: [...T],
     options: SchemaOptions = {},
     isNullable: N = false as N,
     isOptional: O = false as O,
@@ -86,8 +80,8 @@ export class EnumType<
   protected _constructSchema(
     options: SchemaOptions,
     values: [...T],
-  ): TUnionEnum<T> {
-    return UnionEnum(values, options)
+  ): TEnum<Record<string, T[number]>> {
+    return Enum(Object.fromEntries(values.map((k) => [k, k])), options)
   }
 
   nullable() {

package/src/types/object.ts

@@ -2,18 +2,12 @@ import {
   type ObjectOptions,
   type TObject,
   type TRecord,
-  type TSchema,
   Type,
 } from '@sinclair/typebox'
 import type { typeStatic } from '../constants.ts'
 import type { UnionToTupleString } from '../utils.ts'
 import { BaseType, getTypeSchema } from './base.ts'
-import {
-  type AnyEnumType,
-  type AnyObjectEnumType,
-  EnumType,
-  ObjectEnumType,
-} from './enum.ts'
+import { type AnyEnumType, type AnyObjectEnumType, EnumType } from './enum.ts'
 import type { AnyLiteralType } from './literal.ts'
 import type { AnyStringType } from './string.ts'
 import type { AnyUnionType } from './union.ts'
@@ -176,20 +170,8 @@ export class RecordType<
   }
 
   protected _constructSchema(options: ObjectOptions, key: K, element: E) {
-    let keySchema: TSchema
-
-    if (key instanceof EnumType) {
-      keySchema = Type.Union(key.values.map((value) => Type.Literal(value)))
-    } else if (key instanceof ObjectEnumType) {
-      keySchema = Type.Union(
-        Object.values(key.values).map((value) => Type.Literal(value as string)),
-      )
-    } else {
-      keySchema = getTypeSchema(key)
-    }
-
     return Type.Record(
-      keySchema,
+      getTypeSchema(key),
       getTypeSchema(element),
       options,
     ) as unknown as TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>

package/dist/schemas/native-enum.js

@@ -1,14 +0,0 @@
-import { Kind, TypeRegistry } from '@sinclair/typebox/type';
-export const NativeEnumKind = 'NativeEnum';
-export function NativeEnum(value, options = {}) {
-    const values = Object.values(value);
-    function NativeEnumCheck(schema, value) {
-        return typeof value === 'string' && schema.enum.includes(value);
-    }
-    if (!TypeRegistry.Has(NativeEnumKind)) TypeRegistry.Set(NativeEnumKind, NativeEnumCheck);
-    return {
-        ...options,
-        [Kind]: NativeEnumKind,
-        enum: values
-    };
-}

package/dist/schemas/native-enum.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/schemas/native-enum.ts"],"sourcesContent":["import {\n  Kind,\n  type SchemaOptions,\n  type TSchema,\n  TypeRegistry,\n} from '@sinclair/typebox/type'\n\nexport const NativeEnumKind = 'NativeEnum'\nexport interface TNativeEnum<T extends Record<string, string>> extends TSchema {\n  [Kind]: typeof NativeEnumKind\n  static: T[keyof T]\n  enum: T[keyof T][]\n}\n\nexport function NativeEnum<T extends Record<string, string>>(\n  value: T,\n  options: SchemaOptions = {},\n) {\n  const values = Object.values(value)\n\n  function NativeEnumCheck(schema: TNativeEnum<T>, value: unknown) {\n    return typeof value === 'string' && schema.enum.includes(value as any)\n  }\n\n  if (!TypeRegistry.Has(NativeEnumKind))\n    TypeRegistry.Set(NativeEnumKind, NativeEnumCheck)\n\n  return { ...options, [Kind]: NativeEnumKind, enum: values } as TNativeEnum<T>\n}\n"],"names":["Kind","TypeRegistry","NativeEnumKind","NativeEnum","value","options","values","Object","NativeEnumCheck","schema","enum","includes","Has","Set"],"mappings":"AAAA,SACEA,IAAI,EAGJC,YAAY,QACP,yBAAwB;AAE/B,OAAO,MAAMC,iBAAiB,aAAY;AAO1C,OAAO,SAASC,WACdC,KAAQ,EACRC,UAAyB,CAAC,CAAC;IAE3B,MAAMC,SAASC,OAAOD,MAAM,CAACF;IAE7B,SAASI,gBAAgBC,MAAsB,EAAEL,KAAc;QAC7D,OAAO,OAAOA,UAAU,YAAYK,OAAOC,IAAI,CAACC,QAAQ,CAACP;IAC3D;IAEA,IAAI,CAACH,aAAaW,GAAG,CAACV,iBACpBD,aAAaY,GAAG,CAACX,gBAAgBM;IAEnC,OAAO;QAAE,GAAGH,OAAO;QAAE,CAACL,KAAK,EAAEE;QAAgBQ,MAAMJ;IAAO;AAC5D"}

package/dist/schemas/union-enum.js

@@ -1,13 +0,0 @@
-import { Kind, TypeRegistry } from '@sinclair/typebox/type';
-export const UnionEnumKind = 'UnionEnum';
-export function UnionEnum(values, options = {}) {
-    function UnionEnumCheck(schema, value) {
-        return (typeof value === 'string' || typeof value === 'number') && schema.enum.includes(value);
-    }
-    if (!TypeRegistry.Has(UnionEnumKind)) TypeRegistry.Set(UnionEnumKind, UnionEnumCheck);
-    return {
-        ...options,
-        [Kind]: UnionEnumKind,
-        enum: values
-    };
-}

package/dist/schemas/union-enum.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/schemas/union-enum.ts"],"sourcesContent":["import {\n  Kind,\n  type SchemaOptions,\n  type TSchema,\n  TypeRegistry,\n} from '@sinclair/typebox/type'\n\nexport const UnionEnumKind = 'UnionEnum'\n\n// Ref: https://github.com/sinclairzx81/typebox/blob/master/example/prototypes/union-enum.ts\n\n// -------------------------------------------------------------------------------------\n// TUnionEnum\n// -------------------------------------------------------------------------------------\nexport interface TUnionEnum<T extends (string | number)[]> extends TSchema {\n  [Kind]: typeof UnionEnumKind\n  static: T[number]\n  enum: T\n}\n\n// -------------------------------------------------------------------------------------\n// UnionEnum\n// -------------------------------------------------------------------------------------\n/** `[Experimental]` Creates a Union type with a `enum` schema representation  */\nexport function UnionEnum<T extends (string | number)[]>(\n  values: [...T],\n  options: SchemaOptions = {},\n) {\n  function UnionEnumCheck(\n    schema: TUnionEnum<(string | number)[]>,\n    value: unknown,\n  ) {\n    return (\n      (typeof value === 'string' || typeof value === 'number') &&\n      schema.enum.includes(value)\n    )\n  }\n\n  if (!TypeRegistry.Has(UnionEnumKind))\n    TypeRegistry.Set(UnionEnumKind, UnionEnumCheck)\n\n  return { ...options, [Kind]: UnionEnumKind, enum: values } as TUnionEnum<T>\n}\n"],"names":["Kind","TypeRegistry","UnionEnumKind","UnionEnum","values","options","UnionEnumCheck","schema","value","enum","includes","Has","Set"],"mappings":"AAAA,SACEA,IAAI,EAGJC,YAAY,QACP,yBAAwB;AAE/B,OAAO,MAAMC,gBAAgB,YAAW;AAiBxC,OAAO,SAASC,UACdC,MAAc,EACdC,UAAyB,CAAC,CAAC;IAE3B,SAASC,eACPC,MAAuC,EACvCC,KAAc;QAEd,OACE,AAAC,CAAA,OAAOA,UAAU,YAAY,OAAOA,UAAU,QAAO,KACtDD,OAAOE,IAAI,CAACC,QAAQ,CAACF;IAEzB;IAEA,IAAI,CAACP,aAAaU,GAAG,CAACT,gBACpBD,aAAaW,GAAG,CAACV,eAAeI;IAElC,OAAO;QAAE,GAAGD,OAAO;QAAE,CAACL,KAAK,EAAEE;QAAeO,MAAML;IAAO;AAC3D"}

package/src/schemas/native-enum.ts

@@ -1,29 +0,0 @@
-import {
-  Kind,
-  type SchemaOptions,
-  type TSchema,
-  TypeRegistry,
-} from '@sinclair/typebox/type'
-
-export const NativeEnumKind = 'NativeEnum'
-export interface TNativeEnum<T extends Record<string, string>> extends TSchema {
-  [Kind]: typeof NativeEnumKind
-  static: T[keyof T]
-  enum: T[keyof T][]
-}
-
-export function NativeEnum<T extends Record<string, string>>(
-  value: T,
-  options: SchemaOptions = {},
-) {
-  const values = Object.values(value)
-
-  function NativeEnumCheck(schema: TNativeEnum<T>, value: unknown) {
-    return typeof value === 'string' && schema.enum.includes(value as any)
-  }
-
-  if (!TypeRegistry.Has(NativeEnumKind))
-    TypeRegistry.Set(NativeEnumKind, NativeEnumCheck)
-
-  return { ...options, [Kind]: NativeEnumKind, enum: values } as TNativeEnum<T>
-}

package/src/schemas/union-enum.ts

@@ -1,43 +0,0 @@
-import {
-  Kind,
-  type SchemaOptions,
-  type TSchema,
-  TypeRegistry,
-} from '@sinclair/typebox/type'
-
-export const UnionEnumKind = 'UnionEnum'
-
-// Ref: https://github.com/sinclairzx81/typebox/blob/master/example/prototypes/union-enum.ts
-
-// -------------------------------------------------------------------------------------
-// TUnionEnum
-// -------------------------------------------------------------------------------------
-export interface TUnionEnum<T extends (string | number)[]> extends TSchema {
-  [Kind]: typeof UnionEnumKind
-  static: T[number]
-  enum: T
-}
-
-// -------------------------------------------------------------------------------------
-// UnionEnum
-// -------------------------------------------------------------------------------------
-/** `[Experimental]` Creates a Union type with a `enum` schema representation  */
-export function UnionEnum<T extends (string | number)[]>(
-  values: [...T],
-  options: SchemaOptions = {},
-) {
-  function UnionEnumCheck(
-    schema: TUnionEnum<(string | number)[]>,
-    value: unknown,
-  ) {
-    return (
-      (typeof value === 'string' || typeof value === 'number') &&
-      schema.enum.includes(value)
-    )
-  }
-
-  if (!TypeRegistry.Has(UnionEnumKind))
-    TypeRegistry.Set(UnionEnumKind, UnionEnumCheck)
-
-  return { ...options, [Kind]: UnionEnumKind, enum: values } as TUnionEnum<T>
-}