@sinclair/typebox 0.24.23 → 0.24.24

package/value/check.js

@@ -27,8 +27,15 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCheck = void 0;
-const Types = require("../typebox");
+exports.ValueCheck = exports.ValueCheckInvalidTypeError = void 0;
+const index_1 = require("../guard/index");
+class ValueCheckInvalidTypeError extends Error {
+    constructor(schema) {
+        super('ValueCheck: Invalid type');
+        this.schema = schema;
+    }
+}
+exports.ValueCheckInvalidTypeError = ValueCheckInvalidTypeError;
 var ValueCheck;
 (function (ValueCheck) {
     function Any(schema, references, value) {
@@ -244,53 +251,72 @@ var ValueCheck;
         return value === null;
     }
     function Visit(schema, references, value) {
-        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 Error(`ValueCheck: Unknown schema kind '${schema[Types.Kind]}'`);
+        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);
         }
     }
     // -------------------------------------------------------------------------

package/value/create.d.ts

@@ -1,4 +1,8 @@
 import * as Types from '../typebox';
+export declare class ValueCreateInvalidTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare namespace ValueCreate {
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
     function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>;

package/value/create.js

@@ -27,8 +27,15 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = void 0;
-const Types = require("../typebox");
+exports.ValueCreate = exports.ValueCreateInvalidTypeError = void 0;
+const index_1 = require("../guard/index");
+class ValueCreateInvalidTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Invalid type');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateInvalidTypeError = ValueCreateInvalidTypeError;
 var ValueCreate;
 (function (ValueCreate) {
     function Any(schema, references) {
@@ -269,57 +276,72 @@ 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 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 Error(`ValueCreate.Visit: Unknown schema kind '${schema[Types.Kind]}'`);
+        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);
         }
     }
     ValueCreate.Visit = Visit;

package/value/index.d.ts

@@ -1,2 +1,2 @@
-export { ValueError, ValueErrorType } from '../error/errors';
+export { ValueError, ValueErrorType } from '../errors/errors';
 export * from './value';

package/value/index.js

@@ -42,6 +42,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueErrorType = void 0;
-var errors_1 = require("../error/errors");
+var errors_1 = require("../errors/errors");
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return errors_1.ValueErrorType; } });
 __exportStar(require("./value"), exports);

package/value/value.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-import { ValueError } from '../error/errors';
+import { ValueError } from '../errors/index';
 /** Creates Values from TypeBox Types */
 export declare namespace Value {
     /** Creates a value from the given type */

package/value/value.js

@@ -28,7 +28,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Value = void 0;
-const errors_1 = require("../error/errors");
+const index_1 = require("../errors/index");
 const cast_1 = require("./cast");
 const create_1 = require("./create");
 const check_1 = require("./check");
@@ -52,7 +52,7 @@ var Value;
     Value.Cast = Cast;
     function* Errors(...args) {
         const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
-        yield* errors_1.ValueErrors.Errors(schema, references, value);
+        yield* index_1.ValueErrors.Errors(schema, references, value);
     }
     Value.Errors = Errors;
 })(Value = exports.Value || (exports.Value = {}));

package/compiler/property.d.ts

@@ -1,4 +0,0 @@
-export declare namespace Property {
-    /** Tests if this property name can be used in a member expression */
-    function Check(propertyName: string): boolean;
-}