@sinclair/typebox 0.25.13 → 0.25.15

package/compiler/compiler.js

@@ -29,10 +29,11 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeCompiler = exports.TypeCompilerUnknownTypeError = exports.Property = exports.TypeCheck = void 0;
 const index_1 = require("../errors/index");
-const index_2 = require("../guard/index");
-const index_3 = require("../format/index");
-const index_4 = require("../custom/index");
-const index_5 = require("../hash/index");
+const index_2 = require("../system/index");
+const index_3 = require("../guard/index");
+const index_4 = require("../format/index");
+const index_5 = require("../custom/index");
+const index_6 = require("../hash/index");
 const Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
@@ -187,29 +188,34 @@ var TypeCompiler;
             yield `(${value} <= ${schema.maximum})`;
     }
     function* Object(schema, value) {
-        yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`;
+        if (index_2.TypeSystem.Kind === 'json-schema') {
+            yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`;
+        }
+        else if (index_2.TypeSystem.Kind === 'structural') {
+            yield `(typeof ${value} === 'object' && ${value} !== null)`;
+        }
         if (IsNumber(schema.minProperties))
-            yield `(Object.keys(${value}).length >= ${schema.minProperties})`;
+            yield `(Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties})`;
         if (IsNumber(schema.maxProperties))
-            yield `(Object.keys(${value}).length <= ${schema.maxProperties})`;
-        const propertyKeys = globalThis.Object.keys(schema.properties);
+            yield `(Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties})`;
+        const propertyKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
         if (schema.additionalProperties === false) {
             // Optimization: If the property key length matches the required keys length
             // then we only need check that the values property key length matches that
             // of the property key length. This is because exhaustive testing for values
             // will occur in subsequent property tests.
             if (schema.required && schema.required.length === propertyKeys.length) {
-                yield `(Object.keys(${value}).length === ${propertyKeys.length})`;
+                yield `(Object.getOwnPropertyNames(${value}).length === ${propertyKeys.length})`;
             }
             else {
                 const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`;
-                yield `(Object.keys(${value}).every(key => ${keys}.includes(key)))`;
+                yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key)))`;
             }
         }
-        if (index_2.TypeGuard.TSchema(schema.additionalProperties)) {
+        if (index_3.TypeGuard.TSchema(schema.additionalProperties)) {
             const expression = CreateExpression(schema.additionalProperties, 'value[key]');
             const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`;
-            yield `(Object.keys(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
+            yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
         }
         for (const propertyKey of propertyKeys) {
             const memberExpression = Property.Check(propertyKey) ? `${value}.${propertyKey}` : `${value}['${propertyKey}']`;
@@ -227,10 +233,15 @@ var TypeCompiler;
         yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
     }
     function* Record(schema, value) {
-        yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date))`;
+        if (index_2.TypeSystem.Kind === 'json-schema') {
+            yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date))`;
+        }
+        else if (index_2.TypeSystem.Kind === 'structural') {
+            yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date))`;
+        }
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const local = PushLocal(`new RegExp(/${keyPattern}/)`);
-        yield `(Object.keys(${value}).every(key => ${local}.test(key)))`;
+        yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`;
         const expression = CreateExpression(valueSchema, 'value');
         yield `(Object.values(${value}).every(value => ${expression}))`;
     }
@@ -359,7 +370,7 @@ var TypeCompiler;
             case 'Void':
                 return yield* Void(anySchema, value);
             default:
-                if (!index_4.Custom.Has(anySchema[Types.Kind]))
+                if (!index_5.Custom.Has(anySchema[Types.Kind]))
                     throw new TypeCompilerUnknownTypeError(schema);
                 return yield* UserDefined(anySchema, value);
         }
@@ -419,23 +430,23 @@ var TypeCompiler;
     }
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile(schema, references = []) {
-        index_2.TypeGuard.Assert(schema, references);
+        index_3.TypeGuard.Assert(schema, references);
         const code = Build(schema, references);
         const custom_schemas = new Map(state_remote_custom_types);
         const compiledFunction = globalThis.Function('custom', 'format', 'hash', code);
         const checkFunction = compiledFunction((kind, schema_key, value) => {
-            if (!index_4.Custom.Has(kind) || !custom_schemas.has(schema_key))
+            if (!index_5.Custom.Has(kind) || !custom_schemas.has(schema_key))
                 return false;
             const schema = custom_schemas.get(schema_key);
-            const func = index_4.Custom.Get(kind);
+            const func = index_5.Custom.Get(kind);
             return func(schema, value);
         }, (format, value) => {
-            if (!index_3.Format.Has(format))
+            if (!index_4.Format.Has(format))
                 return false;
-            const func = index_3.Format.Get(format);
+            const func = index_4.Format.Get(format);
             return func(value);
         }, (value) => {
-            return index_5.ValueHash.Create(value);
+            return index_6.ValueHash.Create(value);
         });
         return new TypeCheck(schema, references, checkFunction, code);
     }

