@sinclair/typebox 0.31.27 → 0.31.28

package/package.json

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

package/readme.md

@@ -1719,11 +1719,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '148.9 kb' │ ' 65.8 kb' │  '2.26 x'   │
-│ typebox/errors       │ '111.5 kb' │ ' 49.1 kb' │  '2.27 x'   │
-│ typebox/system       │ ' 82.6 kb' │ ' 36.8 kb' │  '2.24 x'   │
-│ typebox/value        │ '190.5 kb' │ ' 82.4 kb' │  '2.31 x'   │
-│ typebox              │ ' 72.4 kb' │ ' 31.6 kb' │  '2.29 x'   │
+│ typebox/compiler     │ '163.6 kb' │ ' 71.6 kb' │  '2.28 x'   │
+│ typebox/errors       │ '113.3 kb' │ ' 50.1 kb' │  '2.26 x'   │
+│ typebox/system       │ ' 83.9 kb' │ ' 37.5 kb' │  '2.24 x'   │
+│ typebox/value        │ '191.1 kb' │ ' 82.3 kb' │  '2.32 x'   │
+│ typebox              │ ' 73.8 kb' │ ' 32.3 kb' │  '2.29 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/value/transform.d.ts

@@ -1,10 +1,5 @@
 import { ValueError } from '../errors/errors';
 import * as Types from '../typebox';
-export type CheckFunction = (schema: Types.TSchema, references: Types.TSchema[], value: unknown) => boolean;
-export declare class TransformUnknownTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TRef | Types.TThis;
-    constructor(schema: Types.TRef | Types.TThis);
-}
 export declare class TransformDecodeCheckError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     readonly value: unknown;

package/value/transform.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EncodeTransform = exports.DecodeTransform = exports.HasTransform = exports.TransformEncodeError = exports.TransformDecodeError = exports.TransformEncodeCheckError = exports.TransformDecodeCheckError = exports.TransformUnknownTypeError = void 0;
+exports.EncodeTransform = exports.DecodeTransform = exports.HasTransform = exports.TransformEncodeError = exports.TransformDecodeError = exports.TransformEncodeCheckError = exports.TransformDecodeCheckError = void 0;
 const guard_1 = require("./guard");
 const deref_1 = require("./deref");
 const check_1 = require("./check");
@@ -35,13 +35,6 @@ const Types = require("../typebox");
 // -------------------------------------------------------------------------
 // Errors
 // -------------------------------------------------------------------------
-class TransformUnknownTypeError extends Types.TypeBoxError {
-    constructor(schema) {
-        super(`Unknown type`);
-        this.schema = schema;
-    }
-}
-exports.TransformUnknownTypeError = TransformUnknownTypeError;
 class TransformDecodeCheckError extends Types.TypeBoxError {
     constructor(schema, value, error) {
         super(`Unable to decode due to invalid value`);
@@ -76,9 +69,9 @@ class TransformEncodeError extends Types.TypeBoxError {
     }
 }
 exports.TransformEncodeError = TransformEncodeError;
-// -------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // HasTransform
-// -------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Recursively checks a schema for transform codecs */
 var HasTransform;
 (function (HasTransform) {
@@ -139,9 +132,6 @@ var HasTransform;
         if (schema.$id)
             visited.add(schema.$id);
         switch (schema[Types.Kind]) {
-            // ------------------------------------------------------
-            // Structural
-            // ------------------------------------------------------
             case 'Array':
                 return TArray(schema_, references_);
             case 'AsyncIterator':
@@ -170,29 +160,7 @@ var HasTransform;
                 return TTuple(schema_, references_);
             case 'Union':
                 return TUnion(schema_, references_);
-            // ------------------------------------------------------
-            // Default
-            // ------------------------------------------------------
-            case 'Any':
-            case 'BigInt':
-            case 'Boolean':
-            case 'Date':
-            case 'Integer':
-            case 'Literal':
-            case 'Never':
-            case 'Null':
-            case 'Number':
-            case 'String':
-            case 'Symbol':
-            case 'TemplateLiteral':
-            case 'Undefined':
-            case 'Uint8Array':
-            case 'Unknown':
-            case 'Void':
-                return Types.TypeGuard.TTransform(schema);
             default:
-                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
-                    throw new TransformUnknownTypeError(schema_);
                 return Types.TypeGuard.TTransform(schema);
         }
     }
@@ -204,9 +172,9 @@ var HasTransform;
     }
     HasTransform.Has = Has;
 })(HasTransform || (exports.HasTransform = HasTransform = {}));
