@sinclair/typebox 0.33.4 → 0.33.6

package/build/cjs/system/policy.d.ts

@@ -16,14 +16,14 @@ export declare namespace TypeSystemPolicy {
     let AllowNaN: boolean;
     /** Sets whether `null` should validate for void types. The default is `false` */
     let AllowNullVoid: boolean;
-    /** Asserts this value using the ExactOptionalPropertyTypes policy */
+    /** Checks this value using the ExactOptionalPropertyTypes policy */
     function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string): boolean;
-    /** Asserts this value using the AllowArrayObjects policy */
+    /** Checks this value using the AllowArrayObjects policy */
     function IsObjectLike(value: unknown): value is Record<keyof any, unknown>;
-    /** Asserts this value as a record using the AllowArrayObjects policy */
+    /** Checks this value as a record using the AllowArrayObjects policy */
     function IsRecordLike(value: unknown): value is Record<keyof any, unknown>;
-    /** Asserts this value using the AllowNaN policy */
+    /** Checks this value using the AllowNaN policy */
     function IsNumberLike(value: unknown): value is number;
-    /** Asserts this value using the AllowVoidNull policy */
+    /** Checks this value using the AllowVoidNull policy */
     function IsVoidLike(value: unknown): value is void;
 }

package/build/cjs/system/policy.js

@@ -28,28 +28,28 @@ var TypeSystemPolicy;
     TypeSystemPolicy.AllowNaN = false;
     /** Sets whether `null` should validate for void types. The default is `false` */
     TypeSystemPolicy.AllowNullVoid = false;
-    /** Asserts this value using the ExactOptionalPropertyTypes policy */
+    /** Checks this value using the ExactOptionalPropertyTypes policy */
     function IsExactOptionalProperty(value, key) {
         return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
     }
     TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
-    /** Asserts this value using the AllowArrayObjects policy */
+    /** Checks this value using the AllowArrayObjects policy */
     function IsObjectLike(value) {
         const isObject = (0, index_1.IsObject)(value);
         return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !(0, index_1.IsArray)(value);
     }
     TypeSystemPolicy.IsObjectLike = IsObjectLike;
-    /** Asserts this value as a record using the AllowArrayObjects policy */
+    /** Checks this value as a record using the AllowArrayObjects policy */
     function IsRecordLike(value) {
         return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
     }
     TypeSystemPolicy.IsRecordLike = IsRecordLike;
-    /** Asserts this value using the AllowNaN policy */
+    /** Checks this value using the AllowNaN policy */
     function IsNumberLike(value) {
         return TypeSystemPolicy.AllowNaN ? (0, index_1.IsNumber)(value) : Number.isFinite(value);
     }
     TypeSystemPolicy.IsNumberLike = IsNumberLike;
