@sinclair/typebox 0.32.22 → 0.32.24

package/build/import/type/constructor/constructor.d.mts

@@ -10,7 +10,7 @@ type StaticParameter<T extends TSchema, P extends unknown[]> = T extends TReadon
     Static<T, P>
 ];
 type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? StaticParameters<R, P, [...Acc, ...StaticParameter<L, P>]> : Acc);
-type StaticConstructor<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<new (...params: StaticParameters<T, P>) => StaticReturnType<U, P>>;
+type StaticConstructor<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<new (...param: StaticParameters<T, P>) => StaticReturnType<U, P>>;
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
     static: StaticConstructor<T, U, this['params']>;

package/build/import/type/function/function.d.mts

@@ -10,7 +10,7 @@ type StaticParameter<T extends TSchema, P extends unknown[]> = T extends TReadon
     Static<T, P>
 ];
 type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? StaticParameters<R, P, [...Acc, ...StaticParameter<L, P>]> : Acc);
-type StaticFunction<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<(...params: StaticParameters<T, P>) => StaticReturnType<U, P>>;
+type StaticFunction<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<(...param: StaticParameters<T, P>) => StaticReturnType<U, P>>;
 export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Function';
     static: StaticFunction<T, U, this['params']>;

package/build/import/value/clean/clean.mjs

@@ -102,7 +102,7 @@ function FromTuple(schema, references, value) {
 }
 function FromUnion(schema, references, value) {
     for (const inner of schema.anyOf) {
-        if (IsCheckable(inner) && Check(inner, value)) {
+        if (IsCheckable(inner) && Check(inner, references, value)) {
             return Visit(inner, references, value);
         }
     }

package/build/import/value/convert/convert.mjs

@@ -5,7 +5,7 @@ import { Kind } from '../../type/symbols/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol } from '../guard/index.mjs';
+import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol, HasPropertyKey } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // Conversions
 // ------------------------------------------------------------------
@@ -142,11 +142,13 @@ function FromObject(schema, references, value) {
     const isConvertable = IsObject(value);
     if (!isConvertable)
         return value;
-    return Object.getOwnPropertyNames(schema.properties).reduce((value, key) => {
-        return !IsUndefined(value[key])
-            ? ({ ...value, [key]: Visit(schema.properties[key], references, value[key]) })
-            : ({ ...value });
-    }, value);
+    const result = {};
+    for (const key of Object.keys(value)) {
+        result[key] = HasPropertyKey(schema.properties, key)
+            ? Visit(schema.properties[key], references, value[key])
+            : value[key];
+    }
+    return result;
 }
 function FromRecord(schema, references, value) {
     const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0];

package/build/import/value/value/value.d.mts

@@ -19,9 +19,9 @@ export declare function Check<T extends TSchema>(schema: T, value: unknown): val
 export declare function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Clean(schema: TSchema, value: unknown): unknown;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert(schema: TSchema, value: unknown): unknown;
 /** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;

package/build/import/value/value/value.mjs

@@ -27,7 +27,7 @@ export function Check(...args) {
 export function Clean(...args) {
     return CleanValue.apply(CleanValue, args);
 }
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export function Convert(...args) {
     return ConvertValue.apply(ConvertValue, args);
 }

package/build/require/type/constructor/constructor.d.ts

@@ -10,7 +10,7 @@ type StaticParameter<T extends TSchema, P extends unknown[]> = T extends TReadon
     Static<T, P>
 ];
 type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? StaticParameters<R, P, [...Acc, ...StaticParameter<L, P>]> : Acc);
-type StaticConstructor<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<new (...params: StaticParameters<T, P>) => StaticReturnType<U, P>>;
+type StaticConstructor<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<new (...param: StaticParameters<T, P>) => StaticReturnType<U, P>>;
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
     static: StaticConstructor<T, U, this['params']>;

package/build/require/type/function/function.d.ts

@@ -10,7 +10,7 @@ type StaticParameter<T extends TSchema, P extends unknown[]> = T extends TReadon
     Static<T, P>
 ];
 type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? StaticParameters<R, P, [...Acc, ...StaticParameter<L, P>]> : Acc);
-type StaticFunction<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<(...params: StaticParameters<T, P>) => StaticReturnType<U, P>>;
+type StaticFunction<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<(...param: StaticParameters<T, P>) => StaticReturnType<U, P>>;
 export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Function';
     static: StaticFunction<T, U, this['params']>;

package/build/require/value/clean/clean.js

@@ -106,7 +106,7 @@ function FromTuple(schema, references, value) {
 }
 function FromUnion(schema, references, value) {
     for (const inner of schema.anyOf) {
-        if (IsCheckable(inner) && (0, index_2.Check)(inner, value)) {
+        if (IsCheckable(inner) && (0, index_2.Check)(inner, references, value)) {
             return Visit(inner, references, value);
         }
     }

package/build/require/value/convert/convert.js

@@ -146,11 +146,13 @@ function FromObject(schema, references, value) {
     const isConvertable = (0, index_5.IsObject)(value);
     if (!isConvertable)
         return value;
-    return Object.getOwnPropertyNames(schema.properties).reduce((value, key) => {
-        return !(0, index_5.IsUndefined)(value[key])
-            ? ({ ...value, [key]: Visit(schema.properties[key], references, value[key]) })
-            : ({ ...value });
-    }, value);
+    const result = {};
+    for (const key of Object.keys(value)) {
+        result[key] = (0, index_5.HasPropertyKey)(schema.properties, key)
+            ? Visit(schema.properties[key], references, value[key])
+            : value[key];
+    }
+    return result;
 }
 function FromRecord(schema, references, value) {
     const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0];

package/build/require/value/value/value.d.ts

@@ -19,9 +19,9 @@ export declare function Check<T extends TSchema>(schema: T, value: unknown): val
 export declare function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Clean(schema: TSchema, value: unknown): unknown;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert(schema: TSchema, value: unknown): unknown;
 /** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;

package/build/require/value/value/value.js

@@ -35,7 +35,7 @@ function Clean(...args) {
     return index_9.Clean.apply(index_9.Clean, args);
 }
 exports.Clean = Clean;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 function Convert(...args) {
     return index_7.Convert.apply(index_7.Convert, args);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.22",
+  "version": "0.32.24",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",