-// -------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // DecodeTransform
-// -------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Decodes a value using transform decoders if available. Does not ensure correct results. */
 var DecodeTransform;
 (function (DecodeTransform) {
@@ -218,89 +186,109 @@ var DecodeTransform;
             throw new TransformDecodeError(schema, value, error);
         }
     }
+    // prettier-ignore
     function TArray(schema, references, value) {
-        const elements1 = value.map((value) => Visit(schema.items, references, value));
-        return Default(schema, elements1);
+        return ((0, guard_1.IsArray)(value))
+            ? Default(schema, value.map((value) => Visit(schema.items, references, value)))
+            : Default(schema, value);
     }
+    // prettier-ignore
     function TIntersect(schema, references, value) {
         if (!(0, guard_1.IsPlainObject)(value) || (0, guard_1.IsValueType)(value))
             return Default(schema, value);
-        const keys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false });
-        const properties1 = Object.entries(value).reduce((acc, [key, value]) => {
-            return !keys.includes(key) ? { ...acc, [key]: value } : { ...acc, [key]: Default(Types.IndexedAccessor.Resolve(schema, [key]), value) };
-        }, {});
-        if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties))
-            return Default(schema, properties1);
-        const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
-            return keys.includes(key) ? { ...acc, [key]: value } : { ...acc, [key]: Default(schema.unevaluatedProperties, value) };
-        }, {});
-        return Default(schema, properties2);
+        const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false });
+        const knownProperties = knownKeys.reduce((value, key) => {
+            return (key in value)
+                ? { ...value, [key]: Visit(Types.IndexedAccessor.Resolve(schema, [key]), references, value[key]) }
+                : value;
+        }, value);
+        if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties)) {
+            return Default(schema, knownProperties);
+        }
+        const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+        const unevaluatedProperties = schema.unevaluatedProperties;
+        const unknownProperties = unknownKeys.reduce((value, key) => {
+            return !knownKeys.includes(key)
+                ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
+                : value;
+        }, knownProperties);
+        return Default(schema, unknownProperties);
     }
     function TNot(schema, references, value) {
-        const value1 = Visit(schema.not, references, value);
-        return Default(schema, value1);
+        return Default(schema, Visit(schema.not, references, value));
     }
+    // prettier-ignore
     function TObject(schema, references, value) {
         if (!(0, guard_1.IsPlainObject)(value))
             return Default(schema, value);
-        const properties1 = Object.entries(value).reduce((acc, [key, value]) => {
-            return !(key in schema.properties) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(schema.properties[key], references, value) };
-        }, {});
-        if (!Types.TypeGuard.TSchema(schema.additionalProperties))
-            return Default(schema, properties1);
+        const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false });
+        const knownProperties = knownKeys.reduce((value, key) => {
+            return (key in value)
+                ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
+                : value;
+        }, value);
+        if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
+            return Default(schema, knownProperties);
+        }
+        const unknownKeys = Object.getOwnPropertyNames(knownProperties);
         const additionalProperties = schema.additionalProperties;
-        const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
-            return key in schema.properties ? { ...acc, [key]: value } : { ...acc, [key]: Visit(additionalProperties, references, value) };
-        }, {});
-        return Default(schema, properties2);
-    }
+        const unknownProperties = unknownKeys.reduce((value, key) => {
+            return !knownKeys.includes(key)
+                ? { ...value, [key]: Default(additionalProperties, value[key]) }
+                : value;
+        }, knownProperties);
+        return Default(schema, unknownProperties);
+    }
+    // prettier-ignore
     function TRecord(schema, references, value) {
         if (!(0, guard_1.IsPlainObject)(value))
             return Default(schema, value);
         const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
-        const property = schema.patternProperties[pattern];
-        const regex = new RegExp(pattern);
-        const properties1 = Object.entries(value).reduce((acc, [key, value]) => {
-            return !regex.test(key) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(property, references, value) };
-        }, {});
-        if (!Types.TypeGuard.TSchema(schema.additionalProperties))
-            return Default(schema, properties1);
+        const knownKeys = new RegExp(pattern);
+        const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
+            return knownKeys.test(key)
+                ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+                : value;
+        }, value);
+        if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
+            return Default(schema, knownProperties);
+        }
+        const unknownKeys = Object.getOwnPropertyNames(knownProperties);
         const additionalProperties = schema.additionalProperties;
