@sinclair/typebox 0.32.27 → 0.32.29

package/build/cjs/type/keyof/index.d.ts

@@ -1,3 +1,4 @@
 export * from './keyof-from-mapped-result';
+export * from './keyof-property-entries';
 export * from './keyof-property-keys';
 export * from './keyof';

package/build/cjs/type/keyof/index.js

@@ -16,5 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./keyof-from-mapped-result"), exports);
+__exportStar(require("./keyof-property-entries"), exports);
 __exportStar(require("./keyof-property-keys"), exports);
 __exportStar(require("./keyof"), exports);

package/build/cjs/type/keyof/keyof-property-entries.d.ts

@@ -0,0 +1,7 @@
+import { TSchema } from '../schema/index';
+/**
+ * `[Utility]` Resolves an array of keys and schemas from the given schema. This method is faster
+ * than obtaining the keys and resolving each individually via indexing. This method was written
+ * accellerate Intersect and Union encoding.
+ */
+export declare function KeyOfPropertyEntries(schema: TSchema): [key: string, schema: TSchema][];

package/build/cjs/type/keyof/keyof-property-entries.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyOfPropertyEntries = void 0;
+const indexed_1 = require("../indexed/indexed");
+const keyof_property_keys_1 = require("./keyof-property-keys");
+/**
+ * `[Utility]` Resolves an array of keys and schemas from the given schema. This method is faster
+ * than obtaining the keys and resolving each individually via indexing. This method was written
+ * accellerate Intersect and Union encoding.
+ */
+function KeyOfPropertyEntries(schema) {
+    const keys = (0, keyof_property_keys_1.KeyOfPropertyKeys)(schema);
+    const schemas = (0, indexed_1.IndexFromPropertyKeys)(schema, keys);
+    return keys.map((_, index) => [keys[index], schemas[index]]);
+}
+exports.KeyOfPropertyEntries = KeyOfPropertyEntries;

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

@@ -5,13 +5,12 @@ exports.TransformDecode = exports.TransformDecodeError = exports.TransformDecode
 const index_1 = require("../../type/symbols/index");
 const index_2 = require("../../type/error/index");
 const index_3 = require("../../type/keyof/index");
-const index_4 = require("../../type/indexed/index");
-const index_5 = require("../deref/index");
-const index_6 = require("../check/index");
+const index_4 = require("../deref/index");
+const index_5 = require("../check/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-const index_7 = require("../guard/index");
+const index_6 = require("../guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -55,19 +54,20 @@ function Default(schema, path, value) {
 }
 // prettier-ignore
 function FromArray(schema, references, path, value) {
-    return ((0, index_7.IsArray)(value))
+    return ((0, index_6.IsArray)(value))
         ? Default(schema, path, value.map((value, index) => Visit(schema.items, references, `${path}/${index}`, value)))
         : Default(schema, path, value);
 }
 // prettier-ignore
 function FromIntersect(schema, references, path, value) {
-    if (!(0, index_7.IsStandardObject)(value) || (0, index_7.IsValueType)(value))
+    if (!(0, index_6.IsStandardObject)(value) || (0, index_6.IsValueType)(value))
         return Default(schema, path, value);
-    const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
+    const knownEntries = (0, index_3.KeyOfPropertyEntries)(schema);
+    const knownKeys = knownEntries.map(entry => entry[0]);
     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]);
