@sinclair/typebox 0.24.31 → 0.24.34

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/package.json

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

package/readme.md

@@ -39,8 +39,6 @@ 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>
@@ -67,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)
 
@@ -148,8 +146,6 @@ function receive(value: T) {                         // ... as a Type
     // ok...
   }
 }
-
-
 ```
 
 ## Types
@@ -344,8 +340,6 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │ }                              │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
-
-
 ```
 
 ## Modifiers
@@ -388,8 +382,6 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 │                                │                             │ }                              │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
-
-
 ```
 
 ## Options
@@ -405,8 +397,6 @@ const T = Type.Number({ multipleOf: 2 })
 
 // array must have at least 5 integer values
 const T = Type.Array(Type.Integer(), { minItems: 5 })
-
-
 ```
 
 ## Extended Types
@@ -469,8 +459,6 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 │                                │                             │ }                              │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
-
-
 ```
 
 ## Reference Types
@@ -486,8 +474,6 @@ const T = Type.String({ $id: 'T' })                  // const T = {
 const R = Type.Ref(T)                                // const R = {
                                                      //    $ref: 'T'
                                                      // }
-
-
 ```
 
 ## Recursive Types
@@ -525,8 +511,6 @@ function test(node: Node) {
                  .nodes[0].nodes[0]
                  .id
 }
-
-
 ```
 
 ## Generic Types
@@ -557,8 +541,6 @@ const U = Nullable(Type.Number())                    // const U = {
                                                      // }
 
 type U = Static<typeof U>                            // type U = number | null
-
-
 ```
 
 ## Unsafe Types
@@ -571,8 +553,6 @@ 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.
@@ -613,8 +593,6 @@ const T = StringEnum(['A', 'B', 'C'])                // const T = {
                                                      // }
 
 type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
-
-
 ```
 
 ## Conditional Types
@@ -666,8 +644,6 @@ The following table shows the TypeBox mappings between TypeScript and JSON schem
 │ )                              │                             │                                │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
-
-
 ```
 
 ## Values
@@ -712,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
@@ -729,8 +737,6 @@ if(TypeGuard.TString(T)) {
     
   // T is TString
 }
-
-
 ```
 
 ## Strict
@@ -758,8 +764,6 @@ const U = Type.Strict(T)                             // const U = {
                                                      //     } 
                                                      //   } 
                                                      // }
-
-
 ```
 
 ## Validation
@@ -823,8 +827,6 @@ 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.
@@ -848,9 +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.
@@ -892,46 +892,6 @@ 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

package/value/cast.d.ts

@@ -3,9 +3,6 @@ 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

@@ -81,7 +81,7 @@ exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
 var ValueCast;
 (function (ValueCast) {
     // -----------------------------------------------------------
-    // Conversion
+    // Convert
     // -----------------------------------------------------------
     function IsString(value) {
         return typeof value === 'string';
@@ -89,12 +89,12 @@ var ValueCast;
     function IsBoolean(value) {
         return typeof value === 'boolean';
     }
-    function IsNumber(value) {
-        return typeof value === 'number';
-    }
     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));
     }
@@ -102,22 +102,25 @@ var ValueCast;
         return IsBigInt(value) || IsBoolean(value) || IsNumber(value);
     }
     function IsValueTrue(value) {
-        return (IsNumber(value) && value === 1) || (IsString(value) && ['true', 'TRUE', 'True'].includes(value));
+        return value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === 1n) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'));
+    }
+    function IsValueFalse(value) {
+        return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === 0n) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'));
     }
     function TryConvertString(value) {
         return IsValueToString(value) ? value.toString() : value;
     }
     function TryConvertNumber(value) {
-        return IsStringNumeric(value) ? parseFloat(value) : value;
+        return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : value;
     }
     function TryConvertInteger(value) {
-        return IsStringNumeric(value) ? parseInt(value) : value;
+        return IsStringNumeric(value) ? parseInt(value) : IsValueTrue(value) ? 1 : value;
     }
     function TryConvertBoolean(value) {
-        return IsValueTrue(value) ? true : value;
+        return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
     }
     // -----------------------------------------------------------
-    // Casts
+    // Cast
     // -----------------------------------------------------------
     function Any(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);