@sinclair/typebox 0.31.25 → 0.31.27

package/compiler/compiler.js

@@ -62,11 +62,11 @@ class TypeCheck {
     Decode(value) {
         if (!this.checkFunc(value))
             throw new transform_1.TransformDecodeCheckError(this.schema, value, this.Errors(value).First());
-        return this.hasTransform ? transform_1.DecodeTransform.Decode(this.schema, this.references, value, (_, __, value) => this.Check(value)) : value;
+        return this.hasTransform ? transform_1.DecodeTransform.Decode(this.schema, this.references, value) : value;
     }
     /** Encodes a value or throws if error */
     Encode(value) {
-        const encoded = this.hasTransform ? transform_1.EncodeTransform.Encode(this.schema, this.references, value, (_, __, value) => this.Check(value)) : value;
+        const encoded = this.hasTransform ? transform_1.EncodeTransform.Encode(this.schema, this.references, value) : value;
         if (!this.checkFunc(encoded))
             throw new transform_1.TransformEncodeCheckError(this.schema, value, this.Errors(value).First());
         return encoded;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.25",
+  "version": "0.31.27",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/typebox.d.ts

@@ -104,10 +104,9 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
     type: 'array';
     items: T;
 }
-export type TAsyncIteratorResolve<T extends TSchema, P extends unknown[]> = AsyncIterableIterator<Ensure<Static<T, P>>>;
 export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'AsyncIterator';
-    static: TAsyncIteratorResolve<T, this['params']>;
+    static: AsyncIterableIterator<Static<T, this['params']>>;
     type: 'AsyncIterator';
     items: T;
 }
@@ -224,10 +223,9 @@ export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, In
     type?: 'object';
     allOf: [...T];
 }
-export type TIteratorResolve<T extends TSchema, P extends unknown[]> = IterableIterator<Ensure<Static<T, P>>>;
 export interface TIterator<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Iterator';
-    static: TIteratorResolve<T, this['params']>;
+    static: IterableIterator<Static<T, this['params']>>;
     type: 'Iterator';
     items: T;
 }
@@ -562,6 +560,8 @@ export declare namespace ValueGuard {
     function IsBigInt(value: unknown): value is bigint;
     /** Returns true if this value is a boolean */
     function IsBoolean(value: unknown): value is boolean;
+    /** Returns true if this value is a Date object */
+    function IsDate(value: unknown): value is Date;
     /** Returns true if this value is null */
     function IsNull(value: unknown): value is null;
     /** Returns true if this value is number */
@@ -570,6 +570,8 @@ export declare namespace ValueGuard {
     function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
     /** Returns true if this value is string */
     function IsString(value: unknown): value is string;
+    /** Returns true if this value is a Uint8Array */
+    function IsUint8Array(value: unknown): value is Uint8Array;
     /** Returns true if this value is undefined */
     function IsUndefined(value: unknown): value is undefined;
 }

package/typebox.js

@@ -145,6 +145,11 @@ var ValueGuard;
         return typeof value === 'boolean';
     }
     ValueGuard.IsBoolean = IsBoolean;
+    /** Returns true if this value is a Date object */
+    function IsDate(value) {
+        return value instanceof globalThis.Date;
+    }
+    ValueGuard.IsDate = IsDate;
     /** Returns true if this value is null */
     function IsNull(value) {
         return value === null;
@@ -165,6 +170,11 @@ var ValueGuard;
         return typeof value === 'string';
     }
     ValueGuard.IsString = IsString;
