@sinclair/typebox 0.24.28 → 0.24.31

package/compiler/compiler.js

@@ -30,6 +30,7 @@ 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 Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
@@ -236,6 +237,9 @@ var TypeCompiler;
             const local = PushLocal(`new RegExp(/${schema.pattern}/);`);
             yield `(${local}.test(${value}))`;
         }
+        if (schema.format !== undefined) {
+            yield `(format('${schema.format}', ${value}))`;
+        }
     }
     function* Tuple(schema, value) {
         yield `(Array.isArray(${value}))`;
@@ -382,8 +386,14 @@ var TypeCompiler;
     function Compile(schema, references = []) {
         index_2.TypeGuard.Assert(schema, references);
         const code = Build(schema, references);
-        const func = globalThis.Function(code);
-        return new TypeCheck(schema, references, func(), code);
+        const func1 = globalThis.Function('format', code);
+        const func2 = func1((format, value) => {
+            if (!index_3.Format.Has(format))
+                return false;
+            const func = index_3.Format.Get(format);
+            return func(value);
+        });
+        return new TypeCheck(schema, references, func2, code);
     }
     TypeCompiler.Compile = Compile;
 })(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));

package/format/format.d.ts

@@ -0,0 +1,12 @@
+export declare type FormatValidationFunction = (value: string) => boolean;
+/** Shared string formats used by the TypeCompiler and Value modules */
+export declare namespace Format {
+    /** Clears all formats */
+    function Clear(): void;
+    /** Returns true if the string format exists */
+    function Has(format: string): boolean;
+    /** Sets a string format validation function */
+    function Set(format: string, func: FormatValidationFunction): void;
+    /** Gets a string format validation function */
+    function Get(format: string): FormatValidationFunction | undefined;
+}

package/format/format.js

@@ -0,0 +1,55 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+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.Format = void 0;
+/** Shared string formats used by the TypeCompiler and Value modules */
+var Format;
+(function (Format) {
+    const formats = new Map();
+    /** Clears all formats */
+    function Clear() {
+        return formats.clear();
+    }
+    Format.Clear = Clear;
+    /** Returns true if the string format exists */
+    function Has(format) {
+        return formats.has(format);
+    }
+    Format.Has = Has;
+    /** Sets a string format validation function */
+    function Set(format, func) {
+        formats.set(format, func);
+    }
+    Format.Set = Set;
+    /** Gets a string format validation function */
+    function Get(format) {
+        return formats.get(format);
+    }
+    Format.Get = Get;
+})(Format = exports.Format || (exports.Format = {}));

package/format/index.d.ts

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

package/format/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+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("./format"), exports);

package/guard/guard.js

@@ -54,7 +54,7 @@ var TypeGuard;
             return false;
         }
     }
-    function IsValidPropertyKey(value) {
+    function IsControlCharacterFree(value) {
         if (typeof value !== 'string')
             return false;
         for (let i = 0; i < value.length; i++) {
@@ -84,7 +84,10 @@ var TypeGuard;
         return value === undefined || (value !== undefined && IsString(value));
     }
     function IsOptionalPattern(value) {
-        return value === undefined || (value !== undefined && IsString(value) && IsPattern(value));
+        return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value) && IsPattern(value));
+    }
+    function IsOptionalFormat(value) {
+        return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value));
     }
     /** Returns true if the given schema is TAny */
     function TAny(schema) {
@@ -181,7 +184,7 @@ var TypeGuard;
             return false;
         }
         for (const [key, value] of Object.entries(schema.properties)) {
-            if (!IsValidPropertyKey(key))
+            if (!IsControlCharacterFree(key))
                 return false;
             if (!TSchema(value))
                 return false;
@@ -231,7 +234,7 @@ var TypeGuard;
             IsOptionalNumber(schema.minLength) &&
             IsOptionalNumber(schema.maxLength) &&
             IsOptionalPattern(schema.pattern) &&
-            IsOptionalString(schema.format));
+            IsOptionalFormat(schema.format));
     }
     TypeGuard.TString = TString;
     /** Returns true if the given schema is TTuple */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.28",
