@sinclair/typebox 0.24.25 → 0.24.28

package/compiler/compiler.d.ts

@@ -17,7 +17,7 @@ export declare class TypeCheck<T extends Types.TSchema> {
 export declare namespace Property {
     function Check(propertyName: string): boolean;
 }
-export declare class TypeCompilerInvalidTypeError extends Error {
+export declare class TypeCompilerUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }

package/compiler/compiler.js

@@ -27,9 +27,10 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompiler = exports.TypeCompilerInvalidTypeError = exports.Property = exports.TypeCheck = void 0;
+exports.TypeCompiler = exports.TypeCompilerUnknownTypeError = exports.Property = exports.TypeCheck = void 0;
 const index_1 = require("../errors/index");
 const index_2 = require("../guard/index");
+const Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
 // -------------------------------------------------------------------
@@ -71,16 +72,7 @@ var Property;
     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;
         {
@@ -102,13 +94,13 @@ var Property;
 // -------------------------------------------------------------------
 // TypeCompiler
 // -------------------------------------------------------------------
-class TypeCompilerInvalidTypeError extends Error {
+class TypeCompilerUnknownTypeError extends Error {
     constructor(schema) {
-        super('TypeCompiler: Invalid type');
+        super('TypeCompiler: Unknown type');
         this.schema = schema;
     }
 }
-exports.TypeCompilerInvalidTypeError = TypeCompilerInvalidTypeError;
+exports.TypeCompilerUnknownTypeError = TypeCompilerUnknownTypeError;
 /** Compiles Types for Runtime Type Checking */
 var TypeCompiler;
 (function (TypeCompiler) {
@@ -132,7 +124,7 @@ var TypeCompiler;
         yield `(typeof ${value} === 'boolean')`;
     }
     function* Constructor(schema, value) {
-        yield* Visit(schema.returns, value);
+        yield* Visit(schema.returns, `${value}.prototype`);
     }
     function* Function(schema, value) {
         yield `(typeof ${value} === 'function')`;
@@ -154,11 +146,8 @@ var TypeCompiler;
         if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
             yield `(${value} === ${schema.const})`;
         }
-        else if (typeof schema.const === 'string') {
-            yield `(${value} === '${schema.const}')`;
-        }
         else {
-            throw Error('TypeCompiler: Literal value should be string, number or boolean');
+            yield `(${value} === '${schema.const}')`;
         }
     }
     function* Null(schema, value) {
@@ -185,7 +174,7 @@ var TypeCompiler;
             yield `(Object.keys(${value}).length <= ${schema.maxProperties})`;
         const propertyKeys = globalThis.Object.keys(schema.properties);
         if (schema.additionalProperties === false) {
-            // optimization: If the property key length matches the required keys length
+            // Optimization: If the property key length matches the required keys length
             // then we only need check that the values property key length matches that
             // of the property key length. This is because exhaustive testing for values
             // will occur in subsequent property tests.
@@ -221,6 +210,11 @@ var TypeCompiler;
         yield `(Object.values(${value}).every(value => ${expression}))`;
     }
     function* Ref(schema, value) {
+        // Reference: If we have seen this reference before we can just yield and return
+        // the function call. If this isn't the case we defer to visit to generate and
+        // set the function for subsequent passes. Consider for refactor.
+        if (names.has(schema.$ref))
+            return yield `(${CreateFunctionName(schema.$ref)}(${value}))`;
         if (!referenceMap.has(schema.$ref))
             throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`);
         const reference = referenceMap.get(schema.$ref);
@@ -274,9 +268,9 @@ var TypeCompiler;
         yield `(${value} === null)`;
     }
     function* Visit(schema, value) {
-        // reference: referenced schemas can originate from either additional
-        // schemas or inline in the schema itself. Ideally the recursive
-        // path should align to reference path. Consider for review.
+        // Reference: Referenced schemas can originate from either additional schemas
+        // or inline in the schema itself. Ideally the recursive path should align to
+        // reference path. Consider for refactor.
         if (schema.$id && !names.has(schema.$id)) {
             names.add(schema.$id);
             const name = CreateFunctionName(schema.$id);
@@ -285,71 +279,52 @@ var TypeCompiler;
             yield `(${name}(${value}))`;
             return;
         }
-        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);
+        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 TypeCompilerUnknownTypeError(schema);
         }
     }
     // -------------------------------------------------------------------
@@ -405,6 +380,7 @@ var TypeCompiler;
     }
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile(schema, references = []) {
+        index_2.TypeGuard.Assert(schema, references);
         const code = Build(schema, references);
         const func = globalThis.Function(code);
         return new TypeCheck(schema, references, func(), code);

package/conditional/conditional.js

@@ -30,7 +30,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Conditional = void 0;
 const Types = require("../typebox");
 const structural_1 = require("./structural");
-const guard_1 = require("../guard");
+const index_1 = require("../guard/index");
 /** Conditional Types */
 var Conditional;
 (function (Conditional) {
@@ -59,7 +59,7 @@ var Conditional;
     Conditional.Exclude = Exclude;
     /** (Experimental) Constructs a type by extracting from Type all union members that are assignable to Union. */
     function Extract(type, union, options = {}) {
-        if (guard_1.TypeGuard.TUnion(type)) {
+        if (index_1.TypeGuard.TUnion(type)) {
             const anyOf = type.anyOf.filter((schema) => structural_1.Structural.Check(schema, union) === structural_1.StructuralResult.True).map((schema) => Clone(schema));
             return { ...options, [Types.Kind]: 'Union', anyOf };
         }

package/errors/errors.d.ts

@@ -47,7 +47,7 @@ export interface ValueError {
     value: unknown;
     message: string;
 }
-export declare class ValueErrorsInvalidTypeError extends Error {
+export declare class ValueErrorsUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }

package/errors/errors.js

@@ -27,8 +27,8 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueErrors = exports.ValueErrorsInvalidTypeError = exports.ValueErrorType = void 0;
-const index_1 = require("../guard/index");
+exports.ValueErrors = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
+const Types = require("../typebox");
 // -------------------------------------------------------------------
 // ValueErrorType
 // -------------------------------------------------------------------
@@ -77,13 +77,13 @@ var ValueErrorType;
 // -------------------------------------------------------------------
 // ValueErrors
 // -------------------------------------------------------------------
-class ValueErrorsInvalidTypeError extends Error {
+class ValueErrorsUnknownTypeError extends Error {
     constructor(schema) {
-        super('ValueErrors: Invalid type');
+        super('ValueErrors: Unknown type');
         this.schema = schema;
     }
 }
-exports.ValueErrorsInvalidTypeError = ValueErrorsInvalidTypeError;
+exports.ValueErrorsUnknownTypeError = ValueErrorsUnknownTypeError;
 var ValueErrors;
 (function (ValueErrors) {
     function* Any(schema, references, path, value) { }
@@ -110,7 +110,7 @@ var ValueErrors;
         }
     }
     function* Constructor(schema, references, path, value) {
-        yield* Visit(schema.returns, references, path, value);
+        yield* Visit(schema.returns, references, path, value.prototype);
     }
     function* Function(schema, references, path, value) {
         if (!(typeof value === 'function')) {
@@ -306,72 +306,53 @@ var ValueErrors;
         }
     }
     function* Visit(schema, references, path, value) {
-        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);
+        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 ValueErrorsUnknownTypeError(schema);
         }
     }
     function* Errors(schema, references, value) {

package/guard/guard.d.ts

@@ -1,48 +1,54 @@
 import * as Types from '../typebox';
+export declare class TypeGuardInvalidTypeError extends Error {
+    readonly schema: unknown;
+    constructor(schema: unknown);
+}
 /** TypeGuard tests that values conform to a known TypeBox type specification */
 export declare namespace TypeGuard {
     /** Returns true if the given schema is TAny */
-    function TAny(schema: any): schema is Types.TAny;
+    function TAny(schema: unknown): schema is Types.TAny;
     /** Returns true if the given schema is TArray */
-    function TArray(schema: any): schema is Types.TArray;
+    function TArray(schema: unknown): schema is Types.TArray;
     /** Returns true if the given schema is TBoolean */
-    function TBoolean(schema: any): schema is Types.TBoolean;
+    function TBoolean(schema: unknown): schema is Types.TBoolean;
     /** Returns true if the given schema is TConstructor */
-    function TConstructor(schema: any): schema is Types.TConstructor;
+    function TConstructor(schema: unknown): schema is Types.TConstructor;
     /** Returns true if the given schema is TFunction */
-    function TFunction(schema: any): schema is Types.TFunction;
+    function TFunction(schema: unknown): schema is Types.TFunction;
     /** Returns true if the given schema is TInteger */
-    function TInteger(schema: any): schema is Types.TInteger;
+    function TInteger(schema: unknown): schema is Types.TInteger;
     /** Returns true if the given schema is TLiteral */
-    function TLiteral(schema: any): schema is Types.TLiteral;
+    function TLiteral(schema: unknown): schema is Types.TLiteral;
     /** Returns true if the given schema is TNull */
-    function TNull(schema: any): schema is Types.TNull;
+    function TNull(schema: unknown): schema is Types.TNull;
     /** Returns true if the given schema is TNumber */
-    function TNumber(schema: any): schema is Types.TNumber;
+    function TNumber(schema: unknown): schema is Types.TNumber;
     /** Returns true if the given schema is TObject */
-    function TObject(schema: any): schema is Types.TObject;
+    function TObject(schema: unknown): schema is Types.TObject;
     /** Returns true if the given schema is TPromise */
-    function TPromise(schema: any): schema is Types.TPromise;
+    function TPromise(schema: unknown): schema is Types.TPromise;
     /** Returns true if the given schema is TRecord */
-    function TRecord(schema: any): schema is Types.TRecord;
+    function TRecord(schema: unknown): schema is Types.TRecord;
     /** Returns true if the given schema is TSelf */
-    function TSelf(schema: any): schema is Types.TSelf;
+    function TSelf(schema: unknown): schema is Types.TSelf;
     /** Returns true if the given schema is TRef */
-    function TRef(schema: any): schema is Types.TRef;
+    function TRef(schema: unknown): schema is Types.TRef;
     /** Returns true if the given schema is TString */
-    function TString(schema: any): schema is Types.TString;
+    function TString(schema: unknown): schema is Types.TString;
     /** Returns true if the given schema is TTuple */
-    function TTuple(schema: any): schema is Types.TTuple;
+    function TTuple(schema: unknown): schema is Types.TTuple;
     /** Returns true if the given schema is TUndefined */
-    function TUndefined(schema: any): schema is Types.TUndefined;
+    function TUndefined(schema: unknown): schema is Types.TUndefined;
     /** Returns true if the given schema is TUnion */
-    function TUnion(schema: any): schema is Types.TUnion;
+    function TUnion(schema: unknown): schema is Types.TUnion;
     /** Returns true if the given schema is TUint8Array */
-    function TUint8Array(schema: any): schema is Types.TUint8Array;
+    function TUint8Array(schema: unknown): schema is Types.TUint8Array;
     /** Returns true if the given schema is TUnknown */
-    function TUnknown(schema: any): schema is Types.TUnknown;
+    function TUnknown(schema: unknown): schema is Types.TUnknown;
     /** Returns true if the given schema is TVoid */
-    function TVoid(schema: any): schema is Types.TVoid;
+    function TVoid(schema: unknown): schema is Types.TVoid;
     /** Returns true if the given schema is TSchema */
-    function TSchema(schema: any): schema is Types.TSchema;
+    function TSchema(schema: unknown): schema is Types.TSchema;
+    /** Asserts if this schema and associated references are valid. */
+    function Assert<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): void;
 }