-        const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
-            return regex.test(key) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(additionalProperties, references, value) };
-        }, {});
-        return Default(schema, properties2);
+        const unknownProperties = unknownKeys.reduce((value, key) => {
+            return !knownKeys.test(key)
+                ? { ...value, [key]: Default(additionalProperties, value[key]) }
+                : value;
+        }, knownProperties);
+        return Default(schema, unknownProperties);
     }
     function TRef(schema, references, value) {
         const target = (0, deref_1.Deref)(schema, references);
-        const resolved = Visit(target, references, value);
-        return Default(schema, resolved);
+        return Default(schema, Visit(target, references, value));
     }
     function TThis(schema, references, value) {
         const target = (0, deref_1.Deref)(schema, references);
-        const resolved = Visit(target, references, value);
-        return Default(schema, resolved);
+        return Default(schema, Visit(target, references, value));
     }
+    // prettier-ignore
     function TTuple(schema, references, value) {
-        const value1 = (0, guard_1.IsArray)(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value[index])) : [];
-        return Default(schema, value1);
+        return ((0, guard_1.IsArray)(value) && (0, guard_1.IsArray)(schema.items))
+            ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
+            : Default(schema, value);
     }
     function TUnion(schema, references, value) {
-        const value1 = Default(schema, value);
+        const defaulted = Default(schema, value);
         for (const subschema of schema.anyOf) {
-            if (!(0, check_1.Check)(subschema, references, value1))
+            if (!(0, check_1.Check)(subschema, references, defaulted))
                 continue;
-            return Visit(subschema, references, value1);
+            return Visit(subschema, references, defaulted);
         }
-        return value1;
+        return defaulted;
     }
     function Visit(schema, references, value) {
         const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
         const schema_ = schema;
         switch (schema[Types.Kind]) {
-            // ------------------------------------------------------
-            // Structural
-            // ------------------------------------------------------
             case 'Array':
                 return TArray(schema_, references_, value);
             case 'Intersect':
@@ -321,33 +309,7 @@ var DecodeTransform;
                 return TTuple(schema_, references_, value);
             case 'Union':
                 return TUnion(schema_, references_, value);
-            // ------------------------------------------------------
-            // Default
-            // ------------------------------------------------------
-            case 'Any':
-            case 'AsyncIterator':
-            case 'BigInt':
-            case 'Boolean':
-            case 'Constructor':
-            case 'Date':
-            case 'Function':
-            case 'Integer':
-            case 'Iterator':
-            case 'Literal':
-            case 'Never':
-            case 'Null':
-            case 'Number':
-            case 'Promise':
-            case 'String':
-            case 'TemplateLiteral':
-            case 'Undefined':
-            case 'Uint8Array':
-            case 'Unknown':
-            case 'Void':
-                return Default(schema_, value);
             default:
-                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
-                    throw new TransformUnknownTypeError(schema_);
                 return Default(schema_, value);
         }
     }
@@ -356,9 +318,9 @@ var DecodeTransform;
     }
     DecodeTransform.Decode = Decode;
 })(DecodeTransform || (exports.DecodeTransform = DecodeTransform = {}));
-// -------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // DecodeTransform
-// -------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Encodes a value using transform encoders if available. Does not ensure correct results. */
 var EncodeTransform;
 (function (EncodeTransform) {
@@ -370,58 +332,82 @@ var EncodeTransform;
             throw new TransformEncodeError(schema, value, error);
         }
     }
+    // prettier-ignore
     function TArray(schema, references, value) {
-        const elements1 = Default(schema, value);
-        return elements1.map((value) => Visit(schema.items, references, value));
+        const defaulted = Default(schema, value);
+        return (0, guard_1.IsArray)(defaulted)
+            ? defaulted.map((value) => Visit(schema.items, references, value))
+            : defaulted;
     }
+    // prettier-ignore
     function TIntersect(schema, references, value) {
-        const properties1 = Default(schema, value);
+        const defaulted = Default(schema, value);
         if (!(0, guard_1.IsPlainObject)(value) || (0, guard_1.IsValueType)(value))
-            return properties1;
-        const keys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false });
-        const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
-            return !keys.includes(key) ? { ...acc, [key]: value } : { ...acc, [key]: Default(Types.IndexedAccessor.Resolve(schema, [key]), value) };
-        }, {});
-        if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties))
-            return Default(schema, properties2);
-        return Object.entries(properties2).reduce((acc, [key, value]) => {
-            return keys.includes(key) ? { ...acc, [key]: value } : { ...acc, [key]: Default(schema.unevaluatedProperties, value) };
-        }, {});
+            return defaulted;
+        const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false });
+        const knownProperties = knownKeys.reduce((value, key) => {
+            return key in defaulted
+                ? { ...value, [key]: Visit(Types.IndexedAccessor.Resolve(schema, [key]), references, value[key]) }
+                : value;
+        }, defaulted);
+        if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties)) {
+            return Default(schema, knownProperties);
+        }
+        const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+        const unevaluatedProperties = schema.unevaluatedProperties;
+        return unknownKeys.reduce((value, key) => {
+            return !knownKeys.includes(key)
+                ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
+                : value;
+        }, knownProperties);
     }
     function TNot(schema, references, value) {
-        const value1 = Default(schema, value);
-        return Default(schema.not, value1);
+        return Default(schema.not, Default(schema, value));
     }
