@nmtjs/type 0.4.8 → 0.5.0

package/dist/compiler.js

@@ -1,72 +1,118 @@
 import { TypeCompiler } from '@sinclair/typebox/compiler';
-import { Value } from '@sinclair/typebox/value';
-import { getTypeSchema } from "./types/base.js";
+import { TransformDecode, TransformEncode, Value } from '@sinclair/typebox/value';
+import { IsDiscriminatedUnion } from "./schemas/discriminated-union.js";
 function _parse(schema, value) {
     return Value.Convert(schema, Value.Default(schema, Value.Clean(schema, Value.Clone(value))));
 }
+function _errors(errors) {
+    const result = [];
+    for (const error of errors){
+        if (IsDiscriminatedUnion(error.schema)) {
+            const discriminator = error.schema.discriminator;
+            const discriminatorValue = error.value?.[discriminator];
+            if (discriminatorValue !== undefined) {
+                const variantSchema = error.schema.anyOf.find((schema)=>schema.properties[discriminator].const === discriminatorValue);
+                if (variantSchema) {
+                    const propertiesSchemas = [];
+                    for(const element in variantSchema.properties){
+                        const propertySchema = variantSchema.properties[element];
+                        if (propertySchema !== variantSchema.properties[discriminator]) {
+                            propertiesSchemas.push(propertySchema);
+                        }
+                    }
+                    for (const iter of error.errors){
+                        for (const err of iter){
+                            if (!propertiesSchemas.includes(err.schema)) continue;
+                            result.push({
+                                path: err.path,
+                                message: err.message,
+                                value: err.value
+                            });
+                        }
+                    }
+                    continue;
+                }
+            }
+        }
+        result.push({
+            path: error.path,
+            message: error.message,
+            value: error.value
+        });
+        for (const nestedError of error.errors){
+            result.push(..._errors(nestedError));
+        }
+    }
+    return result;
+}
 function compileType(type) {
-    const schema = getTypeSchema(type);
+    const { final: schema } = type;
     const compiled = TypeCompiler.Compile(schema);
+    const errors = (value)=>{
+        return _errors(compiled.Errors(value));
+    };
     return {
         check: compiled.Check.bind(compiled),
-        errors: compiled.Errors.bind(compiled),
-        decode: compiled.Decode.bind(compiled),
-        encode: compiled.Encode.bind(compiled),
-        parse: _parse.bind(null, schema)
+        parse: _parse.bind(null, schema),
+        errors,
+        decode: TransformDecode.bind(null, schema, compiled.References()),
+        encode: TransformEncode.bind(null, schema, compiled.References())
     };
 }
 export function compile(schema) {
     const compiled = compileType(schema);
+    function decodeSafe(val) {
+        try {
+            return {
+                success: true,
+                value: compiled.decode(val)
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error
+            };
+        }
+    }
+    function encodeSafe(val) {
+        try {
+            return {
+                success: true,
+                value: compiled.encode(val)
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error
+            };
+        }
+    }
     return {
         ...compiled,
-        decodeSafe: (val)=>{
-            try {
-                return {
-                    success: true,
-                    value: compiled.decode(val)
-                };
-            } catch (error) {
-                return {
-                    success: false,
-                    error
-                };
-            }
-        },
-        encodeSafe: (val)=>{
-            try {
-                return {
-                    success: true,
-                    value: compiled.encode(val)
-                };
-            } catch (error) {
-                return {
-                    success: false,
-                    error
-                };
-            }
-        }
+        decodeSafe,
+        encodeSafe
     };
 }
 export var runtime;
 (function(runtime) {
     function parse(type, value) {
-        return _parse(getTypeSchema(type), value);
+        return _parse(type.schema, value);
     }
     runtime.parse = parse;
     function errors(type, value) {
-        return Value.Errors(getTypeSchema(type), value);
+        return _errors(Value.Errors(type.schema, value));
     }
     runtime.errors = errors;
     function check(type, value) {
-        return Value.Check(getTypeSchema(type), value);
+        return Value.Check(type.schema, value);
     }
     runtime.check = check;
     function decode(type, value) {
-        return Value.Decode(getTypeSchema(type), value);
+        return TransformDecode(type.schema, [], value);
     }
     runtime.decode = decode;
     function encode(type, value) {
-        return Value.Encode(getTypeSchema(type), value);
+        return TransformEncode(type.schema, [], value);
     }
     runtime.encode = encode;
 })(runtime || (runtime = {}));