package/errors/errors.js

@@ -29,9 +29,10 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueErrors = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
 const Types = require("../typebox");
-const index_1 = require("../format/index");
-const index_2 = require("../custom/index");
-const index_3 = require("../hash/index");
+const index_1 = require("../system/index");
+const index_2 = require("../format/index");
+const index_3 = require("../custom/index");
+const index_4 = require("../hash/index");
 // -------------------------------------------------------------------
 // ValueErrorType
 // -------------------------------------------------------------------
@@ -116,7 +117,7 @@ var ValueErrors;
         }
         // prettier-ignore
         if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
-            const hashed = index_3.ValueHash.Create(element);
+            const hashed = index_4.ValueHash.Create(element);
             if (set.has(hashed)) {
                 return false;
             }
@@ -218,39 +219,46 @@ var ValueErrors;
         }
     }
     function* Object(schema, references, path, value) {
-        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-            return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+        if (index_1.TypeSystem.Kind === 'json-schema') {
+            if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+                return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+            }
+        }
+        else if (index_1.TypeSystem.Kind === 'structural') {
+            if (!(typeof value === 'object' && value !== null)) {
+                return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+            }
         }
-        if (IsNumber(schema.minProperties) && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+        if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
             yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` };
         }
-        if (IsNumber(schema.maxProperties) && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
+        if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
             yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` };
         }
-        const propertyKeys = globalThis.Object.keys(schema.properties);
+        const propertyNames = globalThis.Object.getOwnPropertyNames(schema.properties);
         if (schema.additionalProperties === false) {
-            for (const objectKey of globalThis.Object.keys(value)) {
-                if (!propertyKeys.includes(objectKey)) {
-                    yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${objectKey}`, value: value[objectKey], message: `Unexpected property` };
+            for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
+                if (!propertyNames.includes(propertyName)) {
+                    yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${propertyName}`, value: value[propertyName], message: `Unexpected property` };
                 }
             }
         }
         if (schema.required && schema.required.length > 0) {
-            const objectKeys = globalThis.Object.keys(value);
+            const propertyNames = globalThis.Object.getOwnPropertyNames(value);
             for (const requiredKey of schema.required) {
-                if (objectKeys.includes(requiredKey))
+                if (propertyNames.includes(requiredKey))
                     continue;
                 yield { type: ValueErrorType.ObjectRequiredProperties, schema: schema.properties[requiredKey], path: `${path}/${requiredKey}`, value: undefined, message: `Expected required property` };
             }
         }
         if (typeof schema.additionalProperties === 'object') {
-            for (const objectKey of globalThis.Object.keys(value)) {
-                if (propertyKeys.includes(objectKey))
+            for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
+                if (propertyNames.includes(propertyName))
                     continue;
-                yield* Visit(schema.additionalProperties, references, `${path}/${objectKey}`, value[objectKey]);
+                yield* Visit(schema.additionalProperties, references, `${path}/${propertyName}`, value[propertyName]);
             }
         }
-        for (const propertyKey of propertyKeys) {
+        for (const propertyKey of propertyNames) {
             const propertySchema = schema.properties[propertyKey];
             if (schema.required && schema.required.includes(propertyKey)) {
                 yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey]);
@@ -268,12 +276,19 @@ var ValueErrors;
         }
     }
     function* Record(schema, references, path, value) {
-        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-            return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+        if (index_1.TypeSystem.Kind === 'json-schema') {
+            if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value) && !(value instanceof globalThis.Date))) {
+                return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+            }
+        }
+        else if (index_1.TypeSystem.Kind === 'structural') {
+            if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
+                return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+            }
         }
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const regex = new RegExp(keyPattern);
-        if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
+        if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
             const numeric = keyPattern === '^(0|[1-9][0-9]*)$';
             const type = numeric ? ValueErrorType.RecordKeyNumeric : ValueErrorType.RecordKeyString;
             const message = numeric ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings';
