@sinclair/typebox 0.26.2 → 0.26.3

package/compiler/compiler.js

@@ -165,10 +165,10 @@ var TypeCompiler;
         return typeof value === 'string';
     }
     // -------------------------------------------------------------------
-    // Overrides
+    // Polices
     // -------------------------------------------------------------------
-    function IsNumberCheck(value) {
-        return !index_2.TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
+    function IsExactOptionalProperty(value, key, expression) {
+        return index_2.TypeSystem.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${value}.${key} !== undefined ? ${expression} : true)`;
     }
     function IsObjectCheck(value) {
         return !index_2.TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
@@ -178,6 +178,9 @@ var TypeCompiler;
             ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
             : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`;
     }
+    function IsNumberCheck(value) {
+        return !index_2.TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
+    }
     function IsVoidCheck(value) {
         return index_2.TypeSystem.AllowVoidNull ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
     }
@@ -302,32 +305,32 @@ var TypeCompiler;
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
         if (IsNumber(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
-        const schemaKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
-        for (const schemaKey of schemaKeys) {
-            const memberExpression = MemberExpression.Encode(value, schemaKey);
-            const property = schema.properties[schemaKey];
-            if (schema.required && schema.required.includes(schemaKey)) {
+        const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
+        for (const knownKey of knownKeys) {
+            const memberExpression = MemberExpression.Encode(value, knownKey);
+            const property = schema.properties[knownKey];
+            if (schema.required && schema.required.includes(knownKey)) {
                 yield* Visit(property, references, memberExpression);
                 if (Types.ExtendsUndefined.Check(property))
-                    yield `('${schemaKey}' in ${value})`;
+                    yield `('${knownKey}' in ${value})`;
             }
             else {
                 const expression = CreateExpression(property, references, memberExpression);
-                yield `('${schemaKey}' in ${value} ? ${expression} : true)`;
+                yield IsExactOptionalProperty(value, knownKey, expression);
             }
         }
         if (schema.additionalProperties === false) {
-            if (schema.required && schema.required.length === schemaKeys.length) {
-                yield `Object.getOwnPropertyNames(${value}).length === ${schemaKeys.length}`;
+            if (schema.required && schema.required.length === knownKeys.length) {
+                yield `Object.getOwnPropertyNames(${value}).length === ${knownKeys.length}`;
             }
             else {
-                const keys = `[${schemaKeys.map((key) => `'${key}'`).join(', ')}]`;
+                const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
                 yield `Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key))`;
             }
         }
         if (typeof schema.additionalProperties === 'object') {
             const expression = CreateExpression(schema.additionalProperties, references, 'value[key]');
-            const keys = `[${schemaKeys.map((key) => `'${key}'`).join(', ')}]`;
+            const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
             yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
         }
     }

package/errors/errors.js

@@ -136,6 +136,24 @@ var ValueErrors;
     // ----------------------------------------------------------------------
     // Guards
     // ----------------------------------------------------------------------
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    function IsInteger(value) {
+        return globalThis.Number.isInteger(value);
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsDefined(value) {
+        return value !== undefined;
+    }
+    // ----------------------------------------------------------------------
+    // Policies
+    // ----------------------------------------------------------------------
+    function IsExactOptionalProperty(value, key) {
+        return index_1.TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
+    }
     function IsObject(value) {
         const result = typeof value === 'object' && value !== null;
         return index_1.TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value);
@@ -143,26 +161,14 @@ var ValueErrors;
     function IsRecordObject(value) {
         return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array);
     }
-    function IsBigInt(value) {
-        return typeof value === 'bigint';
-    }
     function IsNumber(value) {
         const result = typeof value === 'number';
         return index_1.TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value);
     }
-    function IsInteger(value) {
-        return globalThis.Number.isInteger(value);
-    }
-    function IsString(value) {
-        return typeof value === 'string';
-    }
     function IsVoid(value) {
         const result = value === undefined;
         return index_1.TypeSystem.AllowVoidNull ? result || value === null : result;
     }
-    function IsDefined(value) {
-        return value !== undefined;
-    }
     // ----------------------------------------------------------------------
     // Types
     // ----------------------------------------------------------------------
@@ -361,7 +367,7 @@ var ValueErrors;
                 }
             }
             else {
-                if (knownKey in value) {
+                if (IsExactOptionalProperty(value, knownKey)) {
                     yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey]);
                 }
             }

