@sinclair/typebox 0.32.23 → 0.32.25

package/build/require/type/union/union-evaluated.js

@@ -11,14 +11,14 @@ const union_create_1 = require("./union-create");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function IsUnionOptional(T) {
-    return T.some(L => (0, type_2.IsOptional)(L));
+    return T.some(L => (0, kind_1.IsOptional)(L));
 }
 // prettier-ignore
 function RemoveOptionalFromRest(T) {
-    return T.map(L => (0, type_2.IsOptional)(L) ? RemoveOptionalFromType(L) : L);
+    return T.map(L => (0, kind_1.IsOptional)(L) ? RemoveOptionalFromType(L) : L);
 }
 // prettier-ignore
 function RemoveOptionalFromType(T) {

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

@@ -68,7 +68,7 @@ function FromRecord(schema, references, value) {
     if (!(0, index_6.IsObject)(value))
         return value;
     const additionalProperties = schema.additionalProperties;
-    const propertyKeys = Object.keys(value);
+    const propertyKeys = Object.getOwnPropertyNames(value);
     const [propertyKey, propertySchema] = Object.entries(schema.patternProperties)[0];
     const propertyKeyTest = new RegExp(propertyKey);
     for (const key of propertyKeys) {

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

@@ -10,8 +10,14 @@ const index_1 = require("../guard/index");
 // Clonable
 // ------------------------------------------------------------------
 function ObjectType(value) {
-    const keys = [...Object.getOwnPropertyNames(value), ...Object.getOwnPropertySymbols(value)];
-    return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {});
+    const Acc = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+        Acc[key] = Clone(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        Acc[key] = Clone(value[key]);
+    }
+    return Acc;
 }
 function ArrayType(value) {
     return value.map((element) => Clone(element));

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/create/create.js

@@ -211,10 +211,13 @@ function FromObject(schema, references) {
     }
     else {
         const required = new Set(schema.required);
-        return (FromDefault(schema.default) ||
-            Object.entries(schema.properties).reduce((acc, [key, schema]) => {
-                return required.has(key) ? { ...acc, [key]: Visit(schema, references) } : { ...acc };
-            }, {}));
+        const Acc = {};
+        for (const [key, subschema] of Object.entries(schema.properties)) {
+            if (!required.has(key))
+                continue;
+            Acc[key] = Visit(subschema, references);
+        }
+        return Acc;
     }
 }
 function FromPromise(schema, references) {
@@ -232,9 +235,10 @@ function FromRecord(schema, references) {
     }
     else if (!(keyPattern === index_6.PatternStringExact || keyPattern === index_6.PatternNumberExact)) {
         const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
-        return propertyKeys.reduce((acc, key) => {
-            return { ...acc, [key]: Visit(valueSchema, references) };
-        }, {});
+        const Acc = {};
+        for (const key of propertyKeys)
+            Acc[key] = Visit(valueSchema, references);
+        return Acc;
     }
     else {
         return {};

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

@@ -85,7 +85,7 @@ function NumberType(value) {
 }
 function ObjectType(value) {
     FNV1A64(ByteMarker.Object);
-    for (const key of globalThis.Object.keys(value).sort()) {
+    for (const key of globalThis.Object.getOwnPropertyNames(value).sort()) {
         Visit(key);
         Visit(value[key]);
     }

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

@@ -20,8 +20,8 @@ function ObjectType(root, path, current, next) {
         index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
     }
     else {
-        const currentKeys = Object.keys(current);
-        const nextKeys = Object.keys(next);
+        const currentKeys = Object.getOwnPropertyNames(current);
+        const nextKeys = Object.getOwnPropertyNames(next);
         for (const currentKey of currentKeys) {
             if (!nextKeys.includes(currentKey)) {
                 delete current[currentKey];

package/build/require/value/transform/decode.js

@@ -64,21 +64,21 @@ function FromIntersect(schema, references, path, value) {
     if (!(0, index_7.IsStandardObject)(value) || (0, index_7.IsValueType)(value))
         return Default(schema, path, value);
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return (key in value)
-            ? { ...value, [key]: Visit((0, index_4.Index)(schema, [key]), references, `${path}/${key}`, value[key]) }
-            : value;
-    }, value);
+    const knownProperties = { ...value };
+    for (const key of knownKeys)
+        if (key in knownProperties) {
+            knownProperties[key] = Visit((0, index_4.Index)(schema, [key]), references, `${path}/${key}`, knownProperties[key]);
+        }
     if (!(0, type_1.IsTransform)(schema.unevaluatedProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const unevaluatedProperties = schema.unevaluatedProperties;
-    const unknownProperties = unknownKeys.reduce((value, key) => {
-        return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }
-            : value;
-    }, knownProperties);
+    const unknownProperties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            unknownProperties[key] = Default(unevaluatedProperties, `${path}/${key}`, unknownProperties[key]);
+        }
     return Default(schema, path, unknownProperties);
 }
 function FromNot(schema, references, path, value) {
@@ -89,21 +89,21 @@ function FromObject(schema, references, path, value) {
     if (!(0, index_7.IsStandardObject)(value))
         return Default(schema, path, value);
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return (key in value)
-            ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) }
-            : value;
-    }, value);
+    const knownProperties = { ...value };
+    for (const key of knownKeys)
+        if (key in knownProperties) {
+            knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+        }
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
-    const unknownProperties = unknownKeys.reduce((value, key) => {
-        return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
-            : value;
-    }, knownProperties);
+    const unknownProperties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            unknownProperties[key] = Default(additionalProperties, `${path}/${key}`, unknownProperties[key]);
+        }
     return Default(schema, path, unknownProperties);
 }
 // prettier-ignore
@@ -112,21 +112,21 @@ function FromRecord(schema, references, path, value) {
         return Default(schema, path, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
-    const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
-        return knownKeys.test(key)
-            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
-            : value;
-    }, value);
+    const knownProperties = { ...value };
+    for (const key of Object.getOwnPropertyNames(value))
+        if (knownKeys.test(key)) {
+            knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
+        }
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
-    const unknownProperties = unknownKeys.reduce((value, key) => {
-        return !knownKeys.test(key)
-            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
-            : value;
-    }, knownProperties);
+    const unknownProperties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.test(key)) {
+            unknownProperties[key] = Default(additionalProperties, `${path}/${key}`, unknownProperties[key]);
+        }
     return Default(schema, path, unknownProperties);
 }
 // prettier-ignore

package/build/require/value/transform/encode.js

@@ -65,21 +65,22 @@ function FromIntersect(schema, references, path, value) {
     if (!(0, index_7.IsStandardObject)(value) || (0, index_7.IsValueType)(value))
         return defaulted;
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return key in defaulted
-            ? { ...value, [key]: Visit((0, index_4.Index)(schema, [key]), references, `${path}/${key}`, value[key]) }
-            : value;
-    }, defaulted);
+    const knownProperties = { ...defaulted };
+    for (const key of knownKeys)
+        if (key in knownProperties) {
+            knownProperties[key] = Visit((0, index_4.Index)(schema, [key]), references, `${path}/${key}`, knownProperties[key]);
+        }
     if (!(0, type_1.IsTransform)(schema.unevaluatedProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const unevaluatedProperties = schema.unevaluatedProperties;
-    return unknownKeys.reduce((value, key) => {
-        return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }
-            : value;
-    }, knownProperties);
+    const properties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            properties[key] = Default(unevaluatedProperties, `${path}/${key}`, properties[key]);
+        }
+    return properties;
 }
 // prettier-ignore
 function FromNot(schema, references, path, value) {
@@ -91,21 +92,22 @@ function FromObject(schema, references, path, value) {
     if (!(0, index_7.IsStandardObject)(value))
         return defaulted;
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return key in value
-            ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) }
-            : value;
-    }, defaulted);
+    const knownProperties = { ...defaulted };
+    for (const key of knownKeys)
+        if (key in value) {
+            knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+        }
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
         return knownProperties;
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
-    return unknownKeys.reduce((value, key) => {
-        return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
-            : value;
-    }, knownProperties);
+    const properties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            properties[key] = Default(additionalProperties, `${path}/${key}`, properties[key]);
+        }
+    return properties;
 }
 // prettier-ignore
 function FromRecord(schema, references, path, value) {
@@ -114,21 +116,22 @@ function FromRecord(schema, references, path, value) {
         return defaulted;
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
-    const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
-        return knownKeys.test(key)
-            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
-            : value;
-    }, defaulted);
+    const knownProperties = { ...defaulted };
+    for (const key of Object.getOwnPropertyNames(value))
+        if (knownKeys.test(key)) {
+            knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
+        }
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
-    return unknownKeys.reduce((value, key) => {
-        return !knownKeys.test(key)
-            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
-            : value;
-    }, knownProperties);
+    const properties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.test(key)) {
+            properties[key] = Default(additionalProperties, `${path}/${key}`, properties[key]);
+        }
+    return properties;
 }
 // prettier-ignore
 function FromRef(schema, references, path, value) {

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.23",
+  "version": "0.32.25",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -1804,11 +1804,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '120.6 kb' │ ' 52.9 kb' │  '2.28 x'   │
-│ typebox/errors       │ ' 55.7 kb' │ ' 25.5 kb' │  '2.19 x'   │
+│ typebox/compiler     │ '126.9 kb' │ ' 55.7 kb' │  '2.28 x'   │
+│ typebox/errors       │ ' 46.1 kb' │ ' 20.8 kb' │  '2.22 x'   │
 │ typebox/system       │ '  4.7 kb' │ '  2.0 kb' │  '2.33 x'   │
-│ typebox/value        │ '146.2 kb' │ ' 62.0 kb' │  '2.36 x'   │
-│ typebox              │ ' 91.4 kb' │ ' 37.8 kb' │  '2.42 x'   │
+│ typebox/value        │ '152.2 kb' │ ' 64.5 kb' │  '2.36 x'   │
+│ typebox              │ ' 95.7 kb' │ ' 39.8 kb' │  '2.40 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```