@@ -312,11 +327,11 @@ var ValueErrors;
             }
         }
         if (schema.format !== undefined) {
-            if (!index_1.Format.Has(schema.format)) {
+            if (!index_2.Format.Has(schema.format)) {
                 yield { type: ValueErrorType.StringFormatUnknown, schema, path, value, message: `Unknown string format '${schema.format}'` };
             }
             else {
-                const format = index_1.Format.Get(schema.format);
+                const format = index_2.Format.Get(schema.format);
                 if (!format(value)) {
                     yield { type: ValueErrorType.StringFormat, schema, path, value, message: `Expected string to match format '${schema.format}'` };
                 }
@@ -378,7 +393,7 @@ var ValueErrors;
         }
     }
     function* UserDefined(schema, references, path, value) {
-        const func = index_2.Custom.Get(schema[Types.Kind]);
+        const func = index_3.Custom.Get(schema[Types.Kind]);
         if (!func(schema, value)) {
             return yield { type: ValueErrorType.Custom, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` };
         }
@@ -434,7 +449,7 @@ var ValueErrors;
             case 'Void':
                 return yield* Void(anySchema, anyReferences, path, value);
             default:
-                if (!index_2.Custom.Has(anySchema[Types.Kind]))
+                if (!index_3.Custom.Has(anySchema[Types.Kind]))
                     throw new ValueErrorsUnknownTypeError(schema);
                 return yield* UserDefined(anySchema, anyReferences, path, value);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.13",
+  "version": "0.25.15",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -20,6 +20,7 @@
     "./format": "./format/index.js",
     "./guard": "./guard/index.js",
     "./hash": "./hash/index.js",
+    "./system": "./system/index.js",
     "./value": "./value/index.js",
     ".": "./typebox.js"
   },

package/readme.md

@@ -1143,27 +1143,28 @@ The custom module is an optional import.
 import { Custom } from '@sinclair/typebox/custom'
 ```
 
-The following creates a `BigInt` type.
+The following creates a `bigint` type.
 
 ```typescript
 import { Type, Kind } from '@sinclair/typebox'
 
-Custom.Set('BigInt', (schema, value) => typeof value === 'bigint')
+Custom.Set('bigint', (schema, value) => typeof value === 'bigint')
+//            ▲
 //            │
-//            └────────────────────────────┐         The [Kind] is used to match registered type
+//            └────────────────────────────┐
 //                                         │
-const T = Type.Unsafe<bigint>({ [Kind]: 'BigInt' })  // const T = { [Kind]: 'BigInt' }
+const T = Type.Unsafe<bigint>({ [Kind]: 'bigint' })  // const T = { [Kind]: 'BigInt' }
 
-const A = TypeCompiler.Compile(T).Check(65536)       // const A = false
+const A = TypeCompiler.Compile(T).Check(1n)          // const A = true
 
-const B = Value.Check(T, 65536n)                     // const B = true
+const B = Value.Check(T, 1)                          // const B = false
 ```
 
 <a name='typecheck-custom-formats'></a>
 
 ### Custom Formats
 
-Use the format module to create user defined string formats. If using Ajv, please refer to the official Ajv format documentation located [here](https://ajv.js.org/guide/formats.html). The format module is specific to TypeBox can only be used with the TypeCompiler and Value modules.
+Use the format module to create user defined string formats. The format module is specific to TypeBox can only be used with the TypeCompiler and Value modules. If using Ajv, please refer to the official Ajv format documentation located [here](https://ajv.js.org/guide/formats.html).
 
 The format module is an optional import.
 
@@ -1171,20 +1172,19 @@ The format module is an optional import.
 import { Format } from '@sinclair/typebox/format'
 ```
 
-The following creates a palindrome string format.
+The following creates a custom string format that checks for lowercase.
 
 ```typescript
-Format.Set('palindrome', value => value === value.split('').reverse().join(''))
-```
-
-Once set, this format can then be used by the TypeCompiler and Value modules.
-
-```typescript
-const T = Type.String({ format: 'palindrome' })
+Format.Set('lowercase', value => value === value.toLowerCase())
+//            ▲
+//            │
+//            └────────────────────┐         
+//                                 │
+const T = Type.String({ format: 'lowercase' })
 
-const A = TypeCompiler.Compile(T).Check('engine')    // const A = false
+const A = TypeCompiler.Compile(T).Check('action')    // const A = true
 
-const B = Value.Check(T, 'kayak')                    // const B = true
+const B = Value.Check(T, 'Action')                   // const B = false
 ```
 
 <a name='benchmark'></a>

package/system/index.d.ts

@@ -0,0 +1 @@
+export * from './system';

package/system/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/system
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./system"), exports);

package/system/system.d.ts

@@ -0,0 +1,18 @@
+export declare class InvalidTypeSystemError extends Error {
+    constructor(typeSystem: string);
+}
+export type TypeSystemKind = 'json-schema' | 'structural';
+declare class TypeSystemSettings {
+    private kind;
+    constructor();
+    /**
+     * `Experimental` Sets the type system kind used by TypeBox. By default TypeBox uses `json-schema` assertion
+     * rules to verify JavaScript values. If setting the type system to `structural`, TypeBox will use TypeScript
+     * structural checking rules enabling Arrays to be validated as Objects.
+     */
+    get Kind(): TypeSystemKind;
+    set Kind(value: TypeSystemKind);
+}
+/** TypeBox TypeSystem Settings */
+export declare const TypeSystem: TypeSystemSettings;
+export {};

package/system/system.js

@@ -0,0 +1,57 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/system
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSystem = exports.InvalidTypeSystemError = void 0;
+class InvalidTypeSystemError extends Error {
+    constructor(typeSystem) {
+        super(`TypeSystemSettings: Unknown TypeSystem '${typeSystem}'`);
+    }
+}
+exports.InvalidTypeSystemError = InvalidTypeSystemError;
+class TypeSystemSettings {
+    constructor() {
+        this.kind = 'json-schema';
+    }
+    /**
+     * `Experimental` Sets the type system kind used by TypeBox. By default TypeBox uses `json-schema` assertion
+     * rules to verify JavaScript values. If setting the type system to `structural`, TypeBox will use TypeScript
+     * structural checking rules enabling Arrays to be validated as Objects.
+     */
+    get Kind() {
+        return this.kind;
+    }
+    set Kind(value) {
+        if (!(value === 'json-schema' || value === 'structural')) {
+            throw new InvalidTypeSystemError(value);
+        }
+        this.kind = value;
+    }
+}
+/** TypeBox TypeSystem Settings */
+exports.TypeSystem = new TypeSystemSettings();

package/value/cast.js

@@ -239,11 +239,11 @@ var ValueCast;
         }
         // additional schema properties
         if (typeof schema.additionalProperties === 'object') {
-            const propertyKeys = globalThis.Object.keys(schema.properties);
-            for (const objectKey of globalThis.Object.keys(value)) {
-                if (propertyKeys.includes(objectKey))
+            const propertyNames = globalThis.Object.getOwnPropertyNames(schema.properties);
+            for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
+                if (propertyNames.includes(propertyName))
                     continue;
-                result[objectKey] = Visit(schema.additionalProperties, references, value[objectKey]);
+                result[propertyName] = Visit(schema.additionalProperties, references, value[propertyName]);
             }
         }
         return result;
@@ -256,8 +256,8 @@ var ValueCast;
             return clone_1.ValueClone.Clone(value);
         if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value) || value instanceof globalThis.Date)
             return create_1.ValueCreate.Create(schema, references);
-        const subschemaKey = globalThis.Object.keys(schema.patternProperties)[0];
-        const subschema = schema.patternProperties[subschemaKey];
+        const subschemaPropertyName = globalThis.Object.getOwnPropertyNames(schema.patternProperties)[0];
+        const subschema = schema.patternProperties[subschemaPropertyName];
         const result = {};
         for (const [propKey, propValue] of globalThis.Object.entries(value)) {
             result[propKey] = Visit(subschema, references, propValue);

package/value/check.js

@@ -29,9 +29,10 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueCheck = exports.ValueCheckUnknownTypeError = void 0;
 const Types = require("../typebox");
-const index_1 = require("../format/index");
-const index_2 = require("../custom/index");
-const index_3 = require("../hash/index");
+const index_1 = require("../system/index");
+const index_2 = require("../format/index");
+const index_3 = require("../custom/index");
+const index_4 = require("../hash/index");
 class ValueCheckUnknownTypeError extends Error {
     constructor(schema) {
         super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`);
@@ -59,7 +60,7 @@ var ValueCheck;
         }
         // prettier-ignore
         if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
-            const hashed = index_3.ValueHash.Create(element);
+            const hashed = index_4.ValueHash.Create(element);
             if (set.has(hashed)) {
                 return false;
             }
@@ -153,32 +154,39 @@ var ValueCheck;
         return true;
     }
     function Object(schema, references, value) {
-        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-            return false;
+        if (index_1.TypeSystem.Kind === 'json-schema') {
+            if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+                return false;
+            }
+        }
+        else if (index_1.TypeSystem.Kind === 'structural') {
+            if (!(typeof value === 'object' && value !== null)) {
+                return false;
+            }
         }
-        if (IsNumber(schema.minProperties) && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+        if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
             return false;
         }
-        if (IsNumber(schema.maxProperties) && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
+        if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
             return false;
         }
-        const propertyKeys = globalThis.Object.keys(schema.properties);
+        const propertyKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
         if (schema.additionalProperties === false) {
             // optimization: If the property key length matches the required keys length
             // then we only need check that the values property key length matches that
             // of the property key length. This is because exhaustive testing for values
             // will occur in subsequent property tests.
-            if (schema.required && schema.required.length === propertyKeys.length && !(globalThis.Object.keys(value).length === propertyKeys.length)) {
+            if (schema.required && schema.required.length === propertyKeys.length && !(globalThis.Object.getOwnPropertyNames(value).length === propertyKeys.length)) {
                 return false;
             }
             else {
-                if (!globalThis.Object.keys(value).every((key) => propertyKeys.includes(key))) {
+                if (!globalThis.Object.getOwnPropertyNames(value).every((key) => propertyKeys.includes(key))) {
                     return false;
                 }
             }
         }
         if (typeof schema.additionalProperties === 'object') {
-            for (const objectKey of globalThis.Object.keys(value)) {
+            for (const objectKey of globalThis.Object.getOwnPropertyNames(value)) {
                 if (propertyKeys.includes(objectKey))
                     continue;
                 if (!Visit(schema.additionalProperties, references, value[objectKey])) {
@@ -207,12 +215,19 @@ var ValueCheck;
         return typeof value === 'object' && typeof value.then === 'function';
     }
     function Record(schema, references, value) {
-        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value) && !(value instanceof globalThis.Date))) {
-            return false;
+        if (index_1.TypeSystem.Kind === 'json-schema') {
+            if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value) && !(value instanceof globalThis.Date))) {
+                return false;
+            }
+        }
+        else if (index_1.TypeSystem.Kind === 'structural') {
+            if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
+                return false;
+            }
         }
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const regex = new RegExp(keyPattern);
-        if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
+        if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
             return false;
         }
         for (const propValue of globalThis.Object.values(value)) {
@@ -251,9 +266,9 @@ var ValueCheck;
                 return false;
         }
         if (schema.format !== undefined) {
-            if (!index_1.Format.Has(schema.format))
+            if (!index_2.Format.Has(schema.format))
                 return false;
-            const func = index_1.Format.Get(schema.format);
+            const func = index_2.Format.Get(schema.format);
             return func(value);
         }
         return true;
@@ -302,9 +317,9 @@ var ValueCheck;
         return value === null;
     }
     function UserDefined(schema, references, value) {
-        if (!index_2.Custom.Has(schema[Types.Kind]))
+        if (!index_3.Custom.Has(schema[Types.Kind]))
             return false;
-        const func = index_2.Custom.Get(schema[Types.Kind]);
+        const func = index_3.Custom.Get(schema[Types.Kind]);
         return func(schema, value);
     }
     function Visit(schema, references, value) {
@@ -358,7 +373,7 @@ var ValueCheck;
             case 'Void':
                 return Void(anySchema, anyReferences, value);
             default:
-                if (!index_2.Custom.Has(anySchema[Types.Kind]))
+                if (!index_3.Custom.Has(anySchema[Types.Kind]))
                     throw new ValueCheckUnknownTypeError(anySchema);
                 return UserDefined(anySchema, anyReferences, value);
         }

package/value/create.js

@@ -131,13 +131,23 @@ var ValueCreate;
         }
     }
     function Literal(schema, references) {
-        return schema.const;
+        if (schema.default !== undefined) {
+            return schema.default;
+        }
+        else {
+            return schema.const;
+        }
     }
     function Never(schema, references) {
         throw new ValueCreateNeverTypeError(schema);
     }
     function Null(schema, references) {
-        return null;
+        if (schema.default !== undefined) {
+            return schema.default;
+        }
+        else {
+            return null;
+        }
     }
     function Number(schema, references) {
         if (schema.default !== undefined) {
@@ -258,7 +268,12 @@ var ValueCreate;
         }
     }
     function Undefined(schema, references) {
-        return undefined;
+        if (schema.default !== undefined) {
+            return schema.default;
+        }
+        else {
+            return undefined;
+        }
     }
     function Union(schema, references) {
         if (schema.default !== undefined) {
@@ -291,7 +306,12 @@ var ValueCreate;
         }
     }
     function Void(schema, references) {
-        return null;
+        if (schema.default !== undefined) {
+            return schema.default;
+        }
+        else {
+            return null;
+        }
     }
     function UserDefined(schema, references) {
         if (schema.default !== undefined) {