-    /** Asserts this value using the AllowVoidNull policy */
+    /** Checks this value using the AllowVoidNull policy */
     function IsVoidLike(value) {
         const isUndefined = (0, index_1.IsUndefined)(value);
         return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;

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

@@ -145,8 +145,10 @@ function FromNumber(schema, references, value) {
 function FromObject(schema, references, value) {
     if (!(0, index_5.IsObject)(value))
         return value;
-    for (const key of Object.getOwnPropertyNames(schema.properties)) {
-        value[key] = Visit(schema.properties[key], references, value[key]);
+    for (const propertyKey of Object.getOwnPropertyNames(schema.properties)) {
+        if (!(0, index_5.HasPropertyKey)(value, propertyKey))
+            continue;
+        value[propertyKey] = Visit(schema.properties[propertyKey], references, value[propertyKey]);
     }
     return value;
 }

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

@@ -49,22 +49,25 @@ function FromObject(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     if (!(0, index_5.IsObject)(defaulted))
         return defaulted;
-    const additionalPropertiesSchema = schema.additionalProperties;
     const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties);
     // properties
     for (const key of knownPropertyKeys) {
-        if (!HasDefaultProperty(schema.properties[key]))
+        // note: we need to traverse into the object and test if the return value
+        // yielded a non undefined result. Here we interpret an undefined result as
+        // a non assignable property and continue.
+        const propertyValue = Visit(schema.properties[key], references, defaulted[key]);
+        if ((0, index_5.IsUndefined)(propertyValue))
             continue;
-        defaulted[key] = Visit(schema.properties[key], references, defaulted[key]);
+        defaulted[key] = propertyValue;
     }
     // return if not additional properties
-    if (!HasDefaultProperty(additionalPropertiesSchema))
+    if (!HasDefaultProperty(schema.additionalProperties))
         return defaulted;
     // additional properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
         if (knownPropertyKeys.includes(key))
             continue;
-        defaulted[key] = Visit(additionalPropertiesSchema, references, defaulted[key]);
+        defaulted[key] = Visit(schema.additionalProperties, references, defaulted[key]);
     }
     return defaulted;
 }

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

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformDecodeError = exports.TransformDecodeCheckError = void 0;
 exports.TransformDecode = TransformDecode;
+const policy_1 = require("../../system/policy");
 const index_1 = require("../../type/symbols/index");
 const index_2 = require("../../type/error/index");
 const index_3 = require("../../type/keyof/index");
@@ -91,10 +92,18 @@ function FromObject(schema, references, path, value) {
         return Default(schema, path, value);
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = { ...value };
-    for (const key of knownKeys)
-        if (key in knownProperties) {
-            knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
-        }
+    for (const key of knownKeys) {
+        if (!(0, index_6.HasPropertyKey)(knownProperties, key))
+            continue;
+        // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+        // property policy, then we need to continue. This is a special case for optional property handling 
+        // where a transforms wrapped in a optional modifiers should not run.
+        if ((0, index_6.IsUndefined)(knownProperties[key]) && (!(0, type_1.IsUndefined)(schema.properties[key]) ||
+            policy_1.TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+            continue;
+        // decode property
+        knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+    }
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
         return Default(schema, path, knownProperties);
     }

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

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformEncodeError = exports.TransformEncodeCheckError = void 0;
 exports.TransformEncode = TransformEncode;
+const policy_1 = require("../../system/policy");
 const index_1 = require("../../type/symbols/index");
 const index_2 = require("../../type/error/index");
 const index_3 = require("../../type/keyof/index");
@@ -94,10 +95,18 @@ function FromObject(schema, references, path, value) {
         return defaulted;
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = { ...defaulted };
-    for (const key of knownKeys)
-        if (key in knownProperties) {
-            knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
-        }
+    for (const key of knownKeys) {
+        if (!(0, index_6.HasPropertyKey)(knownProperties, key))
+            continue;
+        // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+        // property policy, then we need to continue. This is a special case for optional property handling 
+        // where a transforms wrapped in a optional modifiers should not run.
+        if ((0, index_6.IsUndefined)(knownProperties[key]) && (!(0, type_1.IsUndefined)(schema.properties[key]) ||
+            policy_1.TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+            continue;
+        // encode property
+        knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+    }
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
         return knownProperties;
     }

package/build/esm/system/policy.d.mts

@@ -16,14 +16,14 @@ export declare namespace TypeSystemPolicy {
     let AllowNaN: boolean;
     /** Sets whether `null` should validate for void types. The default is `false` */
     let AllowNullVoid: boolean;
-    /** Asserts this value using the ExactOptionalPropertyTypes policy */
+    /** Checks this value using the ExactOptionalPropertyTypes policy */
     function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string): boolean;
-    /** Asserts this value using the AllowArrayObjects policy */
+    /** Checks this value using the AllowArrayObjects policy */
     function IsObjectLike(value: unknown): value is Record<keyof any, unknown>;
-    /** Asserts this value as a record using the AllowArrayObjects policy */
+    /** Checks this value as a record using the AllowArrayObjects policy */
     function IsRecordLike(value: unknown): value is Record<keyof any, unknown>;
-    /** Asserts this value using the AllowNaN policy */
+    /** Checks this value using the AllowNaN policy */
     function IsNumberLike(value: unknown): value is number;
-    /** Asserts this value using the AllowVoidNull policy */
+    /** Checks this value using the AllowVoidNull policy */
     function IsVoidLike(value: unknown): value is void;
 }

package/build/esm/system/policy.mjs

@@ -24,28 +24,28 @@ export var TypeSystemPolicy;
     TypeSystemPolicy.AllowNaN = false;
     /** Sets whether `null` should validate for void types. The default is `false` */
     TypeSystemPolicy.AllowNullVoid = false;
-    /** Asserts this value using the ExactOptionalPropertyTypes policy */
+    /** Checks this value using the ExactOptionalPropertyTypes policy */
     function IsExactOptionalProperty(value, key) {
         return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
     }
     TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
-    /** Asserts this value using the AllowArrayObjects policy */
+    /** Checks this value using the AllowArrayObjects policy */
     function IsObjectLike(value) {
         const isObject = IsObject(value);
         return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !IsArray(value);
     }
     TypeSystemPolicy.IsObjectLike = IsObjectLike;
-    /** Asserts this value as a record using the AllowArrayObjects policy */
+    /** Checks this value as a record using the AllowArrayObjects policy */
     function IsRecordLike(value) {
         return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
     }
     TypeSystemPolicy.IsRecordLike = IsRecordLike;
-    /** Asserts this value using the AllowNaN policy */
+    /** Checks this value using the AllowNaN policy */
     function IsNumberLike(value) {
         return TypeSystemPolicy.AllowNaN ? IsNumber(value) : Number.isFinite(value);
     }
     TypeSystemPolicy.IsNumberLike = IsNumberLike;
-    /** Asserts this value using the AllowVoidNull policy */
+    /** Checks this value using the AllowVoidNull policy */
     function IsVoidLike(value) {
         const isUndefined = IsUndefined(value);
         return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;

package/build/esm/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
 // ------------------------------------------------------------------
@@ -141,8 +141,10 @@ function FromNumber(schema, references, value) {
 function FromObject(schema, references, value) {
     if (!IsObject(value))
         return value;
-    for (const key of Object.getOwnPropertyNames(schema.properties)) {
-        value[key] = Visit(schema.properties[key], references, value[key]);
+    for (const propertyKey of Object.getOwnPropertyNames(schema.properties)) {
+        if (!HasPropertyKey(value, propertyKey))
+            continue;
+        value[propertyKey] = Visit(schema.properties[propertyKey], references, value[propertyKey]);
     }
     return value;
 }

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

@@ -45,22 +45,25 @@ function FromObject(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     if (!IsObject(defaulted))
         return defaulted;
-    const additionalPropertiesSchema = schema.additionalProperties;
     const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties);
     // properties
     for (const key of knownPropertyKeys) {
-        if (!HasDefaultProperty(schema.properties[key]))
+        // note: we need to traverse into the object and test if the return value
+        // yielded a non undefined result. Here we interpret an undefined result as
+        // a non assignable property and continue.
+        const propertyValue = Visit(schema.properties[key], references, defaulted[key]);
+        if (IsUndefined(propertyValue))
             continue;
-        defaulted[key] = Visit(schema.properties[key], references, defaulted[key]);
+        defaulted[key] = propertyValue;
     }
     // return if not additional properties
-    if (!HasDefaultProperty(additionalPropertiesSchema))
+    if (!HasDefaultProperty(schema.additionalProperties))
         return defaulted;
     // additional properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
         if (knownPropertyKeys.includes(key))
             continue;
-        defaulted[key] = Visit(additionalPropertiesSchema, references, defaulted[key]);
+        defaulted[key] = Visit(schema.additionalProperties, references, defaulted[key]);
     }
     return defaulted;
 }

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

@@ -1,3 +1,4 @@
+import { TypeSystemPolicy } from '../../system/policy.mjs';
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index.mjs';
@@ -6,11 +7,11 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { HasPropertyKey, IsObject, IsArray, IsValueType, IsUndefined as IsUndefinedValue } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
+import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/type.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -84,10 +85,18 @@ function FromObject(schema, references, path, value) {
         return Default(schema, path, value);
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = { ...value };
-    for (const key of knownKeys)
-        if (key in knownProperties) {
-            knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
-        }
+    for (const key of knownKeys) {
+        if (!HasPropertyKey(knownProperties, key))
+            continue;
+        // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+        // property policy, then we need to continue. This is a special case for optional property handling 
+        // where a transforms wrapped in a optional modifiers should not run.
+        if (IsUndefinedValue(knownProperties[key]) && (!IsUndefined(schema.properties[key]) ||
+            TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+            continue;
+        // decode property
+        knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+    }
     if (!IsSchema(schema.additionalProperties)) {
         return Default(schema, path, knownProperties);
     }

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

@@ -1,3 +1,4 @@
+import { TypeSystemPolicy } from '../../system/policy.mjs';
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index.mjs';
@@ -6,11 +7,11 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { HasPropertyKey, IsObject, IsArray, IsValueType, IsUndefined as IsUndefinedValue } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
+import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/type.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -87,10 +88,18 @@ function FromObject(schema, references, path, value) {
         return defaulted;
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = { ...defaulted };
-    for (const key of knownKeys)
-        if (key in knownProperties) {
-            knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
-        }
+    for (const key of knownKeys) {
+        if (!HasPropertyKey(knownProperties, key))
+            continue;
+        // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+        // property policy, then we need to continue. This is a special case for optional property handling 
+        // where a transforms wrapped in a optional modifiers should not run.
+        if (IsUndefinedValue(knownProperties[key]) && (!IsUndefined(schema.properties[key]) ||
+            TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+            continue;
+        // encode property
+        knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+    }
     if (!IsSchema(schema.additionalProperties)) {
         return knownProperties;
     }

package/package.json

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

package/readme.md

@@ -1676,6 +1676,7 @@ The following is a list of community packages that offer general tooling, extend
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
 | [h3-typebox](https://github.com/kevinmarrec/h3-typebox) | Schema validation utilities for h3 using TypeBox & Ajv |
 | [http-wizard](https://github.com/flodlc/http-wizard) | Type safe http client library for Fastify |
+| [nominal-typebox](https://github.com/Coder-Spirit/nominal/tree/main/%40coderspirit/nominal-typebox) | Allows devs to integrate nominal types into TypeBox schemas |
 | [openapi-box](https://github.com/geut/openapi-box) | Generate TypeBox types from OpenApi IDL + Http client library |
 | [prismabox](https://github.com/m1212e/prismabox) | Converts a prisma.schema to typebox schema matching the database models |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from Json Schemas |