package/package.json

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

package/readme.md

@@ -325,15 +325,15 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Composite([     │ type T = {                  │ const T = {                    │
+│ const T = Type.Composite([     │ type I = {                  │ const T = {                    │
 │   Type.Object({                │   x: number                 │   type: 'object',              │
-│     x: Type.Number()           │   y: number                 │   required: ['x', 'y'],        │
-│   }),                          │ }                           │   properties: {                │
-│   Type.Object({                │                             │     x: {                       │
+│     x: Type.Number()           │ } & {                       │   required: ['x', 'y'],        │
+│   }),                          │   y: number                 │   properties: {                │
+│   Type.Object({                │ }                           │     x: {                       │
 │     y: Type.Number()           │                             │       type: 'number'           │
-│   })                           │                             │     },                         │
-│ ])                             │                             │     y: {                       │
-│                                │                             │       type: 'number'           │
+│   })                           │ type T = {                  │     },                         │
+│ ])                             │   [K in keyof I]: I[K]      │     y: {                       │
+│                                │ }                           │       type: 'number'           │
 │                                │                             │     }                          │
 │                                │                             │   }                            │
 │                                │                             │ }                              │

package/system/system.d.ts

@@ -7,6 +7,8 @@ export declare class TypeSystemDuplicateFormat extends Error {
 }
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 export declare namespace TypeSystem {
+    /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+    let ExactOptionalPropertyTypes: boolean;
     /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
     let AllowArrayObjects: boolean;
     /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */

package/system/system.js

@@ -44,12 +44,20 @@ exports.TypeSystemDuplicateFormat = TypeSystemDuplicateFormat;
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 var TypeSystem;
 (function (TypeSystem) {
+    // ------------------------------------------------------------------------
+    // Assertion Policies
+    // ------------------------------------------------------------------------
+    /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+    TypeSystem.ExactOptionalPropertyTypes = false;
     /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
     TypeSystem.AllowArrayObjects = false;
     /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
     TypeSystem.AllowNaN = false;
     /** Sets whether `null` should validate for void types. The default is `false` */
     TypeSystem.AllowVoidNull = false;
+    // ------------------------------------------------------------------------
+    // String Formats and Types
+    // ------------------------------------------------------------------------
     /** Creates a new type */
     function Type(kind, check) {
         if (Types.TypeRegistry.Has(kind))

package/value/check.js

@@ -53,6 +53,24 @@ var ValueCheck;
     // ----------------------------------------------------------------------
     // Guards
     // ----------------------------------------------------------------------
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    function IsInteger(value) {
+        return globalThis.Number.isInteger(value);
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsDefined(value) {
+        return value !== undefined;
+    }
+    // ----------------------------------------------------------------------
+    // Policies
+    // ----------------------------------------------------------------------
+    function IsExactOptionalProperty(value, key) {
+        return index_1.TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
+    }
     function IsObject(value) {
         const result = typeof value === 'object' && value !== null;
         return index_1.TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value);
@@ -60,26 +78,14 @@ var ValueCheck;
     function IsRecordObject(value) {
         return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array);
     }
-    function IsBigInt(value) {
-        return typeof value === 'bigint';
-    }
     function IsNumber(value) {
         const result = typeof value === 'number';
         return index_1.TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value);
     }
-    function IsInteger(value) {
-        return globalThis.Number.isInteger(value);
-    }
-    function IsString(value) {
-        return typeof value === 'string';
-    }
     function IsVoid(value) {
         const result = value === undefined;
         return index_1.TypeSystem.AllowVoidNull ? result || value === null : result;
     }
-    function IsDefined(value) {
-        return value !== undefined;
-    }
     // ----------------------------------------------------------------------
     // Types
     // ----------------------------------------------------------------------
@@ -255,7 +261,7 @@ var ValueCheck;
                 }
             }
             else {
-                if (knownKey in value && !Visit(property, references, value[knownKey])) {
+                if (IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
                     return false;
                 }
             }