@sinclair/typebox 0.24.8 → 0.24.9

package/compiler/compiler.d.ts

@@ -14,6 +14,7 @@ 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>;
 }
+/** Compiles TypeBox 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. */
     function Compile<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): TypeCheck<T>;

package/compiler/compiler.js

@@ -61,6 +61,7 @@ exports.TypeCheck = TypeCheck;
 // -------------------------------------------------------------------
 // TypeCompiler
 // -------------------------------------------------------------------
+/** Compiles TypeBox Types for Runtime Type Checking */
 var TypeCompiler;
 (function (TypeCompiler) {
     // -------------------------------------------------------------------
@@ -275,7 +276,7 @@ var TypeCompiler;
             case 'Void':
                 return yield* Void(anySchema, value);
             default:
-                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
+                throw new Error(`TypeCompiler: Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
     // -------------------------------------------------------------------
@@ -292,9 +293,9 @@ var TypeCompiler;
     function PushReferences(schemas = []) {
         for (const schema of schemas) {
             if (!schema.$id)
-                throw Error(`Referenced schemas must specify an $id. Failed for '${JSON.stringify(schema)}'`);
+                throw new Error(`TypeCompiler: Referenced schemas must specify an $id.`);
             if (referenceMap.has(schema.$id))
-                throw Error(`Duplicate schema $id detected for '${schema.$id}'`);
+                throw new Error(`TypeCompiler: Duplicate schema $id found for '${schema.$id}'`);
             referenceMap.set(schema.$id, schema);
         }
     }

package/compiler/index.d.ts

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

package/compiler/index.js

@@ -38,4 +38,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./compiler"), exports);
-__exportStar(require("../value/errors"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.8",
+  "version": "0.24.9",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",

package/readme.md

@@ -554,7 +554,7 @@ type U = Static<typeof U>                            // type U = number | null
 
 ### Unsafe Types
 
-In some cases, you may need schema definitions that are not provided by TypeBox. In these scenarios, it's common to want to define your own schema and static type inference rules. The `Type.Unsafe(...)` function provides this functionality, allowing you to specify both schema representation and a static type to infer. Consider the following which defines a `number` schema, but will infer as a `string`.
+In some scenarios, you may need specific schemas not provided by TypeBox. In these cases, it's common to want to define a custom schema with custom static inference rules. The `Type.Unsafe(...)` function provides this functionality. This function enables one to specify both schema representation and a static type to infer. Consider the following which defines a `number` schema but infers as `string`.
 
 ```typescript
 const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
@@ -564,7 +564,7 @@ const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
 type T = Static<typeof T>                            // type T = string
 ```
 
-The `Type.Unsafe(...)` function can be used with function generics to create custom schema representations for validators requiring specific schema representations. An example of which would be OpenAPI's `nullable` and `string-enum` representations which are not provided by TypeBox by default. The following demonstrates creating these schemas using the `Type.Unsafe(...)` function.
+The `Type.Unsafe(...)` function can be combined with function generics to create user defined schemas for validators that need specific schema representations. An example of this might be the OpenAPI `nullable` and `string-enum` schema representations which are not provided by TypeBox. The following demonstrates creating these schemas using the `Type.Unsafe(...)` function.
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'

package/typebox.js

@@ -227,7 +227,7 @@ class TypeBuilder {
     /** Creates a reference schema */
     Ref(schema, options = {}) {
         if (schema.$id === undefined)
-            throw Error('Cannot create reference schema as target schema as has no $id');
+            throw Error('Type.Ref: Referenced schema must specify an $id');
         return this.Create({ ...options, [exports.Kind]: 'Ref', $ref: schema.$id });
     }
     /** Creates a string type from a regular expression */

package/value/cast.js

@@ -72,7 +72,6 @@ var UnionValueCast;
 })(UnionValueCast || (UnionValueCast = {}));
 var ValueCast;
 (function (ValueCast) {
-    const ids = new Map();
     function Any(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
@@ -121,7 +120,6 @@ var ValueCast;
             return value;
         if (value === null || typeof value !== 'object')
             return create_1.ValueCreate.Create(schema, references);
-        ids.set(schema.$id, schema);
         const required = new Set(schema.required || []);
         const result = {};
         for (const [key, property] of globalThis.Object.entries(schema.properties)) {
@@ -148,7 +146,7 @@ var ValueCast;
         return result;
     }
     function Recursive(schema, references, value) {
-        throw Error('Cannot patch recursive schemas');
+        throw new Error('CastValue.Recursive: Cannot cast recursive schemas');
     }
     function Ref(schema, references, value) {
         const reference = references.find((reference) => reference.$id === schema.$ref);

package/value/check.js

@@ -273,7 +273,7 @@ var ValueCheck;
             case 'Void':
                 return Void(anySchema, anyReferences, value);
             default:
-                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
+                throw new Error(`CheckValue: Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
     // -------------------------------------------------------------------------

package/value/create.js

@@ -70,8 +70,8 @@ var ValueCreate;
                 return class {
                     constructor() {
                         for (const [key, val] of globalThis.Object.entries(value)) {
-                            const facade = this;
-                            facade[key] = val;
+                            const self = this;
+                            self[key] = val;
                         }
                     }
                 };
@@ -169,7 +169,7 @@ var ValueCreate;
             return schema.default;
         }
         else {
-            throw new Error('Rec types require a default value');
+            throw new Error('ValueCreate.Recursive: Recursive types require a default value');
         }
     }
     function Ref(schema, references) {
@@ -197,7 +197,7 @@ var ValueCreate;
     function String(schema, references) {
         if (schema.pattern !== undefined) {
             if (schema.default === undefined) {
-                throw Error('String types with patterns must specify a default value');
+                throw new Error('ValueCreate.String: String types with patterns must specify a default value');
             }
             else {
                 return schema.default;
@@ -231,7 +231,7 @@ var ValueCreate;
             return schema.default;
         }
         else if (schema.anyOf.length === 0) {
-            throw Error('Cannot generate Union with empty set');
+            throw new Error('ValueCreate: Cannot create Union with zero variants');
         }
         else {
             return ValueCreate.Create(schema.anyOf[0], references);
@@ -311,7 +311,7 @@ var ValueCreate;
             case 'Void':
                 return Void(anySchema, anyReferences);
             default:
-                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
+                throw new Error(`ValueCreate: Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
     ValueCreate.Visit = Visit;

package/value/errors.js

@@ -159,13 +159,13 @@ var ValueErrors;
     function* Ref(schema, references, path, value) {
         const reference = references.find((reference) => reference.$id === schema.$ref);
         if (reference === undefined)
-            throw new Error(`CheckValue.Ref: Cannot find schema with $id '${schema.$ref}'.`);
+            throw new Error(`ValueErrors.Ref: Cannot find schema with $id '${schema.$ref}'.`);
         yield* Visit(reference, references, path, value);
     }
     function* Self(schema, references, path, value) {
         const reference = references.find((reference) => reference.$id === schema.$ref);
         if (reference === undefined)
-            throw new Error(`CheckValue.Ref: Cannot find schema with $id '${schema.$ref}'.`);
+            throw new Error(`ValueErrors.Self: Cannot find schema with $id '${schema.$ref}'.`);
         yield* Visit(reference, references, path, value);
     }
     function* String(schema, references, path, value) {
@@ -280,7 +280,7 @@ var ValueErrors;
             case 'Void':
                 return yield* Void(anySchema, anyReferences, path, value);
             default:
-                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
+                throw new Error(`ValueErrors: Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
     function* Errors(schema, references, value) {

package/value/index.d.ts

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