+    // prettier-ignore
     function TObject(schema, references, value) {
-        const properties1 = Default(schema, value);
+        const defaulted = Default(schema, value);
         if (!(0, guard_1.IsPlainObject)(value))
-            return properties1;
-        const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
-            return !(key in schema.properties) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(schema.properties[key], references, value) };
-        }, {});
-        if (!Types.TypeGuard.TSchema(schema.additionalProperties))
-            return properties2;
+            return defaulted;
+        const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false });
+        const knownProperties = knownKeys.reduce((value, key) => {
+            return key in value
+                ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
+                : value;
+        }, defaulted);
+        if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
+            return knownProperties;
+        }
+        const unknownKeys = Object.getOwnPropertyNames(knownProperties);
         const additionalProperties = schema.additionalProperties;
-        return Object.entries(properties2).reduce((acc, [key, value]) => {
-            return key in schema.properties ? { ...acc, [key]: value } : { ...acc, [key]: Visit(additionalProperties, references, value) };
-        }, {});
+        return unknownKeys.reduce((value, key) => {
+            return !knownKeys.includes(key)
+                ? { ...value, [key]: Default(additionalProperties, value[key]) }
+                : value;
+        }, knownProperties);
     }
+    // prettier-ignore
     function TRecord(schema, references, value) {
-        const properties1 = Default(schema, value);
+        const defaulted = Default(schema, value);
         if (!(0, guard_1.IsPlainObject)(value))
-            return properties1;
+            return defaulted;
         const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
-        const property = schema.patternProperties[pattern];
-        const regex = new RegExp(pattern);
-        const properties2 = Object.entries(properties1).reduce((acc, [key, value]) => {
-            return !regex.test(key) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(property, references, value) };
-        }, {});
-        if (!Types.TypeGuard.TSchema(schema.additionalProperties))
-            return Default(schema, properties2);
+        const knownKeys = new RegExp(pattern);
+        const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
+            return knownKeys.test(key)
+                ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+                : value;
+        }, defaulted);
+        if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
+            return Default(schema, knownProperties);
+        }
+        const unknownKeys = Object.getOwnPropertyNames(knownProperties);
         const additionalProperties = schema.additionalProperties;
-        return Object.entries(properties2).reduce((acc, [key, value]) => {
-            return regex.test(key) ? { ...acc, [key]: value } : { ...acc, [key]: Visit(additionalProperties, references, value) };
-        }, {});
+        return unknownKeys.reduce((value, key) => {
+            return !knownKeys.test(key)
+                ? { ...value, [key]: Default(additionalProperties, value[key]) }
+                : value;
+        }, knownProperties);
     }
     function TRef(schema, references, value) {
         const target = (0, deref_1.Deref)(schema, references);
@@ -458,9 +444,6 @@ var EncodeTransform;
         const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
         const schema_ = schema;
         switch (schema[Types.Kind]) {
-            // ------------------------------------------------------
-            // Structural
-            // ------------------------------------------------------
             case 'Array':
                 return TArray(schema_, references_, value);
             case 'Intersect':
@@ -479,34 +462,7 @@ var EncodeTransform;
                 return TTuple(schema_, references_, value);
             case 'Union':
                 return TUnion(schema_, references_, value);
-            // ------------------------------------------------------
-            // Apply
-            // ------------------------------------------------------
-            case 'Any':
-            case 'AsyncIterator':
-            case 'BigInt':
-            case 'Boolean':
-            case 'Constructor':
-            case 'Date':
-            case 'Function':
-            case 'Integer':
-            case 'Iterator':
-            case 'Literal':
-            case 'Never':
-            case 'Null':
-            case 'Number':
-            case 'Promise':
-            case 'String':
-            case 'Symbol':
-            case 'TemplateLiteral':
-            case 'Undefined':
-            case 'Uint8Array':
-            case 'Unknown':
-            case 'Void':
-                return Default(schema_, value);
             default:
-                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
-                    throw new TransformUnknownTypeError(schema_);
                 return Default(schema_, value);
         }
     }