+  "version": "0.24.31",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -26,15 +26,15 @@
     "publish": "hammer task publish"
   },
   "devDependencies": {
-    "@sinclair/hammer": "^0.17.0",
-    "@types/chai": "^4.3.0",
-    "@types/mocha": "^9.1.0",
-    "@types/node": "^17.0.12",
+    "@sinclair/hammer": "^0.17.1",
+    "@types/chai": "^4.3.3",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^18.7.13",
     "ajv": "^8.11.0",
     "ajv-formats": "^2.1.1",
-    "chai": "^4.3.5",
-    "mocha": "^9.2.0",
+    "chai": "^4.3.6",
+    "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^4.7.4"
+    "typescript": "^4.8.2"
   }
 }

package/readme.md

@@ -39,6 +39,8 @@ import { Static, Type } from '@sinclair/typebox'
 const T = Type.String()     // const T = { type: 'string' }
 
 type T = Static<typeof T>   // type T = string
+
+
 ```
 
 <a name="Overview"></a>
@@ -69,6 +71,7 @@ License MIT
 - [Strict](#strict)
 - [Validation](#validation)
 - [Compiler](#compiler)
+- [Formats](#formats)
 - [Benchmark](#benchmark)
 - [Contribute](#contribute)
 
@@ -145,6 +148,8 @@ function receive(value: T) {                         // ... as a Type
     // ok...
   }
 }
+
+
 ```
 
 ## Types
@@ -339,6 +344,8 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │ }                              │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
+
+
 ```
 
 ## Modifiers
@@ -381,6 +388,8 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 │                                │                             │ }                              │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
+
+
 ```
 
 ## Options
@@ -396,6 +405,8 @@ const T = Type.Number({ multipleOf: 2 })
 
 // array must have at least 5 integer values
 const T = Type.Array(Type.Integer(), { minItems: 5 })
+
+
 ```
 
 ## Extended Types
@@ -458,6 +469,8 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 │                                │                             │ }                              │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
+
+
 ```
 
 ## Reference Types
@@ -473,6 +486,8 @@ const T = Type.String({ $id: 'T' })                  // const T = {
 const R = Type.Ref(T)                                // const R = {
                                                      //    $ref: 'T'
                                                      // }
+
+
 ```
 
 ## Recursive Types
@@ -510,6 +525,8 @@ function test(node: Node) {
                  .nodes[0].nodes[0]
                  .id
 }
+
+
 ```
 
 ## Generic Types
@@ -540,6 +557,8 @@ const U = Nullable(Type.Number())                    // const U = {
                                                      // }
 
 type U = Static<typeof U>                            // type U = number | null
+
+
 ```
 
 ## Unsafe Types
@@ -552,6 +571,8 @@ const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
                                                      // }
 
 type T = Static<typeof T>                            // type T = string
+
+
 ```
 
 This function can be used to create custom schemas for validators that require specific schema representations. An example of this might be OpenAPI's `nullable` and `enum` schemas which are not provided by TypeBox. The following demonstrates using `Type.Unsafe(...)` to create these types.
@@ -592,6 +613,8 @@ const T = StringEnum(['A', 'B', 'C'])                // const T = {
                                                      // }
 
 type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
+
+
 ```
 
 ## Conditional Types
@@ -643,6 +666,8 @@ The following table shows the TypeBox mappings between TypeScript and JSON schem
 │ )                              │                             │                                │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
+
+
 ```
 
 ## Values
@@ -704,6 +729,8 @@ if(TypeGuard.TString(T)) {
     
   // T is TString
 }
+
+
 ```
 
 ## Strict
@@ -731,6 +758,8 @@ const U = Type.Strict(T)                             // const U = {
                                                      //     } 
                                                      //   } 
                                                      // }
+
+
 ```
 
 ## Validation