+    /** Returns true if this value is a Uint8Array */
+    function IsUint8Array(value) {
+        return value instanceof globalThis.Uint8Array;
+    }
+    ValueGuard.IsUint8Array = IsUint8Array;
     /** Returns true if this value is undefined */
     function IsUndefined(value) {
         return value === undefined;
@@ -1252,19 +1262,27 @@ var TypeExtends;
 /** Specialized Clone for Types */
 var TypeClone;
 (function (TypeClone) {
+    function ArrayType(value) {
+        return value.map((value) => Visit(value));
+    }
+    function DateType(value) {
+        return new Date(value.getTime());
+    }
+    function Uint8ArrayType(value) {
+        return new Uint8Array(value);
+    }
     function ObjectType(value) {
         const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
         const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
         return { ...clonedProperties, ...clonedSymbols };
     }
-    function ArrayType(value) {
-        return value.map((value) => Visit(value));
-    }
     function Visit(value) {
         // prettier-ignore
-        return ValueGuard.IsArray(value) ? ArrayType(value) :
-            ValueGuard.IsObject(value) ? ObjectType(value) :
-                value;
+        return (ValueGuard.IsArray(value) ? ArrayType(value) :
+            ValueGuard.IsDate(value) ? DateType(value) :
+                ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) :
+                    ValueGuard.IsObject(value) ? ObjectType(value) :
+                        value);
     }
     /** Clones a Rest */
     function Rest(schemas) {

package/value/create.js

@@ -162,7 +162,7 @@ function TDate(schema, references) {
         return new Date(schema.minimumTimestamp);
     }
     else {
-        return new Date(0);
+        return new Date();
     }
 }
 function TFunction(schema, references) {

package/value/transform.d.ts

@@ -34,9 +34,9 @@ export declare namespace HasTransform {
 }
 /** Decodes a value using transform decoders if available. Does not ensure correct results. */
 export declare namespace DecodeTransform {
-    function Decode(schema: Types.TSchema, references: Types.TSchema[], value: unknown, check: CheckFunction): unknown;
+    function Decode(schema: Types.TSchema, references: Types.TSchema[], value: unknown): unknown;
 }
 /** Encodes a value using transform encoders if available. Does not ensure correct results. */
 export declare namespace EncodeTransform {
-    function Encode(schema: Types.TSchema, references: Types.TSchema[], value: unknown, check: CheckFunction): unknown;
+    function Encode(schema: Types.TSchema, references: Types.TSchema[], value: unknown): unknown;
 }

package/value/transform.js

@@ -30,6 +30,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EncodeTransform = exports.DecodeTransform = exports.HasTransform = exports.TransformEncodeError = exports.TransformDecodeError = exports.TransformEncodeCheckError = exports.TransformDecodeCheckError = exports.TransformUnknownTypeError = void 0;
 const guard_1 = require("./guard");
 const deref_1 = require("./deref");
+const check_1 = require("./check");
 const Types = require("../typebox");
 // -------------------------------------------------------------------------
 // Errors
@@ -125,7 +126,7 @@ var HasTransform;
         return Visit((0, deref_1.Deref)(schema, references), references);
     }
     function TTuple(schema, references) {
-        return Types.TypeGuard.TTransform(schema) || (Types.TypeGuard.TSchema(schema.items) && schema.items.some((schema) => Visit(schema, references)));
+        return Types.TypeGuard.TTransform(schema) || (!(0, guard_1.IsUndefined)(schema.items) && schema.items.some((schema) => Visit(schema, references)));
     }
     function TUnion(schema, references) {
         return Types.TypeGuard.TTransform(schema) || schema.anyOf.some((schema) => Visit(schema, references));
@@ -287,7 +288,7 @@ var DecodeTransform;
     function TUnion(schema, references, value) {
         const value1 = Default(schema, value);
         for (const subschema of schema.anyOf) {
-            if (!checkFunction(subschema, references, value1))
+            if (!(0, check_1.Check)(subschema, references, value1))
                 continue;
             return Visit(subschema, references, value1);
         }
@@ -350,9 +351,7 @@ var DecodeTransform;
                 return Default(schema_, value);
         }
     }
-    let checkFunction = () => false;
-    function Decode(schema, references, value, check) {
-        checkFunction = check;
+    function Decode(schema, references, value) {
         return Visit(schema, references, value);
     }
     DecodeTransform.Decode = Decode;
@@ -441,7 +440,7 @@ var EncodeTransform;
     function TUnion(schema, references, value) {
         // test value against union variants
         for (const subschema of schema.anyOf) {
-            if (!checkFunction(subschema, references, value))
+            if (!(0, check_1.Check)(subschema, references, value))
                 continue;
             const value1 = Visit(subschema, references, value);
             return Default(schema, value1);
@@ -449,7 +448,7 @@ var EncodeTransform;
         // test transformed value against union variants
         for (const subschema of schema.anyOf) {
             const value1 = Visit(subschema, references, value);
-            if (!checkFunction(schema, references, value1))
+            if (!(0, check_1.Check)(schema, references, value1))
                 continue;
             return Default(schema, value1);
         }
@@ -511,9 +510,7 @@ var EncodeTransform;
                 return Default(schema_, value);
         }
     }
-    let checkFunction = () => false;
-    function Encode(schema, references, value, check) {
-        checkFunction = check;
+    function Encode(schema, references, value) {
         return Visit(schema, references, value);
     }
     EncodeTransform.Encode = Encode;

package/value/value.d.ts

@@ -23,13 +23,13 @@ export declare namespace Value {
     /** Returns a structural clone of the given value */
     function Clone<T>(value: T): T;
     /** Decodes a value or throws if error */
-    function Decode<T extends Types.TSchema, D = Types.StaticDecode<T>>(schema: T, references: Types.TSchema[], value: unknown): D;
+    function Decode<T extends Types.TSchema, R = Types.StaticDecode<T>>(schema: T, references: Types.TSchema[], value: unknown): R;
     /** Decodes a value or throws if error */
-    function Decode<T extends Types.TSchema, D = Types.StaticDecode<T>>(schema: T, value: unknown): D;
+    function Decode<T extends Types.TSchema, R = Types.StaticDecode<T>>(schema: T, value: unknown): R;
     /** Encodes a value or throws if error */
-    function Encode<T extends Types.TSchema, E = Types.StaticEncode<T>>(schema: T, references: Types.TSchema[], value: unknown): E;
+    function Encode<T extends Types.TSchema, R = Types.StaticEncode<T>>(schema: T, references: Types.TSchema[], value: unknown): R;
     /** Encodes a value or throws if error */
-    function Encode<T extends Types.TSchema, E = Types.StaticEncode<T>>(schema: T, value: unknown): E;
+    function Encode<T extends Types.TSchema, R = Types.StaticEncode<T>>(schema: T, value: unknown): R;
     /** Returns an iterator for each error in this value. */
     function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): ValueErrors.ValueErrorIterator;
     /** Returns an iterator for each error in this value. */

package/value/value.js

@@ -72,13 +72,13 @@ var Value;
         const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
         if (!Check(schema, references, value))
             throw new ValueTransform.TransformDecodeCheckError(schema, value, Errors(schema, references, value).First());
-        return ValueTransform.DecodeTransform.Decode(schema, references, value, ValueCheck.Check);
+        return ValueTransform.DecodeTransform.Decode(schema, references, value);
     }
     Value.Decode = Decode;
     /** Encodes a value or throws if error */
     function Encode(...args) {
         const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
-        const encoded = ValueTransform.EncodeTransform.Encode(schema, references, value, ValueCheck.Check);
+        const encoded = ValueTransform.EncodeTransform.Encode(schema, references, value);
         if (!Check(schema, references, encoded))
             throw new ValueTransform.TransformEncodeCheckError(schema, value, Errors(schema, references, value).First());
         return encoded;