@sinclair/typebox 0.24.30 → 0.24.33

package/errors/errors.d.ts

@@ -31,14 +31,16 @@ export declare enum ValueErrorType {
     StringMinLength = 28,
     StringMaxLength = 29,
     StringPattern = 30,
-    TupleZeroLength = 31,
-    TupleLength = 32,
-    Undefined = 33,
-    Union = 34,
-    Uint8Array = 35,
-    Uint8ArrayMinByteLength = 36,
-    Uint8ArrayMaxByteLength = 37,
-    Void = 38
+    StringFormatUnknown = 31,
+    StringFormat = 32,
+    TupleZeroLength = 33,
+    TupleLength = 34,
+    Undefined = 35,
+    Union = 36,
+    Uint8Array = 37,
+    Uint8ArrayMinByteLength = 38,
+    Uint8ArrayMaxByteLength = 39,
+    Void = 40
 }
 export interface ValueError {
     type: ValueErrorType;

package/errors/errors.js

@@ -29,6 +29,7 @@ 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");
 // -------------------------------------------------------------------
 // ValueErrorType
 // -------------------------------------------------------------------
@@ -65,14 +66,16 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["StringMinLength"] = 28] = "StringMinLength";
     ValueErrorType[ValueErrorType["StringMaxLength"] = 29] = "StringMaxLength";
     ValueErrorType[ValueErrorType["StringPattern"] = 30] = "StringPattern";
-    ValueErrorType[ValueErrorType["TupleZeroLength"] = 31] = "TupleZeroLength";
-    ValueErrorType[ValueErrorType["TupleLength"] = 32] = "TupleLength";
-    ValueErrorType[ValueErrorType["Undefined"] = 33] = "Undefined";
-    ValueErrorType[ValueErrorType["Union"] = 34] = "Union";
-    ValueErrorType[ValueErrorType["Uint8Array"] = 35] = "Uint8Array";
-    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 36] = "Uint8ArrayMinByteLength";
-    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 37] = "Uint8ArrayMaxByteLength";
-    ValueErrorType[ValueErrorType["Void"] = 38] = "Void";
+    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 31] = "StringFormatUnknown";
+    ValueErrorType[ValueErrorType["StringFormat"] = 32] = "StringFormat";
+    ValueErrorType[ValueErrorType["TupleZeroLength"] = 33] = "TupleZeroLength";
+    ValueErrorType[ValueErrorType["TupleLength"] = 34] = "TupleLength";
+    ValueErrorType[ValueErrorType["Undefined"] = 35] = "Undefined";
+    ValueErrorType[ValueErrorType["Union"] = 36] = "Union";
+    ValueErrorType[ValueErrorType["Uint8Array"] = 37] = "Uint8Array";
+    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 38] = "Uint8ArrayMinByteLength";
+    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 39] = "Uint8ArrayMaxByteLength";
+    ValueErrorType[ValueErrorType["Void"] = 40] = "Void";
 })(ValueErrorType = exports.ValueErrorType || (exports.ValueErrorType = {}));
 // -------------------------------------------------------------------
 // ValueErrors
