@sinclair/typebox 0.25.16 → 0.25.18

package/compiler/compiler.js

@@ -134,7 +134,7 @@ var TypeCompiler;
         yield* Visit(schema.returns, `${value}.prototype`);
     }
     function* Date(schema, value) {
-        yield `(${value} instanceof Date)`;
+        yield `(${value} instanceof Date) && !isNaN(${value}.getTime())`;
         if (IsNumber(schema.exclusiveMinimumTimestamp))
             yield `(${value}.getTime() > ${schema.exclusiveMinimumTimestamp})`;
         if (IsNumber(schema.exclusiveMaximumTimestamp))
@@ -272,7 +272,7 @@ var TypeCompiler;
         if (IsNumber(schema.maxLength))
             yield `(${value}.length <= ${schema.maxLength})`;
         if (schema.pattern !== undefined) {
-            const local = PushLocal(`new RegExp(/${schema.pattern}/);`);
+            const local = PushLocal(`${new RegExp(schema.pattern)};`);
             yield `(${local}.test(${value}))`;
         }
         if (schema.format !== undefined) {

package/errors/errors.js

@@ -143,6 +143,9 @@ var ValueErrors;
         if (!(value instanceof globalThis.Date)) {
             return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` };
         }
+        if (isNaN(value.getTime())) {
+            return yield { type: ValueErrorType.Date, schema, path, value, message: `Invalid Date` };
+        }
         if (IsNumber(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
             yield { type: ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` };
         }

package/package.json

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

package/value/cast.js

@@ -127,6 +127,9 @@ var ValueCast;
     function IsArray(value) {
         return typeof value === 'object' && globalThis.Array.isArray(value);
     }
+    function IsDate(value) {
+        return typeof value === 'object' && value instanceof globalThis.Date;
+    }
     function IsString(value) {
         return typeof value === 'string';
     }
@@ -151,6 +154,21 @@ var ValueCast;
     function IsValueFalse(value) {
         return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === globalThis.BigInt('0')) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'));
     }
+    function IsTimeStringWithTimeZone(value) {
+        return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    }
+    function IsTimeStringWithoutTimeZone(value) {
+        return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    }
+    function IsDateTimeStringWithTimeZone(value) {
+        return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    }
+    function IsDateTimeStringWithoutTimeZone(value) {
+        return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    }
+    function IsDateString(value) {
+        return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
+    }
     // ----------------------------------------------------------------------------------------------
     // Convert
     // ----------------------------------------------------------------------------------------------
@@ -166,6 +184,31 @@ var ValueCast;
     function TryConvertBoolean(value) {
         return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
     }
+    function TryConvertDate(value) {
+        // note: this function may return an invalid dates for the regex tests
+        // above. Invalid dates will however be checked during the casting
+        // function and will return a epoch date if invalid. Consider better
+        // string parsing for the iso dates in future revisions.
+        return IsDate(value)
+            ? value
+            : IsNumber(value)
+                ? new globalThis.Date(value)
+                : IsValueTrue(value)
+                    ? new globalThis.Date(1)
+                    : IsStringNumeric(value)
+                        ? new globalThis.Date(parseInt(value))
+                        : IsTimeStringWithoutTimeZone(value)
+                            ? new globalThis.Date(`1970-01-01T${value}.000Z`)
+                            : IsTimeStringWithTimeZone(value)
+                                ? new globalThis.Date(`1970-01-01T${value}`)
+                                : IsDateTimeStringWithoutTimeZone(value)
+                                    ? new globalThis.Date(`${value}.000Z`)
+                                    : IsDateTimeStringWithTimeZone(value)
+                                        ? new globalThis.Date(value)
+                                        : IsDateString(value)
+                                            ? new globalThis.Date(`${value}T00:00:00.000Z`)
+                                            : value;
+    }
     // ----------------------------------------------------------------------------------------------
     // Cast
     // ----------------------------------------------------------------------------------------------
@@ -203,7 +246,8 @@ var ValueCast;
         return result;
     }
     function Date(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+        const conversion = TryConvertDate(value);
+        return check_1.ValueCheck.Check(schema, references, conversion) ? clone_1.ValueClone.Clone(conversion) : create_1.ValueCreate.Create(schema, references);
     }
     function Function(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);

package/value/check.js

@@ -82,6 +82,9 @@ var ValueCheck;
         if (!(value instanceof globalThis.Date)) {
             return false;
         }
+        if (isNaN(value.getTime())) {
+            return false;
+        }
         if (IsNumber(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
             return false;
         }

package/value/value.d.ts

@@ -3,9 +3,9 @@ import { ValueError } from '../errors/index';
 import { Edit } from './delta';
 /** Provides functions to perform structural updates to JavaScript values */
 export declare namespace Value {
-    /** 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. */
+    /** 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, boolean and date 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 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. */
+    /** 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, boolean and date values if a reasonable conversion is possible. */
     function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>;
     /** Creates a value from the given type */
     function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>;