@sinclair/typebox 0.31.24 → 0.31.26

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.24",
+  "version": "0.31.26",
   "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[]> = Ensure<AsyncIterableIterator<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[]> = Ensure<IterableIterator<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;
 }
@@ -433,11 +431,11 @@ export type TTemplateLiteralKind = TUnion | TLiteral | TInteger | TTemplateLiter
 export type TTemplateLiteralConst<T, Acc extends string> = T extends TUnion<infer U> ? {
     [K in keyof U]: TTemplateLiteralUnion<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
 }[number] : T extends TTemplateLiteral ? `${Static<T>}` : T extends TLiteral<infer U> ? `${U}` : T extends TString ? `${string}` : T extends TNumber ? `${number}` : T extends TBigInt ? `${bigint}` : T extends TBoolean ? `${boolean}` : never;
-export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
+export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string> = T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
 export type TTemplateLiteralKeyRest<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, TPropertyKey[]>;
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
     [Kind]: 'TemplateLiteral';
-    static: TTemplateLiteralUnion<T>;
+    static: TTemplateLiteralUnion<T, ''>;
     type: 'string';
     pattern: string;
 }

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;