@sinclair/typebox 0.24.22 → 0.24.25

package/compiler/compiler.d.ts

@@ -1,4 +1,4 @@
-import { ValueError } from '../value/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("../value/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 type { ValueError } from '../value/errors';
+export { ValueError, ValueErrorType } from '../errors/index';
 export * from './compiler';

package/compiler/index.js

@@ -41,4 +41,7 @@ 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 });
+exports.ValueErrorType = void 0;
+var index_1 = require("../errors/index");
+Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
 __exportStar(require("./compiler"), exports);

package/errors/errors.d.ts

@@ -0,0 +1,56 @@
+import * as Types from '../typebox';
+export declare enum ValueErrorType {
+    Array = 0,
+    ArrayMinItems = 1,
+    ArrayMaxItems = 2,
+    ArrayUniqueItems = 3,
+    Boolean = 4,
+    Function = 5,
+    Integer = 6,
+    IntegerMultipleOf = 7,
+    IntegerExclusiveMinimum = 8,
+    IntegerExclusiveMaximum = 9,
+    IntegerMinimum = 10,
+    IntegerMaximum = 11,
+    Literal = 12,
+    Null = 13,
+    Number = 14,
+    NumberMultipleOf = 15,
+    NumberExclusiveMinimum = 16,
+    NumberExclusiveMaximum = 17,
+    NumberMinumum = 18,
+    NumberMaximum = 19,
+    Object = 20,
+    ObjectMinProperties = 21,
+    ObjectMaxProperties = 22,
+    ObjectAdditionalProperties = 23,
+    Promise = 24,
+    RecordKeyNumeric = 25,
+    RecordKeyString = 26,
+    String = 27,
+    StringMinLength = 28,
+    StringMaxLength = 29,
+    StringPattern = 30,
+    TupleZeroLength = 31,
+    TupleLength = 32,
+    Undefined = 33,
+    Union = 34,
+    Uint8Array = 35,
+    Uint8ArrayMinByteLength = 36,
+    Uint8ArrayMaxByteLength = 37,
+    Void = 38
+}
+export interface ValueError {
+    type: ValueErrorType;
+    schema: Types.TSchema;
+    path: string;
+    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>;
+}