+    for (const [knownKey, knownSchema] of knownEntries)
+        if (knownKey in knownProperties) {
+            knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
         }
     if (!(0, type_1.IsTransform)(schema.unevaluatedProperties)) {
         return Default(schema, path, knownProperties);
@@ -86,7 +86,7 @@ function FromNot(schema, references, path, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, path, value) {
-    if (!(0, index_7.IsStandardObject)(value))
+    if (!(0, index_6.IsStandardObject)(value))
         return Default(schema, path, value);
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = { ...value };
@@ -108,7 +108,7 @@ function FromObject(schema, references, path, value) {
 }
 // prettier-ignore
 function FromRecord(schema, references, path, value) {
-    if (!(0, index_7.IsStandardObject)(value))
+    if (!(0, index_6.IsStandardObject)(value))
         return Default(schema, path, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
@@ -131,24 +131,24 @@ function FromRecord(schema, references, path, value) {
 }
 // prettier-ignore
 function FromRef(schema, references, path, value) {
-    const target = (0, index_5.Deref)(schema, references);
+    const target = (0, index_4.Deref)(schema, references);
     return Default(schema, path, Visit(target, references, path, value));
 }
 // prettier-ignore
 function FromThis(schema, references, path, value) {
-    const target = (0, index_5.Deref)(schema, references);
+    const target = (0, index_4.Deref)(schema, references);
     return Default(schema, path, Visit(target, references, path, value));
 }
 // prettier-ignore
 function FromTuple(schema, references, path, value) {
-    return ((0, index_7.IsArray)(value) && (0, index_7.IsArray)(schema.items))
+    return ((0, index_6.IsArray)(value) && (0, index_6.IsArray)(schema.items))
         ? Default(schema, path, schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value[index])))
         : Default(schema, path, value);
 }
 // prettier-ignore
 function FromUnion(schema, references, path, value) {
     for (const subschema of schema.anyOf) {
-        if (!(0, index_6.Check)(subschema, references, value))
+        if (!(0, index_5.Check)(subschema, references, value))
             continue;
         // note: ensure interior is decoded first
         const decoded = Visit(subschema, references, path, value);

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

@@ -5,13 +5,12 @@ exports.TransformEncode = exports.TransformEncodeError = exports.TransformEncode
 const index_1 = require("../../type/symbols/index");
 const index_2 = require("../../type/error/index");
 const index_3 = require("../../type/keyof/index");
-const index_4 = require("../../type/indexed/index");
-const index_5 = require("../deref/index");
-const index_6 = require("../check/index");
+const index_4 = require("../deref/index");
+const index_5 = require("../check/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-const index_7 = require("../guard/index");
+const index_6 = require("../guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -55,20 +54,21 @@ function Default(schema, path, value) {
 // prettier-ignore
 function FromArray(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    return (0, index_7.IsArray)(defaulted)
+    return (0, index_6.IsArray)(defaulted)
         ? defaulted.map((value, index) => Visit(schema.items, references, `${path}/${index}`, value))
         : defaulted;
 }
 // prettier-ignore
 function FromIntersect(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!(0, index_7.IsStandardObject)(value) || (0, index_7.IsValueType)(value))
+    if (!(0, index_6.IsStandardObject)(value) || (0, index_6.IsValueType)(value))
         return defaulted;
-    const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
+    const knownEntries = (0, index_3.KeyOfPropertyEntries)(schema);
+    const knownKeys = knownEntries.map(entry => entry[0]);
     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]);
+    for (const [knownKey, knownSchema] of knownEntries)
+        if (knownKey in knownProperties) {
+            knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
         }
     if (!(0, type_1.IsTransform)(schema.unevaluatedProperties)) {
         return Default(schema, path, knownProperties);
@@ -89,12 +89,12 @@ function FromNot(schema, references, path, value) {
 // prettier-ignore
 function FromObject(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!(0, index_7.IsStandardObject)(value))
+    if (!(0, index_6.IsStandardObject)(defaulted))
         return defaulted;
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = { ...defaulted };
     for (const key of knownKeys)
-        if (key in value) {
+        if (key in knownProperties) {
             knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
         }
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
@@ -112,7 +112,7 @@ function FromObject(schema, references, path, value) {
 // prettier-ignore
 function FromRecord(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!(0, index_7.IsStandardObject)(value))
+    if (!(0, index_6.IsStandardObject)(value))
         return defaulted;
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
@@ -135,26 +135,26 @@ function FromRecord(schema, references, path, value) {
 }
 // prettier-ignore
 function FromRef(schema, references, path, value) {
-    const target = (0, index_5.Deref)(schema, references);
+    const target = (0, index_4.Deref)(schema, references);
     const resolved = Visit(target, references, path, value);
     return Default(schema, path, resolved);
 }
 // prettier-ignore
 function FromThis(schema, references, path, value) {
-    const target = (0, index_5.Deref)(schema, references);
+    const target = (0, index_4.Deref)(schema, references);
     const resolved = Visit(target, references, path, value);
     return Default(schema, path, resolved);
 }
 // prettier-ignore
 function FromTuple(schema, references, path, value) {
     const value1 = Default(schema, path, value);
-    return (0, index_7.IsArray)(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value1[index])) : [];
+    return (0, index_6.IsArray)(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value1[index])) : [];
 }
 // prettier-ignore
 function FromUnion(schema, references, path, value) {
     // test value against union variants
     for (const subschema of schema.anyOf) {
-        if (!(0, index_6.Check)(subschema, references, value))
+        if (!(0, index_5.Check)(subschema, references, value))
             continue;
         const value1 = Visit(subschema, references, path, value);
         return Default(schema, path, value1);
@@ -162,7 +162,7 @@ function FromUnion(schema, references, path, value) {
     // test transformed value against union variants
     for (const subschema of schema.anyOf) {
         const value1 = Visit(subschema, references, path, value);
-        if (!(0, index_6.Check)(schema, references, value1))
+        if (!(0, index_5.Check)(schema, references, value1))
             continue;
         return Default(schema, path, value1);
     }

package/build/cjs/value/value/value.js

@@ -50,7 +50,7 @@ function Decode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
     if (!Check(schema, references, value))
         throw new index_1.TransformDecodeCheckError(schema, value, Errors(schema, references, value).First());
-    return (0, index_1.TransformDecode)(schema, references, value);
+    return (0, index_1.HasTransform)(schema, references) ? (0, index_1.TransformDecode)(schema, references, value) : value;
 }
 exports.Decode = Decode;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
@@ -61,7 +61,7 @@ exports.Default = Default;
 /** 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 = (0, index_1.TransformEncode)(schema, references, value);
+    const encoded = (0, index_1.HasTransform)(schema, references) ? (0, index_1.TransformEncode)(schema, references, value) : value;
     if (!Check(schema, references, encoded))
         throw new index_1.TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First());
     return encoded;

package/build/esm/type/keyof/index.d.mts

@@ -1,3 +1,4 @@
 export * from './keyof-from-mapped-result.mjs';
+export * from './keyof-property-entries.mjs';
 export * from './keyof-property-keys.mjs';
 export * from './keyof.mjs';

package/build/esm/type/keyof/index.mjs

@@ -1,3 +1,4 @@
 export * from './keyof-from-mapped-result.mjs';
+export * from './keyof-property-entries.mjs';
 export * from './keyof-property-keys.mjs';
 export * from './keyof.mjs';

package/build/esm/type/keyof/keyof-property-entries.d.mts

@@ -0,0 +1,7 @@
+import { TSchema } from '../schema/index.mjs';
+/**
+ * `[Utility]` Resolves an array of keys and schemas from the given schema. This method is faster
+ * than obtaining the keys and resolving each individually via indexing. This method was written
+ * accellerate Intersect and Union encoding.
+ */
+export declare function KeyOfPropertyEntries(schema: TSchema): [key: string, schema: TSchema][];

package/build/esm/type/keyof/keyof-property-entries.mjs

@@ -0,0 +1,12 @@
+import { IndexFromPropertyKeys } from '../indexed/indexed.mjs';
+import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
+/**
+ * `[Utility]` Resolves an array of keys and schemas from the given schema. This method is faster
+ * than obtaining the keys and resolving each individually via indexing. This method was written
+ * accellerate Intersect and Union encoding.
+ */
+export function KeyOfPropertyEntries(schema) {
+    const keys = KeyOfPropertyKeys(schema);
+    const schemas = IndexFromPropertyKeys(schema, keys);
+    return keys.map((_, index) => [keys[index], schemas[index]]);
+}

package/build/esm/value/transform/decode.mjs

@@ -1,7 +1,6 @@
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
-import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
-import { Index } from '../../type/indexed/index.mjs';
+import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
@@ -64,11 +63,12 @@ function FromArray(schema, references, path, value) {
 function FromIntersect(schema, references, path, value) {
     if (!IsStandardObject(value) || IsValueType(value))
         return Default(schema, path, value);
-    const knownKeys = KeyOfPropertyKeys(schema);
+    const knownEntries = KeyOfPropertyEntries(schema);
+    const knownKeys = knownEntries.map(entry => entry[0]);
     const knownProperties = { ...value };
-    for (const key of knownKeys)
-        if (key in knownProperties) {
-            knownProperties[key] = Visit(Index(schema, [key]), references, `${path}/${key}`, knownProperties[key]);
+    for (const [knownKey, knownSchema] of knownEntries)
+        if (knownKey in knownProperties) {
+            knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
         }
     if (!IsTransform(schema.unevaluatedProperties)) {
         return Default(schema, path, knownProperties);

package/build/esm/value/transform/encode.mjs

@@ -1,7 +1,6 @@
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
-import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
-import { Index } from '../../type/indexed/index.mjs';
+import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
@@ -65,11 +64,12 @@ function FromIntersect(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
     if (!IsStandardObject(value) || IsValueType(value))
         return defaulted;
-    const knownKeys = KeyOfPropertyKeys(schema);
+    const knownEntries = KeyOfPropertyEntries(schema);
+    const knownKeys = knownEntries.map(entry => entry[0]);
     const knownProperties = { ...defaulted };
-    for (const key of knownKeys)
-        if (key in knownProperties) {
-            knownProperties[key] = Visit(Index(schema, [key]), references, `${path}/${key}`, knownProperties[key]);
+    for (const [knownKey, knownSchema] of knownEntries)
+        if (knownKey in knownProperties) {
+            knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
         }
     if (!IsTransform(schema.unevaluatedProperties)) {
         return Default(schema, path, knownProperties);
@@ -90,12 +90,12 @@ function FromNot(schema, references, path, value) {
 // prettier-ignore
 function FromObject(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!IsStandardObject(value))
+    if (!IsStandardObject(defaulted))
         return defaulted;
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = { ...defaulted };
     for (const key of knownKeys)
-        if (key in value) {
+        if (key in knownProperties) {
             knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
         }
     if (!IsSchema(schema.additionalProperties)) {

package/build/esm/value/value/value.mjs

@@ -1,4 +1,4 @@
-import { TransformDecode, TransformEncode, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index.mjs';
+import { HasTransform, TransformDecode, TransformEncode, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index.mjs';
 import { Mutate as MutateValue } from '../mutate/index.mjs';
 import { Hash as HashValue } from '../hash/index.mjs';
 import { Equal as EqualValue } from '../equal/index.mjs';
@@ -40,7 +40,7 @@ export function Decode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
     if (!Check(schema, references, value))
         throw new TransformDecodeCheckError(schema, value, Errors(schema, references, value).First());
-    return TransformDecode(schema, references, value);
+    return HasTransform(schema, references) ? TransformDecode(schema, references, value) : value;
 }
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export function Default(...args) {
@@ -49,7 +49,7 @@ export function Default(...args) {
 /** Encodes a value or throws if error */
 export function Encode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
-    const encoded = TransformEncode(schema, references, value);
+    const encoded = HasTransform(schema, references) ? TransformEncode(schema, references, value) : value;
     if (!Check(schema, references, encoded))
         throw new TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First());
     return encoded;

package/package.json

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