@@ -250,6 +253,17 @@ var ValueErrors;
                 yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` };
             }
         }
+        if (schema.format !== undefined) {
+            if (!index_1.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);
+                if (!format(value)) {
+                    yield { type: ValueErrorType.StringFormat, schema, path, value, message: `Expected string to match format '${schema.format}'` };
+                }
+            }
+        }
     }
     function* Tuple(schema, references, path, value) {
         if (!globalThis.Array.isArray(value)) {

package/format/format.d.ts

@@ -2,7 +2,7 @@ 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(format: string): void;
+    function Clear(): void;
     /** Returns true if the string format exists */
     function Has(format: string): boolean;
     /** Sets a string format validation function */

package/format/format.js

@@ -33,7 +33,7 @@ var Format;
 (function (Format) {
     const formats = new Map();
     /** Clears all formats */
-    function Clear(format) {
+    function Clear() {
         return formats.clear();
     }
     Format.Clear = Clear;

package/package.json

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

package/readme.md

@@ -65,11 +65,11 @@ License MIT
 - [Unsafe Types](#unsafe-types)
 - [Conditional Types](#conditional-types)
 - [Values](#values)
+- [Formats](#formats)
 - [Guards](#guards)
 - [Strict](#strict)
 - [Validation](#validation)
 - [Compiler](#compiler)
-- [Formats](#formats)
 - [Benchmark](#benchmark)
 - [Contribute](#contribute)
 
@@ -688,8 +688,40 @@ const A = Value.Cast(T, null)                        // const A = { x: 0, y: 0 }
 const B = Value.Cast(T, { x: 1 })                    // const B = { x: 1, y: 0 }
 
 const C = Value.Cast(T, { x: 1, y: 2, z: 3 })        // const C = { x: 1, y: 2 }
+```
+
+## Formats
+
+Use the format module to create user defined string formats. This module enables programmatic validation of strings that cannot be easily validated with [pattern](https://json-schema.org/understanding-json-schema/reference/regular_expressions.html) expressions. The format module is used by the Value and TypeCompiler modules only. 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.
+
+```typescript
+import { Format } from '@sinclair/typebox/format'
+```
+
+The following demonstrates its use.
+
+```typescript
+//--------------------------------------------------------------------------------------------
+//
+// Use Format.Set(format, func) to define custom format
+//
+//--------------------------------------------------------------------------------------------
+
+Format.Set('palindrome', value => value === value.split('').reverse().join(''))
+
+//--------------------------------------------------------------------------------------------
+//
+// Use the format property on string types
+//
+//--------------------------------------------------------------------------------------------
 
+const T = Type.String({ format: 'palindrome' })
 
+Value.Check(T, 'kayak')                              // true
+
+Value.Check(T, 'engine')                             // false
 ```
 
 ## Guards
@@ -818,7 +850,7 @@ const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObje
   z: Type.Number()                                   //     z: TNumber;
 }))                                                  // }>>
 
-const R = C.Check({ x: 1, y: 2, z: 3 })              // const R = true 
+const R = C.Check({ x: 1, y: 2, z: 3 })              // const R = true
 ```
 
 Validation errors can be read with the `Errors(...)` function.
@@ -862,38 +894,6 @@ console.log(C.Code())                                // return function check(va
                                                      // }
 ```
 
-## Formats
-
-Use the `Format` module to define custom string formats.
-
-```typescript
-import { Format } from '@sinclair/typebox/format'
-```
-
-Formats are shared between `Value` and the `TypeCompiler` modules.
-
-```typescript
-//--------------------------------------------------------------------------------------------
-//
-// Use Format.Set(...) to define a format
-//
-//--------------------------------------------------------------------------------------------
-
-Format.Set('ObjectId', value => /^[0-9a-fA-F]{24}$/.test(value))
-
-//--------------------------------------------------------------------------------------------
-//
-// The format is now available to TypeCompiler and Value modules
-//
-//--------------------------------------------------------------------------------------------
-
-const T = Type.String({ format: 'ObjectId' })
-
-const R1 = TypeCompiler.Compile(T).Check('507f1f77bcf86cd799439011')
-
-const R2 = Value.Check(T, '507f1f77bcf86cd799439011')                
-```
-
 ## Benchmark
 
 This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.11.0. 

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 IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    function IsNumber(value) {
+        return typeof value === 'number';
+    }
+    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 value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === 1n) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'));
+    }
+    function TryConvertString(value) {
+        return IsValueToString(value) ? value.toString() : value;
+    }
+    function TryConvertNumber(value) {
+        return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : value;
+    }
+    function TryConvertInteger(value) {
+        return IsStringNumeric(value) ? parseInt(value) : IsValueTrue(value) ? 1 : 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/value.d.ts

@@ -10,9 +10,9 @@ export declare namespace Value {
     function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>;
     /** 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>;