@sinclair/typebox 0.24.23 → 0.24.24

package/compiler/compiler.d.ts

@@ -1,4 +1,4 @@
-import { ValueError } from '../error/errors';
+import { ValueError } from '../errors/index';
 import * as Types from '../typebox';
 export declare type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends Types.TSchema> {
@@ -14,6 +14,13 @@ export declare class TypeCheck<T extends Types.TSchema> {
     /** Returns true if the value matches the given type. */
     Check(value: unknown): value is Types.Static<T>;
 }
+export declare namespace Property {
+    function Check(propertyName: string): boolean;
+}
+export declare class TypeCompilerInvalidTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 /** Compiles Types for Runtime Type Checking */
 export declare namespace TypeCompiler {
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */

package/compiler/compiler.js

@@ -27,10 +27,9 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompiler = exports.TypeCheck = void 0;
-const errors_1 = require("../error/errors");
-const property_1 = require("./property");
-const Types = require("../typebox");
+exports.TypeCompiler = exports.TypeCompilerInvalidTypeError = exports.Property = exports.TypeCheck = void 0;
+const index_1 = require("../errors/index");
+const index_2 = require("../guard/index");
 // -------------------------------------------------------------------
 // TypeCheck
 // -------------------------------------------------------------------
@@ -47,7 +46,7 @@ class TypeCheck {
     }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
-        return errors_1.ValueErrors.Errors(this.schema, this.references, value);
+        return index_1.ValueErrors.Errors(this.schema, this.references, value);
     }
     /** Returns true if the value matches the given type. */
     Check(value) {
@@ -56,8 +55,60 @@ class TypeCheck {
 }
 exports.TypeCheck = TypeCheck;
 // -------------------------------------------------------------------
+// Property
+// -------------------------------------------------------------------
+var Property;
+(function (Property) {
+    function DollarSign(code) {
+        return code === 36;
+    }
+    function Underscore(code) {
+        return code === 95;
+    }
+    function Numeric(code) {
+        return code >= 48 && code <= 57;
+    }
+    function Alpha(code) {
+        return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+    }
+    function AssertEscapeCharacters(propertyName) {
+        for (let i = 0; i < propertyName.length; i++) {
+            const code = propertyName.charCodeAt(i);
+            if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
+                throw Error('Property: Invalid escape character found in property key');
+            }
+        }
+    }
+    function Check(propertyName) {
+        AssertEscapeCharacters(propertyName);
+        if (propertyName.length === 0)
+            return false;
+        {
+            const code = propertyName.charCodeAt(0);
+            if (!(DollarSign(code) || Underscore(code) || Alpha(code))) {
+                return false;
+            }
+        }
+        for (let i = 1; i < propertyName.length; i++) {
+            const code = propertyName.charCodeAt(i);
+            if (!(DollarSign(code) || Underscore(code) || Alpha(code) || Numeric(code))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    Property.Check = Check;
+})(Property = exports.Property || (exports.Property = {}));
+// -------------------------------------------------------------------
 // TypeCompiler
 // -------------------------------------------------------------------
+class TypeCompilerInvalidTypeError extends Error {
+    constructor(schema) {
+        super('TypeCompiler: Invalid type');
+        this.schema = schema;
+    }
+}
+exports.TypeCompilerInvalidTypeError = TypeCompilerInvalidTypeError;
 /** Compiles Types for Runtime Type Checking */
 var TypeCompiler;
 (function (TypeCompiler) {
@@ -100,11 +151,14 @@ var TypeCompiler;
             yield `(${value} <= ${schema.maximum})`;
     }
     function* Literal(schema, value) {
-        if (typeof schema.const === 'string') {
+        if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
+            yield `(${value} === ${schema.const})`;
+        }
+        else if (typeof schema.const === 'string') {
             yield `(${value} === '${schema.const}')`;
         }
         else {
-            yield `(${value} === ${schema.const})`;
+            throw Error('TypeCompiler: Literal value should be string, number or boolean');
         }
     }
     function* Null(schema, value) {
@@ -144,7 +198,7 @@ var TypeCompiler;
             }
         }
         for (const propertyKey of propertyKeys) {
-            const memberExpression = property_1.Property.Check(propertyKey) ? `${value}.${propertyKey}` : `${value}['${propertyKey}']`;
+            const memberExpression = Property.Check(propertyKey) ? `${value}.${propertyKey}` : `${value}['${propertyKey}']`;
             const propertySchema = schema.properties[propertyKey];
             if (schema.required && schema.required.includes(propertyKey)) {
                 yield* Visit(propertySchema, memberExpression);
@@ -231,52 +285,71 @@ var TypeCompiler;
             yield `(${name}(${value}))`;
             return;
         }
-        const anySchema = schema;
-        switch (anySchema[Types.Kind]) {
-            case 'Any':
-                return yield* Any(anySchema, value);
-            case 'Array':
-                return yield* Array(anySchema, value);
-            case 'Boolean':
-                return yield* Boolean(anySchema, value);
-            case 'Constructor':
-                return yield* Constructor(anySchema, value);
-            case 'Function':
-                return yield* Function(anySchema, value);
-            case 'Integer':
-                return yield* Integer(anySchema, value);
-            case 'Literal':
-                return yield* Literal(anySchema, value);
-            case 'Null':
-                return yield* Null(anySchema, value);
-            case 'Number':
-                return yield* Number(anySchema, value);
-            case 'Object':
-                return yield* Object(anySchema, value);
-            case 'Promise':
-                return yield* Promise(anySchema, value);
-            case 'Record':
-                return yield* Record(anySchema, value);
-            case 'Ref':
-                return yield* Ref(anySchema, value);
-            case 'Self':
-                return yield* Self(anySchema, value);
-            case 'String':
-                return yield* String(anySchema, value);
-            case 'Tuple':
-                return yield* Tuple(anySchema, value);
-            case 'Undefined':
-                return yield* Undefined(anySchema, value);
-            case 'Union':
-                return yield* Union(anySchema, value);
-            case 'Uint8Array':
-                return yield* Uint8Array(anySchema, value);
-            case 'Unknown':
-                return yield* Unknown(anySchema, value);
-            case 'Void':
-                return yield* Void(anySchema, value);
-            default:
-                throw new Error(`TypeCompiler: Unknown schema kind '${schema[Types.Kind]}'`);
+        if (index_2.TypeGuard.TAny(schema)) {
+            return yield* Any(schema, value);
+        }
+        else if (index_2.TypeGuard.TArray(schema)) {
+            return yield* Array(schema, value);
+        }
+        else if (index_2.TypeGuard.TBoolean(schema)) {
+            return yield* Boolean(schema, value);
+        }
+        else if (index_2.TypeGuard.TConstructor(schema)) {
+            return yield* Constructor(schema, value);
+        }
+        else if (index_2.TypeGuard.TFunction(schema)) {
+            return yield* Function(schema, value);
+        }
+        else if (index_2.TypeGuard.TInteger(schema)) {
+            return yield* Integer(schema, value);
+        }
+        else if (index_2.TypeGuard.TLiteral(schema)) {
+            return yield* Literal(schema, value);
+        }
+        else if (index_2.TypeGuard.TNull(schema)) {
+            return yield* Null(schema, value);
+        }
+        else if (index_2.TypeGuard.TNumber(schema)) {
+            return yield* Number(schema, value);
+        }
+        else if (index_2.TypeGuard.TObject(schema)) {
+            return yield* Object(schema, value);
+        }
+        else if (index_2.TypeGuard.TPromise(schema)) {
+            return yield* Promise(schema, value);
+        }
+        else if (index_2.TypeGuard.TRecord(schema)) {
+            return yield* Record(schema, value);
+        }
+        else if (index_2.TypeGuard.TRef(schema)) {
+            return yield* Ref(schema, value);
+        }
+        else if (index_2.TypeGuard.TSelf(schema)) {
+            return yield* Self(schema, value);
+        }
+        else if (index_2.TypeGuard.TString(schema)) {
+            return yield* String(schema, value);
+        }
+        else if (index_2.TypeGuard.TTuple(schema)) {
+            return yield* Tuple(schema, value);
+        }
+        else if (index_2.TypeGuard.TUndefined(schema)) {
+            return yield* Undefined(schema, value);
+        }
+        else if (index_2.TypeGuard.TUnion(schema)) {
+            return yield* Union(schema, value);
+        }
+        else if (index_2.TypeGuard.TUint8Array(schema)) {
+            return yield* Uint8Array(schema, value);
+        }
+        else if (index_2.TypeGuard.TUnknown(schema)) {
+            return yield* Unknown(schema, value);
+        }
+        else if (index_2.TypeGuard.TVoid(schema)) {
+            return yield* Void(schema, value);
+        }
+        else {
+            throw new TypeCompilerInvalidTypeError(schema);
         }
     }
     // -------------------------------------------------------------------

package/compiler/index.d.ts

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

package/compiler/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("./compiler"), exports);

package/{error → errors}/errors.d.ts

@@ -47,6 +47,10 @@ export interface ValueError {
     value: unknown;
     message: string;
 }
+export declare class ValueErrorsInvalidTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare namespace ValueErrors {
     function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): IterableIterator<ValueError>;
 }

package/{error → errors}/errors.js

@@ -1,7 +1,7 @@
 "use strict";
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/value
+@sinclair/typebox/errors
 
 The MIT License (MIT)
 
@@ -27,8 +27,8 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueErrors = exports.ValueErrorType = void 0;
-const Types = require("../typebox");
+exports.ValueErrors = exports.ValueErrorsInvalidTypeError = exports.ValueErrorType = void 0;
+const index_1 = require("../guard/index");
 // -------------------------------------------------------------------
 // ValueErrorType
 // -------------------------------------------------------------------
@@ -77,6 +77,13 @@ var ValueErrorType;
 // -------------------------------------------------------------------
 // ValueErrors
 // -------------------------------------------------------------------
+class ValueErrorsInvalidTypeError extends Error {
+    constructor(schema) {
+        super('ValueErrors: Invalid type');
+        this.schema = schema;
+    }
+}
+exports.ValueErrorsInvalidTypeError = ValueErrorsInvalidTypeError;
 var ValueErrors;
 (function (ValueErrors) {
     function* Any(schema, references, path, value) { }
@@ -299,53 +306,72 @@ var ValueErrors;
         }
     }
     function* Visit(schema, references, path, value) {
-        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
-        const anySchema = schema;
-        switch (anySchema[Types.Kind]) {
-            case 'Any':
-                return yield* Any(anySchema, anyReferences, path, value);
-            case 'Array':
-                return yield* Array(anySchema, anyReferences, path, value);
-            case 'Boolean':
-                return yield* Boolean(anySchema, anyReferences, path, value);
-            case 'Constructor':
-                return yield* Constructor(anySchema, anyReferences, path, value);
-            case 'Function':
-                return yield* Function(anySchema, anyReferences, path, value);
-            case 'Integer':
-                return yield* Integer(anySchema, anyReferences, path, value);
-            case 'Literal':
-                return yield* Literal(anySchema, anyReferences, path, value);
-            case 'Null':
-                return yield* Null(anySchema, anyReferences, path, value);
-            case 'Number':
-                return yield* Number(anySchema, anyReferences, path, value);
-            case 'Object':
-                return yield* Object(anySchema, anyReferences, path, value);
-            case 'Promise':
-                return yield* Promise(anySchema, anyReferences, path, value);
-            case 'Record':
-                return yield* Record(anySchema, anyReferences, path, value);
-            case 'Ref':
-                return yield* Ref(anySchema, anyReferences, path, value);
-            case 'Self':
-                return yield* Self(anySchema, anyReferences, path, value);
-            case 'String':
-                return yield* String(anySchema, anyReferences, path, value);
-            case 'Tuple':
-                return yield* Tuple(anySchema, anyReferences, path, value);
-            case 'Undefined':
-                return yield* Undefined(anySchema, anyReferences, path, value);
-            case 'Union':
-                return yield* Union(anySchema, anyReferences, path, value);
-            case 'Uint8Array':
-                return yield* Uint8Array(anySchema, anyReferences, path, value);
-            case 'Unknown':
-                return yield* Unknown(anySchema, anyReferences, path, value);
-            case 'Void':
-                return yield* Void(anySchema, anyReferences, path, value);
-            default:
-                throw new Error(`ValueErrors: Unknown schema kind '${schema[Types.Kind]}'`);
+        const refs = schema.$id === undefined ? references : [schema, ...references];
+        if (index_1.TypeGuard.TAny(schema)) {
+            return yield* Any(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TArray(schema)) {
+            return yield* Array(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TBoolean(schema)) {
+            return yield* Boolean(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TConstructor(schema)) {
+            return yield* Constructor(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TFunction(schema)) {
+            return yield* Function(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TInteger(schema)) {
+            return yield* Integer(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TLiteral(schema)) {
+            return yield* Literal(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TNull(schema)) {
+            return yield* Null(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TNumber(schema)) {
+            return yield* Number(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TObject(schema)) {
+            return yield* Object(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TPromise(schema)) {
+            return yield* Promise(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TRecord(schema)) {
+            return yield* Record(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TRef(schema)) {
+            return yield* Ref(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TSelf(schema)) {
+            return yield* Self(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TString(schema)) {
+            return yield* String(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TTuple(schema)) {
+            return yield* Tuple(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TUndefined(schema)) {
+            return yield* Undefined(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TUnion(schema)) {
+            return yield* Union(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TUint8Array(schema)) {
+            return yield* Uint8Array(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TUnknown(schema)) {
+            return yield* Unknown(schema, refs, path, value);
+        }
+        else if (index_1.TypeGuard.TVoid(schema)) {
+            return yield* Void(schema, refs, path, value);
+        }
+        else {
+            throw new ValueErrorsInvalidTypeError(schema);
         }
     }
     function* Errors(schema, references, value) {

package/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './errors';

package/{compiler/property.js → errors/index.js}

@@ -1,7 +1,7 @@
 "use strict";
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/compiler
+@sinclair/typebox/errors
 
 The MIT License (MIT)
 
@@ -26,39 +26,19 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Property = void 0;
-var Property;
-(function (Property) {
-    function DollarSign(char) {
-        return char === 36;
-    }
-    function Underscore(char) {
-        return char === 95;
-    }
-    function Numeric(char) {
-        return char >= 48 && char <= 57;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    function Alpha(char) {
-        return (char >= 65 && char <= 90) || (char >= 97 && char <= 122);
-    }
-    /** Tests if this property name can be used in a member expression */
-    function Check(propertyName) {
-        if (propertyName.length === 0)
-            return false;
-        {
-            const code = propertyName.charCodeAt(0);
-            if (!(DollarSign(code) || Underscore(code) || Alpha(code))) {
-                return false;
-            }
-        }
-        for (let i = 1; i < propertyName.length; i++) {
-            const code = propertyName.charCodeAt(i);
-            if (!(DollarSign(code) || Underscore(code) || Alpha(code) || Numeric(code))) {
-                return false;
-            }
-        }
-        return true;
-    }
-    Property.Check = Check;
-})(Property = exports.Property || (exports.Property = {}));
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./errors"), exports);