@sinclair/typebox 0.24.26 → 0.24.29

package/value/check.js

@@ -27,15 +27,16 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCheck = exports.ValueCheckInvalidTypeError = void 0;
-const index_1 = require("../guard/index");
-class ValueCheckInvalidTypeError extends Error {
+exports.ValueCheck = exports.ValueCheckUnknownTypeError = void 0;
+const Types = require("../typebox");
+const format_1 = require("../format");
+class ValueCheckUnknownTypeError extends Error {
     constructor(schema) {
-        super('ValueCheck: Invalid type');
+        super('ValueCheck: Unknown type');
         this.schema = schema;
     }
 }
-exports.ValueCheckInvalidTypeError = ValueCheckInvalidTypeError;
+exports.ValueCheckUnknownTypeError = ValueCheckUnknownTypeError;
 var ValueCheck;
 (function (ValueCheck) {
     function Any(schema, references, value) {
@@ -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) {
@@ -251,72 +258,53 @@ var ValueCheck;
         return value === null;
     }
     function Visit(schema, references, value) {
-        const refs = schema.$id === undefined ? references : [schema, ...references];
-        if (index_1.TypeGuard.TAny(schema)) {
-            return Any(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TArray(schema)) {
-            return Array(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TBoolean(schema)) {
-            return Boolean(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TConstructor(schema)) {
-            return Constructor(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TFunction(schema)) {
-            return Function(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TInteger(schema)) {
-            return Integer(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TLiteral(schema)) {
-            return Literal(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TNull(schema)) {
-            return Null(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TNumber(schema)) {
-            return Number(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TObject(schema)) {
-            return Object(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TPromise(schema)) {
-            return Promise(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TRecord(schema)) {
-            return Record(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TRef(schema)) {
-            return Ref(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TSelf(schema)) {
-            return Self(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TString(schema)) {
-            return String(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TTuple(schema)) {
-            return Tuple(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TUndefined(schema)) {
-            return Undefined(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TUnion(schema)) {
-            return Union(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TUint8Array(schema)) {
-            return Uint8Array(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TUnknown(schema)) {
-            return Unknown(schema, refs, value);
-        }
-        else if (index_1.TypeGuard.TVoid(schema)) {
-            return Void(schema, refs, value);
-        }
-        else {
-            throw new ValueCheckInvalidTypeError(schema);
+        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
+        const anySchema = schema;
+        switch (anySchema[Types.Kind]) {
+            case 'Any':
+                return Any(anySchema, anyReferences, value);
+            case 'Array':
+                return Array(anySchema, anyReferences, value);
+            case 'Boolean':
+                return Boolean(anySchema, anyReferences, value);
+            case 'Constructor':
+                return Constructor(anySchema, anyReferences, value);
+            case 'Function':
+                return Function(anySchema, anyReferences, value);
+            case 'Integer':
+                return Integer(anySchema, anyReferences, value);
+            case 'Literal':
+                return Literal(anySchema, anyReferences, value);
+            case 'Null':
+                return Null(anySchema, anyReferences, value);
+            case 'Number':
+                return Number(anySchema, anyReferences, value);
+            case 'Object':
+                return Object(anySchema, anyReferences, value);
+            case 'Promise':
+                return Promise(anySchema, anyReferences, value);
+            case 'Record':
+                return Record(anySchema, anyReferences, value);
+            case 'Ref':
+                return Ref(anySchema, anyReferences, value);
+            case 'Self':
+                return Self(anySchema, anyReferences, value);
+            case 'String':
+                return String(anySchema, anyReferences, value);
+            case 'Tuple':
+                return Tuple(anySchema, anyReferences, value);
+            case 'Undefined':
+                return Undefined(anySchema, anyReferences, value);
+            case 'Union':
+                return Union(anySchema, anyReferences, value);
+            case 'Uint8Array':
+                return Uint8Array(anySchema, anyReferences, value);
+            case 'Unknown':
+                return Unknown(anySchema, anyReferences, value);
+            case 'Void':
+                return Void(anySchema, anyReferences, value);
+            default:
+                throw new ValueCheckUnknownTypeError(anySchema);
         }
     }
     // -------------------------------------------------------------------------

package/value/create.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-export declare class ValueCreateInvalidTypeError extends Error {
+export declare class ValueCreateUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }

package/value/create.js

@@ -27,15 +27,15 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = exports.ValueCreateInvalidTypeError = void 0;
-const index_1 = require("../guard/index");
-class ValueCreateInvalidTypeError extends Error {
+exports.ValueCreate = exports.ValueCreateUnknownTypeError = void 0;
+const Types = require("../typebox");
+class ValueCreateUnknownTypeError extends Error {
     constructor(schema) {
-        super('ValueCreate: Invalid type');
+        super('ValueCreate: Unknown type');
         this.schema = schema;
     }
 }
-exports.ValueCreateInvalidTypeError = ValueCreateInvalidTypeError;
+exports.ValueCreateUnknownTypeError = ValueCreateUnknownTypeError;
 var ValueCreate;
 (function (ValueCreate) {
     function Any(schema, references) {
@@ -276,72 +276,57 @@ var ValueCreate;
     }
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
     function Visit(schema, references) {
-        const refs = schema.$id === undefined ? references : [schema, ...references];
-        if (index_1.TypeGuard.TAny(schema)) {
-            return Any(schema, refs);
-        }
-        else if (index_1.TypeGuard.TArray(schema)) {
-            return Array(schema, refs);
-        }
-        else if (index_1.TypeGuard.TBoolean(schema)) {
-            return Boolean(schema, refs);
-        }
-        else if (index_1.TypeGuard.TConstructor(schema)) {
-            return Constructor(schema, refs);
-        }
-        else if (index_1.TypeGuard.TFunction(schema)) {
-            return Function(schema, refs);
-        }
-        else if (index_1.TypeGuard.TInteger(schema)) {
-            return Integer(schema, refs);
-        }
-        else if (index_1.TypeGuard.TLiteral(schema)) {
-            return Literal(schema, refs);
-        }
-        else if (index_1.TypeGuard.TNull(schema)) {
-            return Null(schema, refs);
-        }
-        else if (index_1.TypeGuard.TNumber(schema)) {
-            return Number(schema, refs);
-        }
-        else if (index_1.TypeGuard.TObject(schema)) {
-            return Object(schema, refs);
-        }
-        else if (index_1.TypeGuard.TPromise(schema)) {
-            return Promise(schema, refs);
-        }
-        else if (index_1.TypeGuard.TRecord(schema)) {
-            return Record(schema, refs);
-        }
-        else if (index_1.TypeGuard.TRef(schema)) {
-            return Ref(schema, refs);
-        }
-        else if (index_1.TypeGuard.TSelf(schema)) {
-            return Self(schema, refs);
-        }
-        else if (index_1.TypeGuard.TString(schema)) {
-            return String(schema, refs);
-        }
-        else if (index_1.TypeGuard.TTuple(schema)) {
-            return Tuple(schema, refs);
-        }
-        else if (index_1.TypeGuard.TUndefined(schema)) {
-            return Undefined(schema, refs);
-        }
-        else if (index_1.TypeGuard.TUnion(schema)) {
-            return Union(schema, refs);
-        }
-        else if (index_1.TypeGuard.TUint8Array(schema)) {
-            return Uint8Array(schema, refs);
-        }
-        else if (index_1.TypeGuard.TUnknown(schema)) {
-            return Unknown(schema, refs);
-        }
-        else if (index_1.TypeGuard.TVoid(schema)) {
-            return Void(schema, refs);
-        }
-        else {
-            throw new ValueCreateInvalidTypeError(schema);
+        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
+        const anySchema = schema;
+        switch (anySchema[Types.Kind]) {
+            case 'Any':
+                return Any(anySchema, anyReferences);
+            case 'Array':
+                return Array(anySchema, anyReferences);
+            case 'Boolean':
+                return Boolean(anySchema, anyReferences);
+            case 'Constructor':
+                return Constructor(anySchema, anyReferences);
+            case 'Enum':
+                return Enum(anySchema, anyReferences);
+            case 'Function':
+                return Function(anySchema, anyReferences);
+            case 'Integer':
+                return Integer(anySchema, anyReferences);
+            case 'Literal':
+                return Literal(anySchema, anyReferences);
+            case 'Null':
+                return Null(anySchema, anyReferences);
+            case 'Number':
+                return Number(anySchema, anyReferences);
+            case 'Object':
+                return Object(anySchema, anyReferences);
+            case 'Promise':
+                return Promise(anySchema, anyReferences);
+            case 'Record':
+                return Record(anySchema, anyReferences);
+            case 'Rec':
+                return Recursive(anySchema, anyReferences);
+            case 'Ref':
+                return Ref(anySchema, anyReferences);
+            case 'Self':
+                return Self(anySchema, anyReferences);
+            case 'String':
+                return String(anySchema, anyReferences);
+            case 'Tuple':
+                return Tuple(anySchema, anyReferences);
+            case 'Undefined':
+                return Undefined(anySchema, anyReferences);
+            case 'Union':
+                return Union(anySchema, anyReferences);
+            case 'Uint8Array':
+                return Uint8Array(anySchema, anyReferences);
+            case 'Unknown':
+                return Unknown(anySchema, anyReferences);
+            case 'Void':
+                return Void(anySchema, anyReferences);
+            default:
+                throw new ValueCreateUnknownTypeError(anySchema);
         }
     }
     ValueCreate.Visit = Visit;

package/value/value.d.ts

@@ -6,9 +6,9 @@ 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. */
     function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>;