package/dist/compiler.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/compiler.ts"],"sourcesContent":["import type { TSchema } from '@sinclair/typebox'\nimport {\n  TypeCompiler,\n  type ValueErrorIterator,\n} from '@sinclair/typebox/compiler'\nimport { Value } from '@sinclair/typebox/value'\nimport type { typeStatic } from './constants.ts'\nimport { type BaseType, getTypeSchema } from './types/base.ts'\n\nexport type Compiled<T extends BaseType = BaseType> = {\n  check: (val: unknown) => boolean\n  errors: (val: unknown) => ValueErrorIterator\n  parse: (val: unknown) => unknown\n  decode: (val: unknown) => T[typeStatic]['decoded']\n  encode: (val: unknown) => T[typeStatic]['encoded']\n  decodeSafe: (\n    val: unknown,\n  ) =>\n    | { success: true; value: T[typeStatic]['decoded'] }\n    | { success: false; error: any }\n  encodeSafe: (\n    val: unknown,\n  ) =>\n    | { success: true; value: T[typeStatic]['encoded'] }\n    | { success: false; error: any }\n}\n\nfunction _parse(schema: TSchema, value: any) {\n  // Clone -> Clean -> Default -> Convert\n  return Value.Convert(\n    schema,\n    Value.Default(schema, Value.Clean(schema, Value.Clone(value))),\n  )\n}\n\nfunction compileType(type: BaseType) {\n  const schema = getTypeSchema(type)\n  const compiled = TypeCompiler.Compile(schema)\n  return {\n    check: compiled.Check.bind(compiled),\n    errors: compiled.Errors.bind(compiled),\n    decode: compiled.Decode.bind(compiled),\n    encode: compiled.Encode.bind(compiled),\n    parse: _parse.bind(null, schema),\n  }\n}\n\nexport function compile<T extends BaseType>(schema: T): Compiled<T> {\n  const compiled = compileType(schema)\n\n  return {\n    ...compiled,\n    decodeSafe: (val) => {\n      try {\n        return {\n          success: true as const,\n          value: compiled.decode(val),\n        }\n      } catch (error) {\n        return { success: false as const, error }\n      }\n    },\n    encodeSafe: (val) => {\n      try {\n        return {\n          success: true as const,\n          value: compiled.encode(val),\n        }\n      } catch (error) {\n        return { success: false as const, error }\n      }\n    },\n  }\n}\n\nexport namespace runtime {\n  export function parse(type: BaseType, value: any) {\n    return _parse(getTypeSchema(type), value)\n  }\n\n  export function errors(type: BaseType, value: any): ValueErrorIterator {\n    return Value.Errors(getTypeSchema(type), value)\n  }\n\n  export function check(type: BaseType, value: any): boolean {\n    return Value.Check(getTypeSchema(type), value)\n  }\n\n  export function decode<T extends BaseType>(\n    type: BaseType,\n    value: any,\n  ): T[typeStatic]['decoded'] {\n    return Value.Decode(getTypeSchema(type), value)\n  }\n\n  export function encode<T extends BaseType>(\n    type: T,\n    value: any,\n  ): T[typeStatic]['encoded'] {\n    return Value.Encode(getTypeSchema(type), value)\n  }\n}\n"],"names":["TypeCompiler","Value","getTypeSchema","_parse","schema","value","Convert","Default","Clean","Clone","compileType","type","compiled","Compile","check","Check","bind","errors","Errors","decode","Decode","encode","Encode","parse","compile","decodeSafe","val","success","error","encodeSafe","runtime"],"mappings":"AACA,SACEA,YAAY,QAEP,6BAA4B;AACnC,SAASC,KAAK,QAAQ,0BAAyB;AAE/C,SAAwBC,aAAa,QAAQ,kBAAiB;AAoB9D,SAASC,OAAOC,MAAe,EAAEC,KAAU;IAEzC,OAAOJ,MAAMK,OAAO,CAClBF,QACAH,MAAMM,OAAO,CAACH,QAAQH,MAAMO,KAAK,CAACJ,QAAQH,MAAMQ,KAAK,CAACJ;AAE1D;AAEA,SAASK,YAAYC,IAAc;IACjC,MAAMP,SAASF,cAAcS;IAC7B,MAAMC,WAAWZ,aAAaa,OAAO,CAACT;IACtC,OAAO;QACLU,OAAOF,SAASG,KAAK,CAACC,IAAI,CAACJ;QAC3BK,QAAQL,SAASM,MAAM,CAACF,IAAI,CAACJ;QAC7BO,QAAQP,SAASQ,MAAM,CAACJ,IAAI,CAACJ;QAC7BS,QAAQT,SAASU,MAAM,CAACN,IAAI,CAACJ;QAC7BW,OAAOpB,OAAOa,IAAI,CAAC,MAAMZ;IAC3B;AACF;AAEA,OAAO,SAASoB,QAA4BpB,MAAS;IACnD,MAAMQ,WAAWF,YAAYN;IAE7B,OAAO;QACL,GAAGQ,QAAQ;QACXa,YAAY,CAACC;YACX,IAAI;gBACF,OAAO;oBACLC,SAAS;oBACTtB,OAAOO,SAASO,MAAM,CAACO;gBACzB;YACF,EAAE,OAAOE,OAAO;gBACd,OAAO;oBAAED,SAAS;oBAAgBC;gBAAM;YAC1C;QACF;QACAC,YAAY,CAACH;YACX,IAAI;gBACF,OAAO;oBACLC,SAAS;oBACTtB,OAAOO,SAASS,MAAM,CAACK;gBACzB;YACF,EAAE,OAAOE,OAAO;gBACd,OAAO;oBAAED,SAAS;oBAAgBC;gBAAM;YAC1C;QACF;IACF;AACF;;UAEiBE;IACR,SAASP,MAAMZ,IAAc,EAAEN,KAAU;QAC9C,OAAOF,OAAOD,cAAcS,OAAON;IACrC;YAFgBkB,QAAAA;IAIT,SAASN,OAAON,IAAc,EAAEN,KAAU;QAC/C,OAAOJ,MAAMiB,MAAM,CAAChB,cAAcS,OAAON;IAC3C;YAFgBY,SAAAA;IAIT,SAASH,MAAMH,IAAc,EAAEN,KAAU;QAC9C,OAAOJ,MAAMc,KAAK,CAACb,cAAcS,OAAON;IAC1C;YAFgBS,QAAAA;IAIT,SAASK,OACdR,IAAc,EACdN,KAAU;QAEV,OAAOJ,MAAMmB,MAAM,CAAClB,cAAcS,OAAON;IAC3C;YALgBc,SAAAA;IAOT,SAASE,OACdV,IAAO,EACPN,KAAU;QAEV,OAAOJ,MAAMqB,MAAM,CAACpB,cAAcS,OAAON;IAC3C;YALgBgB,SAAAA;AAMlB,GA1BiBS,YAAAA"}
+{"version":3,"sources":["../../src/compiler.ts"],"sourcesContent":["import type { TSchema } from '@sinclair/typebox'\nimport {\n  TypeCompiler,\n  type ValueErrorIterator,\n} from '@sinclair/typebox/compiler'\nimport {\n  TransformDecode,\n  TransformEncode,\n  Value,\n} from '@sinclair/typebox/value'\nimport type { t } from './index.ts'\nimport { IsDiscriminatedUnion } from './schemas/discriminated-union.ts'\nimport type { BaseType } from './types/base.ts'\n\ntype ValidationError = {\n  path: string\n  message: string\n  value: unknown\n}\n\nexport type Compiled<T extends BaseType = BaseType> = {\n  check: (val: unknown) => boolean\n  errors: (val: unknown) => ValidationError[]\n  parse: (val: unknown) => unknown\n  /**\n   * Requires to `check` before calling\n   */\n  decode: (val: unknown) => t.infer.decoded<T>\n  /**\n   * Requires to `check` before calling\n   */\n  encode: (val: unknown) => t.infer.encoded<T>\n  /**\n   * Requires to `check` before calling\n   */\n  decodeSafe: (\n    val: unknown,\n  ) =>\n    | { success: true; value: t.infer.decoded<T> }\n    | { success: false; error: any }\n  /**\n   * Requires to `check` before calling\n   */\n  encodeSafe: (\n    val: unknown,\n  ) =>\n    | { success: true; value: t.infer.encoded<T> }\n    | { success: false; error: any }\n}\n\n// FIXME: this one is very slow\nfunction _parse(schema: TSchema, value: any) {\n  // Clone -> Clean -> Default -> Convert\n  return Value.Convert(\n    schema,\n    Value.Default(schema, Value.Clean(schema, Value.Clone(value))),\n  )\n}\n\nfunction _errors(errors: ValueErrorIterator) {\n  const result: ValidationError[] = []\n\n  for (const error of errors) {\n    if (IsDiscriminatedUnion(error.schema)) {\n      const discriminator = error.schema.discriminator\n      const discriminatorValue = error.value?.[discriminator]\n      if (discriminatorValue !== undefined) {\n        const variantSchema = error.schema.anyOf.find(\n          (schema) =>\n            schema.properties[discriminator].const === discriminatorValue,\n        )\n        if (variantSchema) {\n          const propertiesSchemas: TSchema[] = []\n          for (const element in variantSchema.properties) {\n            const propertySchema = variantSchema.properties[element]\n            if (propertySchema !== variantSchema.properties[discriminator]) {\n              propertiesSchemas.push(propertySchema)\n            }\n          }\n\n          for (const iter of error.errors) {\n            for (const err of iter) {\n              if (!propertiesSchemas.includes(err.schema)) continue\n              result.push({\n                path: err.path,\n                message: err.message,\n                value: err.value,\n              })\n            }\n          }\n\n          continue\n        }\n      }\n    }\n\n    result.push({\n      path: error.path,\n      message: error.message,\n      value: error.value,\n    })\n\n    for (const nestedError of error.errors) {\n      result.push(..._errors(nestedError))\n    }\n  }\n\n  return result\n}\n\nfunction compileType(type: BaseType) {\n  const { final: schema } = type\n  const compiled = TypeCompiler.Compile(schema)\n  const errors = (value) => {\n    return _errors(compiled.Errors(value))\n  }\n\n  return {\n    check: compiled.Check.bind(compiled),\n    parse: _parse.bind(null, schema),\n    errors,\n    decode: TransformDecode.bind(null, schema, compiled.References()),\n    encode: TransformEncode.bind(null, schema, compiled.References()),\n  }\n}\n\nexport function compile<T extends BaseType>(schema: T): Compiled<T> {\n  const compiled = compileType(schema)\n\n  function decodeSafe(val: unknown) {\n    try {\n      return {\n        success: true as const,\n        value: compiled.decode(val),\n      }\n    } catch (error) {\n      return { success: false as const, error }\n    }\n  }\n\n  function encodeSafe(val: unknown) {\n    try {\n      return {\n        success: true as const,\n        value: compiled.encode(val),\n      }\n    } catch (error) {\n      return { success: false as const, error }\n    }\n  }\n\n  return {\n    ...compiled,\n    decodeSafe,\n    encodeSafe,\n  } as any\n}\n\nexport namespace runtime {\n  export function parse(type: BaseType, value: any) {\n    return _parse(type.schema, value)\n  }\n\n  export function errors(type: BaseType, value: any): ValidationError[] {\n    return _errors(Value.Errors(type.schema, value))\n  }\n\n  export function check(type: BaseType, value: any): boolean {\n    return Value.Check(type.schema, value)\n  }\n\n  export function decode<T extends BaseType>(\n    type: T,\n    value: any,\n  ): t.infer.decoded<T> {\n    return TransformDecode(type.schema, [], value)\n  }\n\n  export function encode<T extends BaseType>(\n    type: T,\n    value: any,\n  ): t.infer.encoded<T> {\n    return TransformEncode(type.schema, [], value)\n  }\n}\n"],"names":["TypeCompiler","TransformDecode","TransformEncode","Value","IsDiscriminatedUnion","_parse","schema","value","Convert","Default","Clean","Clone","_errors","errors","result","error","discriminator","discriminatorValue","undefined","variantSchema","anyOf","find","properties","const","propertiesSchemas","element","propertySchema","push","iter","err","includes","path","message","nestedError","compileType","type","final","compiled","Compile","Errors","check","Check","bind","parse","decode","References","encode","compile","decodeSafe","val","success","encodeSafe","runtime"],"mappings":"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"}

package/dist/index.js

@@ -1,37 +1,68 @@
+import { AnyType } from "./types/any.js";
 import { ArrayType } from "./types/array.js";
 import { BooleanType } from "./types/boolean.js";
 import { CustomType } from "./types/custom.js";
-import { DateType } from "./types/datetime.js";
+import { DateType } from "./types/date.js";
 import { EnumType, ObjectEnumType } from "./types/enum.js";
 import { LiteralType } from "./types/literal.js";
+import { NeverType } from "./types/never.js";
 import { BigIntType, IntegerType, NumberType } from "./types/number.js";
 import { ObjectType, RecordType } from "./types/object.js";
 import { StringType } from "./types/string.js";
-import { IntersactionType, UnionType } from "./types/union.js";
-import { AnyType } from "./types/any.js";
-import { NeverType } from "./types/never.js";
+import { DiscriminatedUnionType, IntersactionType, UnionType } from "./types/union.js";
 import { register } from "./formats.js";
 register();
 export * from "./schemas/nullable.js";
-export { BaseType, getTypeSchema } from "./types/base.js";
+export { BaseType } from "./types/base.js";
 export { ArrayType, BooleanType, CustomType, DateType, EnumType, LiteralType, IntegerType, NumberType, ObjectType, StringType, IntersactionType, UnionType, AnyType, NeverType,  };
 export var t;
 (function(t) {
-    t.never = ()=>new NeverType();
-    t.boolean = ()=>new BooleanType();
-    t.string = ()=>new StringType();
-    t.number = ()=>new NumberType();
-    t.integer = ()=>new IntegerType();
-    t.bitint = ()=>new BigIntType();
-    t.literal = (value)=>new LiteralType(value);
-    t.objectEnum = (enumLike)=>new ObjectEnumType(enumLike);
-    t.arrayEnum = (enumLike)=>new EnumType(enumLike);
-    t.date = ()=>new DateType();
-    t.array = (element)=>new ArrayType(element);
-    t.object = (properties)=>new ObjectType(properties);
-    t.record = (key, value)=>new RecordType(key, value);
-    t.any = ()=>new AnyType();
-    t.or = (...types)=>new UnionType(types);
-    t.and = (...types)=>new IntersactionType(types);
-    t.custom = (decode, encode)=>new CustomType(decode, encode);
+    t.never = NeverType.factory;
+    t.boolean = BooleanType.factory;
+    t.string = StringType.factory;
+    t.number = NumberType.factory;
+    t.integer = IntegerType.factory;
+    t.bitint = BigIntType.factory;
+    t.literal = LiteralType.factory;
+    t.objectEnum = ObjectEnumType.factory;
+    t.arrayEnum = EnumType.factory;
+    t.date = DateType.factory;
+    t.array = ArrayType.factory;
+    t.object = ObjectType.factory;
+    t.record = RecordType.factory;
+    t.any = AnyType.factory;
+    t.or = UnionType.factory;
+    t.and = IntersactionType.factory;
+    t.discriminatedUnion = DiscriminatedUnionType.factory;
+    t.custom = CustomType.factory;
+    t.keyof = (type)=>{
+        return t.arrayEnum(Object.keys(type.props.properties));
+    };
+    t.pick = (source, pick)=>{
+        const properties = Object.fromEntries(Object.entries(source.props.properties).filter(([key])=>pick[key]));
+        return ObjectType.factory(properties);
+    };
+    t.omit = (source, omit)=>{
+        const properties = Object.fromEntries(Object.entries(source.props.properties).filter(([key])=>!omit[key]));
+        return ObjectType.factory(properties);
+    };
+    t.extend = (object1, properties)=>{
+        return ObjectType.factory({
+            ...object1.props.properties,
+            ...properties
+        });
+    };
+    t.merge = (object1, object2)=>{
+        return ObjectType.factory({
+            ...object1.props.properties,
+            ...object2.props.properties
+        });
+    };
+    t.partial = (object)=>{
+        const properties = {};
+        for (const [key, value] of Object.entries(object.props.properties)){
+            properties[key] = value.optional();
+        }
+        return ObjectType.factory(properties, {});
+    };
 })(t || (t = {}));

package/dist/index.js.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import type {\n  StaticDecode,\n  StaticEncode,\n  TLiteralValue,\n} from '@sinclair/typebox/type'\nimport { AnyType } from './types/any.ts'\nimport { ArrayType } from './types/array.ts'\nimport type {\n  BaseType,\n  BaseTypeAny,\n  OptionalType,\n  Static,\n} from './types/base.ts'\nimport { BooleanType } from './types/boolean.ts'\nimport { CustomType } from './types/custom.ts'\nimport { DateType } from './types/date.ts'\nimport { EnumType, ObjectEnumType } from './types/enum.ts'\nimport { LiteralType } from './types/literal.ts'\nimport { NeverType } from './types/never.ts'\nimport { BigIntType, IntegerType, NumberType } from './types/number.ts'\nimport { ObjectType, type ObjectTypeProps, RecordType } from './types/object.ts'\nimport { StringType } from './types/string.ts'\nimport {\n  DiscriminatedUnionType,\n  IntersactionType,\n  UnionType,\n} from './types/union.ts'\nimport type { UnionToTupleString } from './utils.ts'\n\n// register ajv formats\nimport { register } from './formats.ts'\nregister()\n\nexport * from './schemas/nullable.ts'\nexport { BaseType, type BaseTypeAny } 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 decoded<T extends BaseTypeAny> = StaticDecode<\n      T['_']['decoded']['output']\n    >\n    export type encoded<T extends BaseTypeAny> = StaticEncode<\n      T['_']['encoded']['output']\n    >\n    export namespace input {\n      export type decoded<T extends BaseTypeAny> = StaticDecode<\n        T['_']['decoded']['input']\n      >\n      export type encoded<T extends BaseTypeAny> = StaticEncode<\n        T['_']['encoded']['input']\n      >\n    }\n  }\n\n  export const never = NeverType.factory\n  export const boolean = BooleanType.factory\n  export const string = StringType.factory\n  export const number = NumberType.factory\n  export const integer = IntegerType.factory\n  export const bitint = BigIntType.factory\n  export const literal = LiteralType.factory\n  export const objectEnum = ObjectEnumType.factory\n  export const arrayEnum = EnumType.factory\n  export const date = DateType.factory\n  export const array = ArrayType.factory\n  export const object = ObjectType.factory\n  export const record = RecordType.factory\n  export const any = AnyType.factory\n  export const or = UnionType.factory\n  export const and = IntersactionType.factory\n  export const discriminatedUnion = DiscriminatedUnionType.factory\n  export const custom = CustomType.factory\n\n  export const keyof = <T extends ObjectType>(\n    type: T,\n  ): EnumType<\n    UnionToTupleString<T extends ObjectType<infer Props> ? keyof Props : never>\n  > => {\n    return arrayEnum(Object.keys(type.props.properties) as any)\n  }\n\n  export const pick = <\n    T extends ObjectType,\n    P extends { [K in keyof T['props']['properties']]?: true },\n  >(\n    source: T,\n    pick: P,\n  ): ObjectType<{\n    [K in keyof T['props']['properties'] as K extends keyof P\n      ? K\n      : never]: T['props']['properties'][K]\n  }> => {\n    const properties = Object.fromEntries(\n      Object.entries(source.props.properties).filter(([key]) => pick[key]),\n    )\n    return ObjectType.factory(properties) as any\n  }\n\n  export const omit = <\n    T extends ObjectType,\n    P extends { [K in keyof T]?: true },\n  >(\n    source: T,\n    omit: P,\n  ): ObjectType<{\n    [K in keyof T['props']['properties'] as K extends keyof P\n      ? never\n      : K]: T['props']['properties'][K]\n  }> => {\n    const properties = Object.fromEntries(\n      Object.entries(source.props.properties).filter(([key]) => !omit[key]),\n    )\n    return ObjectType.factory(properties) as any\n  }\n\n  export const extend = <T extends ObjectType, P extends ObjectTypeProps>(\n    object1: T,\n    properties: P,\n  ): ObjectType<{\n    [K in keyof T['props']['properties'] | keyof P]: K extends keyof P\n      ? P[K]\n      : K extends keyof T['props']['properties']\n        ? T['props']['properties'][K]\n        : never\n  }> => {\n    return ObjectType.factory({\n      ...object1.props.properties,\n      ...properties,\n    }) as any\n  }\n\n  export const merge = <T1 extends ObjectType, T2 extends ObjectType>(\n    object1: T1,\n    object2: T2,\n  ): ObjectType<{\n    [K in\n      | keyof T1['props']['properties']\n      | keyof T2['props']['properties']]: K extends keyof T2['props']['properties']\n      ? T2['props']['properties'][K]\n      : K extends keyof T1['props']['properties']\n        ? T1['props']['properties'][K]\n        : never\n  }> => {\n    return ObjectType.factory({\n      ...object1.props.properties,\n      ...object2.props.properties,\n    }) as any\n  }\n\n  export const partial = <T extends ObjectType>(\n    object: T,\n  ): ObjectType<{\n    [K in keyof T['props']['properties']]: OptionalType<\n      T['props']['properties'][K]\n    >\n  }> => {\n    const properties = {} as any\n\n    for (const [key, value] of Object.entries(object.props.properties)) {\n      properties[key] = value.optional()\n    }\n\n    return ObjectType.factory(properties, {}) as any\n  }\n}\n"],"names":["AnyType","ArrayType","BooleanType","CustomType","DateType","EnumType","ObjectEnumType","LiteralType","NeverType","BigIntType","IntegerType","NumberType","ObjectType","RecordType","StringType","DiscriminatedUnionType","IntersactionType","UnionType","register","BaseType","t","never","factory","boolean","string","number","integer","bitint","literal","objectEnum","arrayEnum","date","array","object","record","any","or","and","discriminatedUnion","custom","keyof","type","Object","keys","props","properties","pick","source","fromEntries","entries","filter","key","omit","extend","object1","merge","object2","partial","value","optional"],"mappings":"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"}

package/dist/schemas/discriminated-union.js

@@ -0,0 +1,9 @@
+import { KindGuard, Type, TypeGuard, ValueGuard } from '@sinclair/typebox';
+export function IsDiscriminatedUnion(schema) {
+    return TypeGuard.IsUnion(schema) && 'discriminator' in schema && ValueGuard.IsString(schema.discriminator) && schema.anyOf.every((variant)=>KindGuard.IsObject(variant) && KindGuard.IsLiteralString(variant.properties[schema.discriminator]));
+}
+export function DiscriminatedUnion(key, types) {
+    return Type.Union(types, {
+        discriminator: key
+    });
+}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/schemas/discriminated-union.ts"],"sourcesContent":["import {\n  KindGuard,\n  type TLiteral,\n  type TObject,\n  type TPropertyKey,\n  type TSchema,\n  type TUnion,\n  Type,\n  TypeGuard,\n  ValueGuard,\n} from '@sinclair/typebox'\n\nexport function IsDiscriminatedUnion(\n  schema: TSchema,\n): schema is TDiscriminatedUnion {\n  return (\n    TypeGuard.IsUnion(schema) &&\n    'discriminator' in schema &&\n    ValueGuard.IsString(schema.discriminator) &&\n    schema.anyOf.every(\n      (variant) =>\n        KindGuard.IsObject(variant) &&\n        KindGuard.IsLiteralString(variant.properties[schema.discriminator]),\n    )\n  )\n}\n\ntype DiscriminatedUnionProperties<K extends string = string> = {\n  [OK in K]: TLiteral<any>\n} & {\n  [OK in TPropertyKey]: any\n}\n\nexport interface TDiscriminatedUnion<\n  K extends string = string,\n  T extends TObject<DiscriminatedUnionProperties<K>>[] = TObject<\n    DiscriminatedUnionProperties<K>\n  >[],\n> extends TUnion<T> {\n  discriminator: K\n  anyOf: T\n}\n\nexport function DiscriminatedUnion<\n  K extends string,\n  T extends TObject<DiscriminatedUnionProperties<K>>[],\n>(key: K, types: T): TDiscriminatedUnion<K, T> {\n  return Type.Union(types, { discriminator: key }) as any\n}\n"],"names":["KindGuard","Type","TypeGuard","ValueGuard","IsDiscriminatedUnion","schema","IsUnion","IsString","discriminator","anyOf","every","variant","IsObject","IsLiteralString","properties","DiscriminatedUnion","key","types","Union"],"mappings":"AAAA,SACEA,SAAS,EAMTC,IAAI,EACJC,SAAS,EACTC,UAAU,QACL,oBAAmB;AAE1B,OAAO,SAASC,qBACdC,MAAe;IAEf,OACEH,UAAUI,OAAO,CAACD,WAClB,mBAAmBA,UACnBF,WAAWI,QAAQ,CAACF,OAAOG,aAAa,KACxCH,OAAOI,KAAK,CAACC,KAAK,CAChB,CAACC,UACCX,UAAUY,QAAQ,CAACD,YACnBX,UAAUa,eAAe,CAACF,QAAQG,UAAU,CAACT,OAAOG,aAAa,CAAC;AAG1E;AAkBA,OAAO,SAASO,mBAGdC,GAAM,EAAEC,KAAQ;IAChB,OAAOhB,KAAKiB,KAAK,CAACD,OAAO;QAAET,eAAeQ;IAAI;AAChD"}

package/dist/schemas/nullable.js

@@ -1,16 +1,11 @@
 import { Type } from '@sinclair/typebox/type';
 export const Nullable = (schema, options = {})=>{
-    const { default: _default, description, examples, readOnly, title, writeOnly } = schema;
+    const { default: _default } = schema;
     return Type.Union([
         schema,
         Type.Null()
     ], {
         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) => {\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"}
+{"version":3,"sources":["../../../src/schemas/nullable.ts"],"sourcesContent":["import {\n  type SchemaOptions,\n  type TNull,\n  type TOptional,\n  type TSchema,\n  type TUndefined,\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 { default: _default } = schema\n\n  return Type.Union([schema, Type.Null()], {\n    default: _default,\n    ...options,\n  })\n}\n\nexport type TOptionalUndefined<T extends TSchema> = TOptional<\n  TUnion<[T, TUndefined]>\n>\n"],"names":["Type","Nullable","schema","options","default","_default","Union","Null"],"mappings":"AAAA,SAOEA,IAAI,QACC,yBAAwB;AAG/B,OAAO,MAAMC,WAAW,CACtBC,QACAC,UAAyB,CAAC,CAAC;IAE3B,MAAM,EAAEC,SAASC,QAAQ,EAAE,GAAGH;IAE9B,OAAOF,KAAKM,KAAK,CAAC;QAACJ;QAAQF,KAAKO,IAAI;KAAG,EAAE;QACvCH,SAASC;QACT,GAAGF,OAAO;IACZ;AACF,EAAC"}

package/dist/temporal.js

@@ -1,9 +1,9 @@
 import { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType } from "./types/temporal.js";
-export const plainDate = ()=>new PlainDateType();
-export const plainDatetime = ()=>new PlainDateTimeType();
-export const plainTime = ()=>new PlainTimeType();
-export const zonedDatetime = ()=>new ZonedDateTimeType();
-export const duration = ()=>new DurationType();
-export const plainYearMonth = ()=>new PlainYearMonthType();
-export const plainMonthDay = ()=>new PlainMonthDayType();
+export const plainDate = PlainDateType.factory;
+export const plainDatetime = PlainDateTimeType.factory;
+export const plainTime = PlainTimeType.factory;
+export const zonedDatetime = ZonedDateTimeType.factory;
+export const duration = DurationType.factory;
+export const plainYearMonth = PlainYearMonthType.factory;
+export const plainMonthDay = PlainMonthDayType.factory;
 export { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType,  };

package/dist/temporal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/temporal.ts"],"sourcesContent":["import {\n  DurationType,\n  PlainDateTimeType,\n  PlainDateType,\n  PlainMonthDayType,\n  PlainTimeType,\n  PlainYearMonthType,\n  ZonedDateTimeType,\n} from './types/temporal.ts'\n\nexport const plainDate = () => new PlainDateType()\nexport const plainDatetime = () => new PlainDateTimeType()\nexport const plainTime = () => new PlainTimeType()\nexport const zonedDatetime = () => new ZonedDateTimeType()\nexport const duration = () => new DurationType()\nexport const plainYearMonth = () => new PlainYearMonthType()\nexport const plainMonthDay = () => new PlainMonthDayType()\n\nexport {\n  DurationType,\n  PlainDateTimeType,\n  PlainDateType,\n  PlainMonthDayType,\n  PlainTimeType,\n  PlainYearMonthType,\n  ZonedDateTimeType,\n}\n"],"names":["DurationType","PlainDateTimeType","PlainDateType","PlainMonthDayType","PlainTimeType","PlainYearMonthType","ZonedDateTimeType","plainDate","plainDatetime","plainTime","zonedDatetime","duration","plainYearMonth","plainMonthDay"],"mappings":"AAAA,SACEA,YAAY,EACZC,iBAAiB,EACjBC,aAAa,EACbC,iBAAiB,EACjBC,aAAa,EACbC,kBAAkB,EAClBC,iBAAiB,QACZ,sBAAqB;AAE5B,OAAO,MAAMC,YAAY,IAAM,IAAIL,gBAAe;AAClD,OAAO,MAAMM,gBAAgB,IAAM,IAAIP,oBAAmB;AAC1D,OAAO,MAAMQ,YAAY,IAAM,IAAIL,gBAAe;AAClD,OAAO,MAAMM,gBAAgB,IAAM,IAAIJ,oBAAmB;AAC1D,OAAO,MAAMK,WAAW,IAAM,IAAIX,eAAc;AAChD,OAAO,MAAMY,iBAAiB,IAAM,IAAIP,qBAAoB;AAC5D,OAAO,MAAMQ,gBAAgB,IAAM,IAAIV,oBAAmB;AAE1D,SACEH,YAAY,EACZC,iBAAiB,EACjBC,aAAa,EACbC,iBAAiB,EACjBC,aAAa,EACbC,kBAAkB,EAClBC,iBAAiB,KAClB"}
+{"version":3,"sources":["../../src/temporal.ts"],"sourcesContent":["import { Temporal } from 'temporal-polyfill'\nimport {\n  DurationType,\n  PlainDateTimeType,\n  PlainDateType,\n  PlainMonthDayType,\n  PlainTimeType,\n  PlainYearMonthType,\n  ZonedDateTimeType,\n} from './types/temporal.ts'\n\nexport const plainDate = PlainDateType.factory\nexport const plainDatetime = PlainDateTimeType.factory\nexport const plainTime = PlainTimeType.factory\nexport const zonedDatetime = ZonedDateTimeType.factory\nexport const duration = DurationType.factory\nexport const plainYearMonth = PlainYearMonthType.factory\nexport const plainMonthDay = PlainMonthDayType.factory\n\nexport {\n  DurationType,\n  PlainDateTimeType,\n  PlainDateType,\n  PlainMonthDayType,\n  PlainTimeType,\n  PlainYearMonthType,\n  ZonedDateTimeType,\n}\n"],"names":["DurationType","PlainDateTimeType","PlainDateType","PlainMonthDayType","PlainTimeType","PlainYearMonthType","ZonedDateTimeType","plainDate","factory","plainDatetime","plainTime","zonedDatetime","duration","plainYearMonth","plainMonthDay"],"mappings":"AACA,SACEA,YAAY,EACZC,iBAAiB,EACjBC,aAAa,EACbC,iBAAiB,EACjBC,aAAa,EACbC,kBAAkB,EAClBC,iBAAiB,QACZ,sBAAqB;AAE5B,OAAO,MAAMC,YAAYL,cAAcM,OAAO,CAAA;AAC9C,OAAO,MAAMC,gBAAgBR,kBAAkBO,OAAO,CAAA;AACtD,OAAO,MAAME,YAAYN,cAAcI,OAAO,CAAA;AAC9C,OAAO,MAAMG,gBAAgBL,kBAAkBE,OAAO,CAAA;AACtD,OAAO,MAAMI,WAAWZ,aAAaQ,OAAO,CAAA;AAC5C,OAAO,MAAMK,iBAAiBR,mBAAmBG,OAAO,CAAA;AACxD,OAAO,MAAMM,gBAAgBX,kBAAkBK,OAAO,CAAA;AAEtD,SACER,YAAY,EACZC,iBAAiB,EACjBC,aAAa,EACbC,iBAAiB,EACjBC,aAAa,EACbC,kBAAkB,EAClBC,iBAAiB,KAClB"}

package/dist/types/any.js

@@ -1,48 +1,8 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class AnyType extends BaseType {
-    constructor(options = {}, isNullable = false, isOptional = false, hasDefault = false){
-        super(options, isNullable, isOptional, hasDefault);
-    }
-    _constructSchema(options) {
-        return Type.Any(options);
-    }
-    nullable() {
-        return new AnyType(...this._with({
-            isNullable: true
-        }));
-    }
-    optional() {
-        return new AnyType(...this._with({
-            isOptional: true
-        }));
-    }
-    nullish() {
-        return new AnyType(...this._with({
-            isNullable: true,
-            isOptional: true
-        }));
-    }
-    default(value) {
-        return new AnyType(...this._with({
-            options: {
-                default: value
-            },
-            hasDefault: true
-        }));
-    }
-    description(description) {
-        return new AnyType(...this._with({
-            options: {
-                description
-            }
-        }));
-    }
-    examples(...examples) {
-        return new AnyType(...this._with({
-            options: {
-                examples
-            }
-        }));
+    _;
+    static factory() {
+        return new AnyType(Type.Any());
     }
 }

package/dist/types/any.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/any.ts"],"sourcesContent":["import { type SchemaOptions, type TAny, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class AnyType<\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TAny, N, O, D, SchemaOptions> {\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(options: SchemaOptions): TAny {\n    return Type.Any(options)\n  }\n\n  nullable() {\n    return new AnyType(...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new AnyType(...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new AnyType(...this._with({ isNullable: true, isOptional: true }))\n  }\n\n  default(value: any) {\n    return new AnyType(\n      ...this._with({\n        options: { default: value },\n        hasDefault: true,\n      }),\n    )\n  }\n\n  description(description: string) {\n    return new AnyType(...this._with({ options: { description } }))\n  }\n\n  examples(...examples: [any, ...any[]]) {\n    return new AnyType(...this._with({ options: { examples } }))\n  }\n}\n"],"names":["Type","BaseType","AnyType","constructor","options","isNullable","isOptional","hasDefault","_constructSchema","Any","nullable","_with","optional","nullish","default","value","description","examples"],"mappings":"AAAA,SAAwCA,IAAI,QAAQ,oBAAmB;AACvE,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,gBAIHD;IACRE,YACEC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC;IACzC;IAEUC,iBAAiBJ,OAAsB,EAAQ;QACvD,OAAOJ,KAAKS,GAAG,CAACL;IAClB;IAEAM,WAAW;QACT,OAAO,IAAIR,WAAW,IAAI,CAACS,KAAK,CAAC;YAAEN,YAAY;QAAK;IACtD;IAEAO,WAAW;QACT,OAAO,IAAIV,WAAW,IAAI,CAACS,KAAK,CAAC;YAAEL,YAAY;QAAK;IACtD;IAEAO,UAAU;QACR,OAAO,IAAIX,WAAW,IAAI,CAACS,KAAK,CAAC;YAAEN,YAAY;YAAMC,YAAY;QAAK;IACxE;IAEAQ,QAAQC,KAAU,EAAE;QAClB,OAAO,IAAIb,WACN,IAAI,CAACS,KAAK,CAAC;YACZP,SAAS;gBAAEU,SAASC;YAAM;YAC1BR,YAAY;QACd;IAEJ;IAEAS,YAAYA,WAAmB,EAAE;QAC/B,OAAO,IAAId,WAAW,IAAI,CAACS,KAAK,CAAC;YAAEP,SAAS;gBAAEY;YAAY;QAAE;IAC9D;IAEAC,SAAS,GAAGA,QAAyB,EAAE;QACrC,OAAO,IAAIf,WAAW,IAAI,CAACS,KAAK,CAAC;YAAEP,SAAS;gBAAEa;YAAS;QAAE;IAC3D;AACF"}
+{"version":3,"sources":["../../../src/types/any.ts"],"sourcesContent":["import { type TAny, Type } from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\n\nexport class AnyType extends BaseType<TAny> {\n  _!: ConstantType<this['schema']>\n\n  static factory() {\n    return new AnyType(Type.Any())\n  }\n}\n"],"names":["Type","BaseType","AnyType","_","factory","Any"],"mappings":"AAAA,SAAoBA,IAAI,QAAQ,oBAAmB;AACnD,SAASC,QAAQ,QAA2B,YAAW;AAEvD,OAAO,MAAMC,gBAAgBD;IAC3BE,EAAgC;IAEhC,OAAOC,UAAU;QACf,OAAO,IAAIF,QAAQF,KAAKK,GAAG;IAC7B;AACF"}

package/dist/types/array.js

@@ -1,73 +1,27 @@
 import { Type } from '@sinclair/typebox';
-import { BaseType, getTypeSchema } from "./base.js";
+import { BaseType } from "./base.js";
 export class ArrayType extends BaseType {
-    element;
-    constructor(element, options = {}, isNullable = false, isOptional = false, hasDefault = false){
-        super(options, isNullable, isOptional, hasDefault, element);
-        this.element = element;
-    }
-    _constructSchema(options, element) {
-        return Type.Array(getTypeSchema(element), options);
-    }
-    nullable() {
-        return new ArrayType(this.element, ...this._with({
-            isNullable: true
-        }));
-    }
-    optional() {
-        return new ArrayType(this.element, ...this._with({
-            isOptional: true
-        }));
-    }
-    nullish() {
-        return new ArrayType(this.element, ...this._with({
-            isNullable: true,
-            isOptional: true
-        }));
-    }
-    default(value) {
-        return new ArrayType(this.element, ...this._with({
-            options: {
-                default: value
-            },
-            hasDefault: true
-        }));
-    }
-    description(description) {
-        return new ArrayType(this.element, ...this._with({
-            options: {
-                description
-            }
-        }));
-    }
-    examples(...examples) {
-        return new ArrayType(this.element, ...this._with({
-            options: {
-                example: examples[0],
-                examples
-            }
-        }));
+    _;
+    static factory(element, options = {}) {
+        return new ArrayType(Type.Array(element.schema, options));
     }
     min(value) {
-        return new ArrayType(this.element, ...this._with({
-            options: {
-                minItems: value
-            }
-        }));
+        return ArrayType.factory(this.props.element, {
+            ...this.props.options,
+            minItems: value
+        });
     }
     max(value) {
-        return new ArrayType(this.element, ...this._with({
-            options: {
-                maxItems: value
-            }
-        }));
+        return ArrayType.factory(this.props.element, {
+            ...this.props.options,
+            maxItems: value
+        });
     }
     length(value) {
-        return new ArrayType(this.element, ...this._with({
-            options: {
-                minItems: value,
-                maxItems: value
-            }
-        }));
+        return ArrayType.factory(this.props.element, {
+            ...this.props.options,
+            minItems: value,
+            maxItems: value
+        });
     }
 }

package/dist/types/array.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/array.ts"],"sourcesContent":["import { type ArrayOptions, type TArray, Type } from '@sinclair/typebox'\nimport type { typeStatic } from '../constants.ts'\nimport { BaseType, getTypeSchema } from './base.ts'\n\nexport class ArrayType<\n  T extends BaseType = BaseType,\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TArray<T[typeStatic]['schema']>, N, O, D, ArrayOptions> {\n  constructor(\n    readonly element: T,\n    options: ArrayOptions = {},\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, element)\n  }\n\n  protected _constructSchema(\n    options: ArrayOptions,\n    element: T,\n  ): TArray<T[typeStatic]['schema']> {\n    return Type.Array(getTypeSchema(element), options)\n  }\n\n  nullable() {\n    return new ArrayType(this.element, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new ArrayType(this.element, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new ArrayType(\n      this.element,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: this[typeStatic]['encoded']) {\n    return new ArrayType(\n      this.element,\n      ...this._with({\n        options: { default: value },\n        hasDefault: true,\n      }),\n    )\n  }\n\n  description(description: string) {\n    return new ArrayType(\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 ArrayType(\n      this.element,\n      ...this._with({\n        options: { example: examples[0], examples },\n      }),\n    )\n  }\n\n  min(value: number) {\n    return new ArrayType(\n      this.element,\n      ...this._with({\n        options: { minItems: value },\n      }),\n    )\n  }\n\n  max(value: number) {\n    return new ArrayType(\n      this.element,\n      ...this._with({\n        options: { maxItems: value },\n      }),\n    )\n  }\n\n  length(value: number) {\n    return new ArrayType(\n      this.element,\n      ...this._with({\n        options: { minItems: value, maxItems: value },\n      }),\n    )\n  }\n}\n"],"names":["Type","BaseType","getTypeSchema","ArrayType","constructor","element","options","isNullable","isOptional","hasDefault","_constructSchema","Array","nullable","_with","optional","nullish","default","value","description","examples","example","min","minItems","max","maxItems","length"],"mappings":"AAAA,SAAyCA,IAAI,QAAQ,oBAAmB;AAExE,SAASC,QAAQ,EAAEC,aAAa,QAAQ,YAAW;AAEnD,OAAO,MAAMC,kBAKHF;;IACRG,YACE,AAASC,OAAU,EACnBC,UAAwB,CAAC,CAAC,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC,YAAYJ;aAN1CA,UAAAA;IAOX;IAEUK,iBACRJ,OAAqB,EACrBD,OAAU,EACuB;QACjC,OAAOL,KAAKW,KAAK,CAACT,cAAcG,UAAUC;IAC5C;IAEAM,WAAW;QACT,OAAO,IAAIT,UAAU,IAAI,CAACE,OAAO,KAAK,IAAI,CAACQ,KAAK,CAAC;YAAEN,YAAY;QAAK;IACtE;IAEAO,WAAW;QACT,OAAO,IAAIX,UAAU,IAAI,CAACE,OAAO,KAAK,IAAI,CAACQ,KAAK,CAAC;YAAEL,YAAY;QAAK;IACtE;IAEAO,UAAU;QACR,OAAO,IAAIZ,UACT,IAAI,CAACE,OAAO,KACT,IAAI,CAACQ,KAAK,CAAC;YAAEN,YAAY;YAAMC,YAAY;QAAK;IAEvD;IAEAQ,QAAQC,KAAkC,EAAE;QAC1C,OAAO,IAAId,UACT,IAAI,CAACE,OAAO,KACT,IAAI,CAACQ,KAAK,CAAC;YACZP,SAAS;gBAAEU,SAASC;YAAM;YAC1BR,YAAY;QACd;IAEJ;IAEAS,YAAYA,WAAmB,EAAE;QAC/B,OAAO,IAAIf,UACT,IAAI,CAACE,OAAO,KACT,IAAI,CAACQ,KAAK,CAAC;YAAEP,SAAS;gBAAEY;YAAY;QAAE;IAE7C;IAEAC,SACE,GAAGA,QAAyE,EAC5E;QACA,OAAO,IAAIhB,UACT,IAAI,CAACE,OAAO,KACT,IAAI,CAACQ,KAAK,CAAC;YACZP,SAAS;gBAAEc,SAASD,QAAQ,CAAC,EAAE;gBAAEA;YAAS;QAC5C;IAEJ;IAEAE,IAAIJ,KAAa,EAAE;QACjB,OAAO,IAAId,UACT,IAAI,CAACE,OAAO,KACT,IAAI,CAACQ,KAAK,CAAC;YACZP,SAAS;gBAAEgB,UAAUL;YAAM;QAC7B;IAEJ;IAEAM,IAAIN,KAAa,EAAE;QACjB,OAAO,IAAId,UACT,IAAI,CAACE,OAAO,KACT,IAAI,CAACQ,KAAK,CAAC;YACZP,SAAS;gBAAEkB,UAAUP;YAAM;QAC7B;IAEJ;IAEAQ,OAAOR,KAAa,EAAE;QACpB,OAAO,IAAId,UACT,IAAI,CAACE,OAAO,KACT,IAAI,CAACQ,KAAK,CAAC;YACZP,SAAS;gBAAEgB,UAAUL;gBAAOO,UAAUP;YAAM;QAC9C;IAEJ;AACF"}
+{"version":3,"sources":["../../../src/types/array.ts"],"sourcesContent":["import {\n  type ArrayOptions,\n  type StaticDecode,\n  type TArray,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class ArrayType<T extends BaseType = BaseType> extends BaseType<\n  TArray<T['schema']>,\n  { element: T; options: ArrayOptions }\n> {\n  _!: {\n    encoded: {\n      input: TArray<T['_']['encoded']['input']>\n      output: TArray<T['_']['encoded']['output']>\n    }\n    decoded: {\n      input: TArray<T['_']['decoded']['input']>\n      output: TArray<T['_']['decoded']['output']>\n    }\n  }\n\n  static factory<T extends BaseType>(element: T, options: ArrayOptions = {}) {\n    return new ArrayType<T>(Type.Array(element.schema, options))\n  }\n\n  min(value: number) {\n    return ArrayType.factory(this.props.element, {\n      ...this.props.options,\n      minItems: value,\n    })\n  }\n\n  max(value: number) {\n    return ArrayType.factory(this.props.element, {\n      ...this.props.options,\n      maxItems: value,\n    })\n  }\n\n  length(value: number) {\n    return ArrayType.factory(this.props.element, {\n      ...this.props.options,\n      minItems: value,\n      maxItems: value,\n    })\n  }\n}\n"],"names":["Type","BaseType","ArrayType","_","factory","element","options","Array","schema","min","value","props","minItems","max","maxItems","length"],"mappings":"AAAA,SAIEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,kBAAiDD;IAI5DE,EASC;IAED,OAAOC,QAA4BC,OAAU,EAAEC,UAAwB,CAAC,CAAC,EAAE;QACzE,OAAO,IAAIJ,UAAaF,KAAKO,KAAK,CAACF,QAAQG,MAAM,EAAEF;IACrD;IAEAG,IAAIC,KAAa,EAAE;QACjB,OAAOR,UAAUE,OAAO,CAAC,IAAI,CAACO,KAAK,CAACN,OAAO,EAAE;YAC3C,GAAG,IAAI,CAACM,KAAK,CAACL,OAAO;YACrBM,UAAUF;QACZ;IACF;IAEAG,IAAIH,KAAa,EAAE;QACjB,OAAOR,UAAUE,OAAO,CAAC,IAAI,CAACO,KAAK,CAACN,OAAO,EAAE;YAC3C,GAAG,IAAI,CAACM,KAAK,CAACL,OAAO;YACrBQ,UAAUJ;QACZ;IACF;IAEAK,OAAOL,KAAa,EAAE;QACpB,OAAOR,UAAUE,OAAO,CAAC,IAAI,CAACO,KAAK,CAACN,OAAO,EAAE;YAC3C,GAAG,IAAI,CAACM,KAAK,CAACL,OAAO;YACrBM,UAAUF;YACVI,UAAUJ;QACZ;IACF;AACF"}