@@ -794,6 +823,8 @@ const T = Type.Object({
 //--------------------------------------------------------------------------------------------
 
 const R = ajv.validate(T, { x: 1, y: 2, z: 3 })      // const R = true
+
+
 ```
 
 Please refer to the official Ajv [documentation](https://ajv.js.org/guide/getting-started.html) for additional information on using Ajv.
@@ -818,6 +849,8 @@ const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObje
 }))                                                  // }>>
 
 const R = C.Check({ x: 1, y: 2, z: 3 })              // const R = true 
+
+
 ```
 
 Validation errors can be read with the `Errors(...)` function.
@@ -859,9 +892,47 @@ console.log(C.Code())                                // return function check(va
                                                      //     (typeof value === 'string')
                                                      //   )
                                                      // }
+
+
 ```
 
+## Formats
+
+Use the `Format` module to create custom string formats. Formats provide greater flexibility over [string patterns](https://json-schema.org/understanding-json-schema/reference/regular_expressions.html), but may come at a cost of schema portability. Formats are internally shared between the TypeCompiler and Value modules. TypeBox does not provide any built in formats by default.
 
+The format module is an optional import.
+
+```typescript
+import { Format } from '@sinclair/typebox/format'
+```
+
+The following creates a custom format to validate Mongo `ObjectId` strings
+
+```typescript
+//--------------------------------------------------------------------------------------------
+//
+// Format.Set(...) to create the format
+//
+//--------------------------------------------------------------------------------------------
+
+Format.Set('ObjectId', value => /^[0-9a-fA-F]{24}$/.test(value))
+
+//--------------------------------------------------------------------------------------------
+//
+// The format can now be used by TypeCompiler and Value modules
+//
+//--------------------------------------------------------------------------------------------
+
+const T = Type.String({ format: 'ObjectId' })
+
+const V = '507f1f77bcf86cd799439011'
+
+const R1 = TypeCompiler.Compile(T).Check(V)          // R1 = true
+
+const R2 = Value.Check(T, V)                         // R2 = true
+
+
+```
 
 ## Benchmark
 
@@ -877,29 +948,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    399 ms' │ '      9 ms' │ '   44.33 x' │
-│           String │    2000    │ '    306 ms' │ '      8 ms' │ '   38.25 x' │
-│          Boolean │    2000    │ '    315 ms' │ '      5 ms' │ '   63.00 x' │
-│             Null │    2000    │ '    255 ms' │ '      6 ms' │ '   42.50 x' │
-│            RegEx │    2000    │ '    478 ms' │ '     10 ms' │ '   47.80 x' │
-│          ObjectA │    2000    │ '   2850 ms' │ '     39 ms' │ '   73.08 x' │
-│          ObjectB │    2000    │ '   3027 ms' │ '     34 ms' │ '   89.03 x' │
-│            Tuple │    2000    │ '   1374 ms' │ '     27 ms' │ '   50.89 x' │
-│            Union │    2000    │ '   1307 ms' │ '     22 ms' │ '   59.41 x' │
-│          Vector4 │    2000    │ '   1568 ms' │ '     17 ms' │ '   92.24 x' │
-│          Matrix4 │    2000    │ '    911 ms' │ '     11 ms' │ '   82.82 x' │
-│   Literal_String │    2000    │ '    332 ms' │ '      8 ms' │ '   41.50 x' │
-│   Literal_Number │    2000    │ '    363 ms' │ '      8 ms' │ '   45.38 x' │
-│  Literal_Boolean │    2000    │ '    360 ms' │ '      5 ms' │ '   72.00 x' │
-│     Array_Number │    2000    │ '    704 ms' │ '      6 ms' │ '  117.33 x' │
-│     Array_String │    2000    │ '    745 ms' │ '     11 ms' │ '   67.73 x' │
-│    Array_Boolean │    2000    │ '    781 ms' │ '      7 ms' │ '  111.57 x' │
-│    Array_ObjectA │    2000    │ '   3552 ms' │ '     31 ms' │ '  114.58 x' │
-│    Array_ObjectB │    2000    │ '   3738 ms' │ '     33 ms' │ '  113.27 x' │
-│      Array_Tuple │    2000    │ '   2336 ms' │ '     16 ms' │ '  146.00 x' │
-│      Array_Union │    2000    │ '   1758 ms' │ '     20 ms' │ '   87.90 x' │
-│    Array_Vector4 │    2000    │ '   2305 ms' │ '     16 ms' │ '  144.06 x' │
-│    Array_Matrix4 │    2000    │ '   1635 ms' │ '     11 ms' │ '  148.64 x' │
+│           Number │    2000    │ '    402 ms' │ '      8 ms' │ '   50.25 x' │
+│           String │    2000    │ '    316 ms' │ '      8 ms' │ '   39.50 x' │
+│          Boolean │    2000    │ '    308 ms' │ '      6 ms' │ '   51.33 x' │
+│             Null │    2000    │ '    259 ms' │ '      5 ms' │ '   51.80 x' │
+│            RegEx │    2000    │ '    479 ms' │ '     11 ms' │ '   43.55 x' │
+│          ObjectA │    2000    │ '   2766 ms' │ '     41 ms' │ '   67.46 x' │
+│          ObjectB │    2000    │ '   3062 ms' │ '     29 ms' │ '  105.59 x' │
+│            Tuple │    2000    │ '   1258 ms' │ '     21 ms' │ '   59.90 x' │
+│            Union │    2000    │ '   1449 ms' │ '     29 ms' │ '   49.97 x' │
+│          Vector4 │    2000    │ '   1616 ms' │ '     16 ms' │ '  101.00 x' │
+│          Matrix4 │    2000    │ '    975 ms' │ '      8 ms' │ '  121.88 x' │
+│   Literal_String │    2000    │ '    350 ms' │ '      6 ms' │ '   58.33 x' │
+│   Literal_Number │    2000    │ '    386 ms' │ '      5 ms' │ '   77.20 x' │
+│  Literal_Boolean │    2000    │ '    377 ms' │ '      4 ms' │ '   94.25 x' │
+│     Array_Number │    2000    │ '    737 ms' │ '      7 ms' │ '  105.29 x' │
+│     Array_String │    2000    │ '    765 ms' │ '      7 ms' │ '  109.29 x' │
+│    Array_Boolean │    2000    │ '    783 ms' │ '      8 ms' │ '   97.88 x' │
+│    Array_ObjectA │    2000    │ '   3578 ms' │ '     31 ms' │ '  115.42 x' │
+│    Array_ObjectB │    2000    │ '   3718 ms' │ '     33 ms' │ '  112.67 x' │
+│      Array_Tuple │    2000    │ '   2259 ms' │ '     14 ms' │ '  161.36 x' │
+│      Array_Union │    2000    │ '   1704 ms' │ '     20 ms' │ '   85.20 x' │
+│    Array_Vector4 │    2000    │ '   2293 ms' │ '     17 ms' │ '  134.88 x' │
+│    Array_Matrix4 │    2000    │ '   1575 ms' │ '     12 ms' │ '  131.25 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -911,31 +982,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     31 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
-│           String │  1000000   │ '     26 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
-│          Boolean │  1000000   │ '     21 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
-│             Null │  1000000   │ '     25 ms' │ '     24 ms' │ '      9 ms' │ '    2.67 x' │
-│            RegEx │  1000000   │ '    166 ms' │ '     45 ms' │ '     38 ms' │ '    1.18 x' │
-│          ObjectA │  1000000   │ '    535 ms' │ '     36 ms' │ '     22 ms' │ '    1.64 x' │
-│          ObjectB │  1000000   │ '    957 ms' │ '     49 ms' │ '     37 ms' │ '    1.32 x' │
-│            Tuple │  1000000   │ '    112 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
-│            Union │  1000000   │ '    304 ms' │ '     25 ms' │ '     14 ms' │ '    1.79 x' │
-│        Recursive │  1000000   │ '   2986 ms' │ '    391 ms' │ '    164 ms' │ '    2.38 x' │
-│          Vector4 │  1000000   │ '    145 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
-│          Matrix4 │  1000000   │ '    575 ms' │ '     39 ms' │ '     29 ms' │ '    1.34 x' │
-│   Literal_String │  1000000   │ '     44 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
-│   Literal_Number │  1000000   │ '     46 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
-│  Literal_Boolean │  1000000   │ '     47 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
-│     Array_Number │  1000000   │ '    398 ms' │ '     30 ms' │ '     17 ms' │ '    1.76 x' │
-│     Array_String │  1000000   │ '    438 ms' │ '     30 ms' │ '     20 ms' │ '    1.50 x' │
-│    Array_Boolean │  1000000   │ '    443 ms' │ '     37 ms' │ '     24 ms' │ '    1.54 x' │
-│    Array_ObjectA │  1000000   │ '  13702 ms' │ '   2649 ms' │ '   1673 ms' │ '    1.58 x' │
-│    Array_ObjectB │  1000000   │ '  16091 ms' │ '   2964 ms' │ '   2032 ms' │ '    1.46 x' │
-│      Array_Tuple │  1000000   │ '   1665 ms' │ '     92 ms' │ '     70 ms' │ '    1.31 x' │
-│      Array_Union │  1000000   │ '   4631 ms' │ '    220 ms' │ '     88 ms' │ '    2.50 x' │
-│  Array_Recursive │  1000000   │ '  53745 ms' │ '   6891 ms' │ '   2744 ms' │ '    2.51 x' │
-│    Array_Vector4 │  1000000   │ '   2156 ms' │ '    105 ms' │ '     55 ms' │ '    1.91 x' │
-│    Array_Matrix4 │  1000000   │ '  11686 ms' │ '    388 ms' │ '    330 ms' │ '    1.18 x' │
+│           Number │  1000000   │ '     38 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
+│           String │  1000000   │ '     26 ms' │ '     23 ms' │ '     12 ms' │ '    1.92 x' │
+│          Boolean │  1000000   │ '     26 ms' │ '     23 ms' │ '     11 ms' │ '    2.09 x' │
+│             Null │  1000000   │ '     29 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
+│            RegEx │  1000000   │ '    169 ms' │ '     47 ms' │ '     37 ms' │ '    1.27 x' │
+│          ObjectA │  1000000   │ '    551 ms' │ '     45 ms' │ '     23 ms' │ '    1.96 x' │
+│          ObjectB │  1000000   │ '    995 ms' │ '     49 ms' │ '     39 ms' │ '    1.26 x' │
+│            Tuple │  1000000   │ '    115 ms' │ '     30 ms' │ '     14 ms' │ '    2.14 x' │
+│            Union │  1000000   │ '    294 ms' │ '     30 ms' │ '     14 ms' │ '    2.14 x' │
+│        Recursive │  1000000   │ '   3308 ms' │ '    429 ms' │ '    174 ms' │ '    2.47 x' │
+│          Vector4 │  1000000   │ '    145 ms' │ '     25 ms' │ '     13 ms' │ '    1.92 x' │
+│          Matrix4 │  1000000   │ '    663 ms' │ '     42 ms' │ '     34 ms' │ '    1.24 x' │
+│   Literal_String │  1000000   │ '     46 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│   Literal_Number │  1000000   │ '     50 ms' │ '     26 ms' │ '     11 ms' │ '    2.36 x' │
+│  Literal_Boolean │  1000000   │ '     45 ms' │ '     24 ms' │ '     11 ms' │ '    2.18 x' │
+│     Array_Number │  1000000   │ '    411 ms' │ '     35 ms' │ '     19 ms' │ '    1.84 x' │
+│     Array_String │  1000000   │ '    438 ms' │ '     33 ms' │ '     20 ms' │ '    1.65 x' │
+│    Array_Boolean │  1000000   │ '    444 ms' │ '     38 ms' │ '     24 ms' │ '    1.58 x' │
+│    Array_ObjectA │  1000000   │ '  13714 ms' │ '   2819 ms' │ '   1791 ms' │ '    1.57 x' │
+│    Array_ObjectB │  1000000   │ '  15855 ms' │ '   2965 ms' │ '   2066 ms' │ '    1.44 x' │
+│      Array_Tuple │  1000000   │ '   1682 ms' │ '     94 ms' │ '     71 ms' │ '    1.32 x' │
+│      Array_Union │  1000000   │ '   4575 ms' │ '    239 ms' │ '     86 ms' │ '    2.78 x' │
+│  Array_Recursive │  1000000   │ '  51970 ms' │ '   7192 ms' │ '   2617 ms' │ '    2.75 x' │
+│    Array_Vector4 │  1000000   │ '   2097 ms' │ '    100 ms' │ '     54 ms' │ '    1.85 x' │
+│    Array_Matrix4 │  1000000   │ '  11596 ms' │ '    381 ms' │ '    327 ms' │ '    1.17 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -947,8 +1018,9 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   47 kb' │ '   23 kb' │  '1.99 x'   │
+│ typebox/compiler     │ '   48 kb' │ '   24 kb' │  '2.00 x'   │
 │ typebox/conditional  │ '   41 kb' │ '   16 kb' │  '2.47 x'   │
+│ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.68 x'   │
 │ typebox/guard        │ '   20 kb' │ '    9 kb' │  '2.08 x'   │
 │ typebox/value        │ '   55 kb' │ '   25 kb' │  '2.15 x'   │
 │ typebox              │ '   11 kb' │ '    5 kb' │  '1.91 x'   │

package/value/cast.d.ts

@@ -3,6 +3,9 @@ export declare class ValueCastUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export interface ValueCastOptions {
+    convert: boolean;
+}
 export declare namespace ValueCast {
     function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
     function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): Types.Static<T>;

package/value/cast.js

@@ -80,6 +80,45 @@ class ValueCastUnknownTypeError extends Error {
 exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
 var ValueCast;
 (function (ValueCast) {
+    // -----------------------------------------------------------
+    // Conversion
+    // -----------------------------------------------------------
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsBoolean(value) {
+        return typeof value === 'boolean';
+    }
+    function IsNumber(value) {
+        return typeof value === 'number';
+    }
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    function IsStringNumeric(value) {
+        return IsString(value) && !isNaN(value) && !isNaN(parseFloat(value));
+    }
+    function IsValueToString(value) {
+        return IsBigInt(value) || IsBoolean(value) || IsNumber(value);
+    }
+    function IsValueTrue(value) {
+        return (IsNumber(value) && value === 1) || (IsString(value) && ['true', 'TRUE', 'True'].includes(value));
+    }
+    function TryConvertString(value) {
+        return IsValueToString(value) ? value.toString() : value;
+    }
+    function TryConvertNumber(value) {
+        return IsStringNumeric(value) ? parseFloat(value) : value;
+    }
+    function TryConvertInteger(value) {
+        return IsStringNumeric(value) ? parseInt(value) : value;
+    }
+    function TryConvertBoolean(value) {
+        return IsValueTrue(value) ? true : value;
+    }
+    // -----------------------------------------------------------
+    // Casts
+    // -----------------------------------------------------------
     function Any(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
@@ -91,7 +130,8 @@ var ValueCast;
         return value.map((val) => Visit(schema.items, references, val));
     }
     function Boolean(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+        const conversion = TryConvertBoolean(value);
+        return check_1.ValueCheck.Check(schema, references, conversion) ? conversion : create_1.ValueCreate.Create(schema, references);
     }
     function Constructor(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
@@ -112,7 +152,8 @@ var ValueCast;
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
     function Integer(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+        const conversion = TryConvertInteger(value);
+        return check_1.ValueCheck.Check(schema, references, conversion) ? conversion : create_1.ValueCreate.Create(schema, references);
     }
     function Literal(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
@@ -121,7 +162,8 @@ var ValueCast;
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
     function Number(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+        const conversion = TryConvertNumber(value);
+        return check_1.ValueCheck.Check(schema, references, conversion) ? conversion : create_1.ValueCreate.Create(schema, references);
     }
     function Object(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
@@ -169,7 +211,8 @@ var ValueCast;
         return Visit(reference, references, value);
     }
     function String(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+        const conversion = TryConvertString(value);
+        return check_1.ValueCheck.Check(schema, references, conversion) ? conversion : create_1.ValueCreate.Create(schema, references);
     }
     function Tuple(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))

package/value/check.js

@@ -29,6 +29,7 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueCheck = exports.ValueCheckUnknownTypeError = void 0;
 const Types = require("../typebox");
+const format_1 = require("../format");
 class ValueCheckUnknownTypeError extends Error {
     constructor(schema) {
         super('ValueCheck: Unknown type');
@@ -205,6 +206,12 @@ var ValueCheck;
             if (!regex.test(value))
                 return false;
         }
+        if (schema.format !== undefined) {
+            if (!format_1.Format.Has(schema.format))
+                return false;
+            const func = format_1.Format.Get(schema.format);
+            return func(value);
+        }
         return true;
     }
     function Tuple(schema, references, value) {

package/value/create.js

@@ -213,6 +213,14 @@ var ValueCreate;
                 return schema.default;
             }
         }
+        else if (schema.format !== undefined) {
+            if (schema.default === undefined) {
+                throw new Error('ValueCreate.String: String types with formats must specify a default value');
+            }
+            else {
+                return schema.default;
+            }
+        }
         else {
             if (schema.default !== undefined) {
                 return schema.default;

package/value/value.d.ts

@@ -6,13 +6,13 @@ export declare namespace Value {
     function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>;
     /** Creates a value from the given type */
     function Create<T extends Types.TSchema>(schema: T): Types.Static<T>;
-    /** Checks a value matches the given type */
+    /** Returns true if the value matches the given type. */
     function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>;
-    /** Checks a value matches the given type */
+    /** Returns true if the value matches the given type. */
     function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;
-    /** Casts a value into a structure matching the given type. The result will be a new value that retains as much information of the original value as possible. */
+    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is possible. */
     function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>;
-    /** Casts a value into a structure matching the given type. The result will be a new value that retains as much information of the original value as possible. */
+    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is possible. */
     function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>;
     /** Returns an iterator for each error in this value. */
     function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): IterableIterator<ValueError>;