@sinclair/typebox 0.24.6 → 0.24.9

package/{compiler → value}/errors.js

@@ -1,7 +1,7 @@
 "use strict";
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox/compiler
+@sinclair/typebox/value
 
 The MIT License (MIT)
 
@@ -27,33 +27,33 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeErrors = void 0;
+exports.ValueErrors = void 0;
 const Types = require("../typebox");
-var TypeErrors;
-(function (TypeErrors) {
-    function* Any(schema, path, value) { }
-    function* Array(schema, path, value) {
+var ValueErrors;
+(function (ValueErrors) {
+    function* Any(schema, references, path, value) { }
+    function* Array(schema, references, path, value) {
         if (!globalThis.Array.isArray(value)) {
             return yield { schema, path, value, message: `Expected array` };
         }
         for (let i = 0; i < value.length; i++) {
-            yield* Visit(schema.items, `${path}/${i}`, value[i]);
+            yield* Visit(schema.items, references, `${path}/${i}`, value[i]);
         }
     }
-    function* Boolean(schema, path, value) {
+    function* Boolean(schema, references, path, value) {
         if (!(typeof value === 'boolean')) {
             return yield { schema, path, value, message: `Expected boolean` };
         }
     }
-    function* Constructor(schema, path, value) {
-        yield* Visit(schema.yields, path, value);
+    function* Constructor(schema, references, path, value) {
+        yield* Visit(schema.returns, references, path, value);
     }
-    function* Function(schema, path, value) {
+    function* Function(schema, references, path, value) {
         if (!(typeof value === 'function')) {
             return yield { schema, path, value, message: `Expected function` };
         }
     }
-    function* Integer(schema, path, value) {
+    function* Integer(schema, references, path, value) {
         if (!(typeof value === 'number')) {
             return yield { schema, path, value, message: `Expected number` };
         }
@@ -76,18 +76,18 @@ var TypeErrors;
             yield { schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
         }
     }
-    function* Literal(schema, path, value) {
+    function* Literal(schema, references, path, value) {
         if (!(value === schema.const)) {
             const error = typeof schema.const === 'string' ? `'${schema.const}'` : schema.const;
             return yield { schema, path, value, message: `Expected ${error}` };
         }
     }
-    function* Null(schema, path, value) {
+    function* Null(schema, references, path, value) {
         if (!(value === null)) {
             return yield { schema, path, value, message: `Expected null` };
         }
     }
-    function* Number(schema, path, value) {
+    function* Number(schema, references, path, value) {
         if (!(typeof value === 'number')) {
             return yield { schema, path, value, message: `Expected number` };
         }
@@ -107,7 +107,7 @@ var TypeErrors;
             yield { schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
         }
     }
-    function* Object(schema, path, value) {
+    function* Object(schema, references, path, value) {
         if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
             return yield { schema, path, value, message: `Expected object` };
         }
@@ -119,37 +119,30 @@ var TypeErrors;
         }
         const propertyKeys = globalThis.Object.keys(schema.properties);
         if (schema.additionalProperties === false) {
-            // 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.
-            if (schema.required && schema.required.length === propertyKeys.length && !(globalThis.Object.keys(value).length === propertyKeys.length)) {
-                yield { schema, path, value, message: 'Expected object must not have additional properties' };
-            }
-            else {
-                if (!globalThis.Object.keys(value).every((key) => propertyKeys.includes(key))) {
-                    yield { schema, path, value, message: 'Expected object must not have additional properties' };
+            for (const propKey of globalThis.Object.keys(value)) {
+                if (!propertyKeys.includes(propKey)) {
+                    yield { schema, path: `${path}/${propKey}`, value: value[propKey], message: 'Unexpected property' };
                 }
             }
         }
         for (const propertyKey of propertyKeys) {
             const propertySchema = schema.properties[propertyKey];
             if (schema.required && schema.required.includes(propertyKey)) {
-                yield* Visit(propertySchema, `${path}/${propertyKey}`, value[propertyKey]);
+                yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey]);
             }
             else {
                 if (value[propertyKey] !== undefined) {
-                    yield* Visit(propertySchema, `${path}/${propertyKey}`, value[propertyKey]);
+                    yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey]);
                 }
             }
         }
     }
-    function* Promise(schema, path, value) {
+    function* Promise(schema, references, path, value) {
         if (!(typeof value === 'object' && typeof value.then === 'function')) {
             yield { schema, path, value, message: `Expected Promise` };
         }
     }
-    function* Record(schema, path, value) {
+    function* Record(schema, references, path, value) {
         if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
             return yield { schema, path, value, message: `Expected object` };
         }
@@ -160,24 +153,22 @@ var TypeErrors;
             return yield { schema, path, value, message };
         }
         for (const [propKey, propValue] of globalThis.Object.entries(value)) {
-            yield* Visit(valueSchema, `${path}/${propKey}`, propValue);
+            yield* Visit(valueSchema, references, `${path}/${propKey}`, propValue);
         }
     }
-    function* Ref(schema, path, value) {
-        if (!referenceMap.has(schema.$ref)) {
-            throw Error(`TypeErrors: Cannot locate referenced schema for $id '${schema.$id}'`);
-        }
-        const referencedSchema = referenceMap.get(schema.$ref);
-        yield* Visit(referencedSchema, path, value);
+    function* Ref(schema, references, path, value) {
+        const reference = references.find((reference) => reference.$id === schema.$ref);
+        if (reference === undefined)
+            throw new Error(`ValueErrors.Ref: Cannot find schema with $id '${schema.$ref}'.`);
+        yield* Visit(reference, references, path, value);
     }
-    function* Self(schema, path, value) {
-        if (!referenceMap.has(schema.$ref)) {
-            throw Error(`TypeErrors: Cannot locate referenced schema for $id '${schema.$id}'`);
-        }
-        const referencedSchema = referenceMap.get(schema.$ref);
-        yield* Visit(referencedSchema, path, value);
+    function* Self(schema, references, path, value) {
+        const reference = references.find((reference) => reference.$id === schema.$ref);
+        if (reference === undefined)
+            throw new Error(`ValueErrors.Self: Cannot find schema with $id '${schema.$ref}'.`);
+        yield* Visit(reference, references, path, value);
     }
-    function* String(schema, path, value) {
+    function* String(schema, references, path, value) {
         if (!(typeof value === 'string')) {
             return yield { schema, path, value, message: 'Expected string' };
         }
@@ -188,7 +179,7 @@ var TypeErrors;
             }
         }
     }
-    function* Tuple(schema, path, value) {
+    function* Tuple(schema, references, path, value) {
         if (!global.Array.isArray(value)) {
             return yield { schema, path, value, message: 'Expected Array' };
         }
@@ -202,18 +193,18 @@ var TypeErrors;
             return;
         }
         for (let i = 0; i < schema.items.length; i++) {
-            yield* Visit(schema.items[i], `${path}/${i}`, value[i]);
+            yield* Visit(schema.items[i], references, `${path}/${i}`, value[i]);
         }
     }
-    function* Undefined(schema, path, value) {
+    function* Undefined(schema, references, path, value) {
         if (!(value === undefined)) {
             yield { schema, path, value, message: `Expected undefined` };
         }
     }
-    function* Union(schema, path, value) {
+    function* Union(schema, references, path, value) {
         const errors = [];
         for (const inner of schema.anyOf) {
-            const variantErrors = [...Visit(inner, path, value)];
+            const variantErrors = [...Visit(inner, references, path, value)];
             if (variantErrors.length === 0)
                 return;
             errors.push(...variantErrors);
@@ -225,7 +216,7 @@ var TypeErrors;
             yield { schema, path, value, message: 'Expected value of union' };
         }
     }
-    function* Uint8Array(schema, path, value) {
+    function* Uint8Array(schema, references, path, value) {
         if (!(value instanceof globalThis.Uint8Array)) {
             return yield { schema, path, value, message: `Expected Uint8Array` };
         }
@@ -236,76 +227,64 @@ var TypeErrors;
             yield { schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` };
         }
     }
-    function* Unknown(schema, path, value) { }
-    function* Void(schema, path, value) {
+    function* Unknown(schema, references, path, value) { }
+    function* Void(schema, references, path, value) {
         if (!(value === null)) {
             return yield { schema, path, value, message: `Expected null` };
         }
     }
-    function* Visit(schema, path, value) {
-        if (schema.$id !== undefined) {
-            referenceMap.set(schema.$id, schema);
-        }
+    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, path, value);
+                return yield* Any(anySchema, anyReferences, path, value);
             case 'Array':
-                return yield* Array(anySchema, path, value);
+                return yield* Array(anySchema, anyReferences, path, value);
             case 'Boolean':
-                return yield* Boolean(anySchema, path, value);
+                return yield* Boolean(anySchema, anyReferences, path, value);
             case 'Constructor':
-                return yield* Constructor(anySchema, path, value);
+                return yield* Constructor(anySchema, anyReferences, path, value);
             case 'Function':
-                return yield* Function(anySchema, path, value);
+                return yield* Function(anySchema, anyReferences, path, value);
             case 'Integer':
-                return yield* Integer(anySchema, path, value);
+                return yield* Integer(anySchema, anyReferences, path, value);
             case 'Literal':
-                return yield* Literal(anySchema, path, value);
+                return yield* Literal(anySchema, anyReferences, path, value);
             case 'Null':
-                return yield* Null(anySchema, path, value);
+                return yield* Null(anySchema, anyReferences, path, value);
             case 'Number':
-                return yield* Number(anySchema, path, value);
+                return yield* Number(anySchema, anyReferences, path, value);
             case 'Object':
-                return yield* Object(anySchema, path, value);
+                return yield* Object(anySchema, anyReferences, path, value);
             case 'Promise':
-                return yield* Promise(anySchema, path, value);
+                return yield* Promise(anySchema, anyReferences, path, value);
             case 'Record':
-                return yield* Record(anySchema, path, value);
+                return yield* Record(anySchema, anyReferences, path, value);
             case 'Ref':
-                return yield* Ref(anySchema, path, value);
+                return yield* Ref(anySchema, anyReferences, path, value);
             case 'Self':
-                return yield* Self(anySchema, path, value);
+                return yield* Self(anySchema, anyReferences, path, value);
             case 'String':
-                return yield* String(anySchema, path, value);
+                return yield* String(anySchema, anyReferences, path, value);
             case 'Tuple':
-                return yield* Tuple(anySchema, path, value);
+                return yield* Tuple(anySchema, anyReferences, path, value);
             case 'Undefined':
-                return yield* Undefined(anySchema, path, value);
+                return yield* Undefined(anySchema, anyReferences, path, value);
             case 'Union':
-                return yield* Union(anySchema, path, value);
+                return yield* Union(anySchema, anyReferences, path, value);
             case 'Uint8Array':
-                return yield* Uint8Array(anySchema, path, value);
+                return yield* Uint8Array(anySchema, anyReferences, path, value);
             case 'Unknown':
-                return yield* Unknown(anySchema, path, value);
+                return yield* Unknown(anySchema, anyReferences, path, value);
             case 'Void':
-                return yield* Void(anySchema, path, value);
+                return yield* Void(anySchema, anyReferences, path, value);
             default:
-                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
-        }
-    }
-    const referenceMap = new Map();
-    function SetAdditional(additional = []) {
-        referenceMap.clear();
-        for (const schema of additional) {
-            if (!schema.$id)
-                throw Error('TypeErrors: Referenced additional schemas must have an $id');
-            referenceMap.set(schema.$id, schema);
+                throw new Error(`ValueErrors: Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
-    function* Errors(schema, additional, value) {
-        SetAdditional(additional);
-        yield* Visit(schema, '', value);
+    function* Errors(schema, references, value) {
+        yield* Visit(schema, references, '', value);
     }
-    TypeErrors.Errors = Errors;
-})(TypeErrors = exports.TypeErrors || (exports.TypeErrors = {}));
+    ValueErrors.Errors = Errors;
+})(ValueErrors = exports.ValueErrors || (exports.ValueErrors = {}));

package/value/index.d.ts

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

package/value/value.d.ts

@@ -1,17 +1,21 @@
 import * as Types from '../typebox';
-import { Edit } from './delta';
-export { Edit, EditType } from './delta';
+import { ValueError } from './errors';
+/** Creates Values from TypeBox Types */
 export declare namespace Value {
-    /** Returns true if the value conforms to the given schema */
-    function Check<T extends Types.TSchema>(schema: T, value: any): value is Types.Static<T>;
-    /** Returns a deep clone of the given value */
-    function Clone<T>(value: T): T;
-    /** Creates a value from the given schema type */
+    /** Creates a value from the given type */
+    function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>;
+    /** Creates a value from the given type */
     function Create<T extends Types.TSchema>(schema: T): Types.Static<T>;
-    /** Diffs the value and produces edits to transform the value into the next value */
-    function Diff(value: any, next: any): Edit[];
-    /** Patches a value by applying a series of edits */
-    function Patch(value: any, edits: Edit[]): any;
-    /** Upcasts a value to match a schema while preserving as much information from the original value as possible. */
-    function Upcast<T extends Types.TSchema>(schema: T, value: any): Types.Static<T>;
+    /** Checks a value matches the given type */
+    function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>;
+    /** Checks a value matches the given type */
+    function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;
+    /** Casts a value into a structure matching the given type. The result will be a new value that retains as much information of the original value as possible. */
+    function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>;
+    /** Casts a value into a structure matching the given type. The result will be a new value that retains as much information of the original value as possible. */
+    function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>;
+    /** Returns an iterator for each error in this value. */
+    function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): IterableIterator<ValueError>;
+    /** Returns an iterator for each error in this value. */
+    function Errors<T extends Types.TSchema>(schema: T, value: unknown): IterableIterator<ValueError>;
 }

package/value/value.js

@@ -1,7 +1,7 @@
 "use strict";
 /*--------------------------------------------------------------------------
 
-@sinclair/typebox
+@sinclair/typebox/value
 
 The MIT License (MIT)
 
@@ -27,44 +27,32 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Value = exports.EditType = void 0;
+exports.Value = void 0;
+const errors_1 = require("./errors");
+const cast_1 = require("./cast");
 const create_1 = require("./create");
 const check_1 = require("./check");
-const clone_1 = require("./clone");
-const delta_1 = require("./delta");
-const upcast_1 = require("./upcast");
-var delta_2 = require("./delta");
-Object.defineProperty(exports, "EditType", { enumerable: true, get: function () { return delta_2.EditType; } });
+/** Creates Values from TypeBox Types */
 var Value;
 (function (Value) {
-    /** Returns true if the value conforms to the given schema */
-    function Check(schema, value) {
-        return check_1.CheckValue.Check(schema, value);
-    }
-    Value.Check = Check;
-    /** Returns a deep clone of the given value */
-    function Clone(value) {
-        return clone_1.CloneValue.Create(value);
-    }
-    Value.Clone = Clone;
-    /** Creates a value from the given schema type */
-    function Create(schema) {
-        return create_1.CreateValue.Create(schema);
+    function Create(...args) {
+        const [schema, references] = args.length === 2 ? [args[0], args[1]] : [args[0], []];
+        return create_1.ValueCreate.Create(schema, references);
     }
     Value.Create = Create;
-    /** Diffs the value and produces edits to transform the value into the next value */
-    function Diff(value, next) {
-        return delta_1.DeltaValue.Diff(value, next);
+    function Check(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return check_1.ValueCheck.Check(schema, references, value);
     }
-    Value.Diff = Diff;
-    /** Patches a value by applying a series of edits */
-    function Patch(value, edits) {
-        return delta_1.DeltaValue.Edit(value, edits);
+    Value.Check = Check;
+    function Cast(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return cast_1.ValueCast.Cast(schema, references, value);
     }
-    Value.Patch = Patch;
-    /** Upcasts a value to match a schema while preserving as much information from the original value as possible. */
-    function Upcast(schema, value) {
-        return upcast_1.UpcastValue.Create(schema, 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);
     }
-    Value.Upcast = Upcast;
+    Value.Errors = Errors;
 })(Value = exports.Value || (exports.Value = {}));

package/compiler/errors.d.ts

@@ -1,10 +0,0 @@
-import * as Types from '../typebox';
-export interface TypeError {
-    schema: Types.TSchema;
-    path: string;
-    value: unknown;
-    message: string;
-}
-export declare namespace TypeErrors {
-    function Errors<T extends Types.TSchema>(schema: T, additional: Types.TSchema[], value: any): Generator<TypeError>;
-}

package/value/clone.d.ts

@@ -1,3 +0,0 @@
-export declare namespace CloneValue {
-    function Create<T extends any>(value: T): T;
-}

package/value/clone.js

@@ -1,94 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CloneValue = void 0;
-const reflect_1 = require("./reflect");
-var CloneValue;
-(function (CloneValue) {
-    function Undefined(_value) {
-        return undefined;
-    }
-    function Null(_value) {
-        return null;
-    }
-    function Function(value) {
-        return value;
-    }
-    function Object(value) {
-        return globalThis.Object.entries(value).reduce((acc, [key, value]) => {
-            return { ...acc, [key]: Create(value) };
-        }, {});
-    }
-    function Array(value) {
-        return value.map((element) => Create(element));
-    }
-    function BigInt(value) {
-        return value;
-    }
-    function Symbol(value) {
-        return value;
-    }
-    function String(value) {
-        return value;
-    }
-    function Boolean(value) {
-        return value;
-    }
-    function Number(value) {
-        return value;
-    }
-    function Create(value) {
-        const typeName = (0, reflect_1.Reflect)(value);
-        switch (typeName) {
-            case 'array':
-                return Array(value);
-            case 'bigint':
-                return BigInt(value);
-            case 'boolean':
-                return Boolean(value);
-            case 'function':
-                return Function(value);
-            case 'null':
-                return Null(value);
-            case 'number':
-                return Number(value);
-            case 'object':
-                return Object(value);
-            case 'string':
-                return String(value);
-            case 'symbol':
-                return Symbol(value);
-            case 'undefined':
-                return Undefined(value);
-            default:
-                throw new Error(`Cannot clone from unknown typename ${typeName}`);
-        }
-    }
-    CloneValue.Create = Create;
-})(CloneValue = exports.CloneValue || (exports.CloneValue = {}));

package/value/delta.d.ts

@@ -1,13 +0,0 @@
-export declare enum EditType {
-    Delete = 0,
-    Update = 1,
-    Insert = 2
-}
-export declare type Edit = Insert | Update | Delete;
-export declare type Update = [EditType.Update, string, any];
-export declare type Insert = [EditType.Insert, string, any];
-export declare type Delete = [EditType.Delete, string];
-export declare namespace DeltaValue {
-    function Diff(valueA: any, valueB: any): Edit[];
-    function Edit(valueA: any, operations: Edit[]): any;
-}