@sinclair/typebox 0.26.2 → 0.26.4

package/compiler/compiler.d.ts

@@ -14,9 +14,6 @@ export declare class TypeCheck<T extends Types.TSchema> {
     /** Returns true if the value matches the compiled type. */
     Check(value: unknown): value is Types.Static<T>;
 }
-export declare namespace MemberExpression {
-    function Encode(object: string, key: string): string;
-}
 export declare class TypeCompilerUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);

package/compiler/compiler.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompiler = exports.TypeCompilerTypeGuardError = exports.TypeCompilerDereferenceError = exports.TypeCompilerUnknownTypeError = exports.MemberExpression = exports.TypeCheck = void 0;
+exports.TypeCompiler = exports.TypeCompilerTypeGuardError = exports.TypeCompilerDereferenceError = exports.TypeCompilerUnknownTypeError = exports.TypeCheck = void 0;
 const Types = require("../typebox");
 const index_1 = require("../errors/index");
 const index_2 = require("../system/index");
@@ -65,20 +65,49 @@ var Character;
         return code === 36;
     }
     Character.DollarSign = DollarSign;
-    function Underscore(code) {
+    function IsUnderscore(code) {
         return code === 95;
     }
-    Character.Underscore = Underscore;
-    function Numeric(code) {
-        return code >= 48 && code <= 57;
+    Character.IsUnderscore = IsUnderscore;
+    function IsAlpha(code) {
+        return (code >= 64 && code <= 90) || (code >= 97 && code <= 122);
     }
-    Character.Numeric = Numeric;
-    function Alpha(code) {
-        return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+    Character.IsAlpha = IsAlpha;
+    function IsNumeric(code) {
+        return code >= 48 && code <= 57;
     }
-    Character.Alpha = Alpha;
+    Character.IsNumeric = IsNumeric;
 })(Character || (Character = {}));
 // -------------------------------------------------------------------
+// MemberExpression
+// -------------------------------------------------------------------
+var MemberExpression;
+(function (MemberExpression) {
+    function IsFirstCharacterNumeric(value) {
+        if (value.length === 0)
+            return false;
+        return Character.IsNumeric(value.charCodeAt(0));
+    }
+    function IsAccessor(value) {
+        if (IsFirstCharacterNumeric(value))
+            return false;
+        for (let i = 0; i < value.length; i++) {
+            const code = value.charCodeAt(i);
+            const check = Character.IsAlpha(code) || Character.IsNumeric(code) || Character.DollarSign(code) || Character.IsUnderscore(code);
+            if (!check)
+                return false;
+        }
+        return true;
+    }
+    function EscapeHyphen(key) {
+        return key.replace(/'/g, "\\'");
+    }
+    function Encode(object, key) {
+        return IsAccessor(key) ? `${object}.${key}` : `${object}['${EscapeHyphen(key)}']`;
+    }
+    MemberExpression.Encode = Encode;
+})(MemberExpression || (MemberExpression = {}));
+// -------------------------------------------------------------------
 // Identifier
 // -------------------------------------------------------------------
 var Identifier;
@@ -87,7 +116,7 @@ var Identifier;
         const buffer = [];
         for (let i = 0; i < $id.length; i++) {
             const code = $id.charCodeAt(i);
-            if (Character.Numeric(code) || Character.Alpha(code)) {
+            if (Character.IsNumeric(code) || Character.IsAlpha(code)) {
                 buffer.push($id.charAt(i));
             }
             else {
@@ -99,33 +128,6 @@ var Identifier;
     Identifier.Encode = Encode;
 })(Identifier || (Identifier = {}));
 // -------------------------------------------------------------------
-// MemberExpression
-// -------------------------------------------------------------------
-var MemberExpression;
-(function (MemberExpression) {
-    function Check(propertyName) {
-        if (propertyName.length === 0)
-            return false;
-        {
-            const code = propertyName.charCodeAt(0);
-            if (!(Character.DollarSign(code) || Character.Underscore(code) || Character.Alpha(code))) {
-                return false;
-            }
-        }
-        for (let i = 1; i < propertyName.length; i++) {
-            const code = propertyName.charCodeAt(i);
-            if (!(Character.DollarSign(code) || Character.Underscore(code) || Character.Alpha(code) || Character.Numeric(code))) {
-                return false;
-            }
-        }
-        return true;
-    }
-    function Encode(object, key) {
-        return !Check(key) ? `${object}['${key}']` : `${object}.${key}`;
-    }
-    MemberExpression.Encode = Encode;
-})(MemberExpression = exports.MemberExpression || (exports.MemberExpression = {}));
-// -------------------------------------------------------------------
 // TypeCompiler
 // -------------------------------------------------------------------
 class TypeCompilerUnknownTypeError extends Error {
@@ -165,10 +167,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 +180,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 +307,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.4",
   "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;
                 }
             }