@sinclair/typebox 0.24.33 → 0.24.36

package/typebox.d.ts

@@ -103,9 +103,12 @@ export declare type IntersectEvaluate<T extends readonly TSchema[], P extends un
     [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 };
 export declare type IntersectReduce<I extends unknown, T extends readonly any[]> = T extends [infer A, ...infer B] ? IntersectReduce<I & A, B> : I extends object ? I : {};
+export declare type IntersectProperties<T extends TObject[]> = UnionToIntersect<{
+    [I in keyof T]: T[I]['properties'];
+}[number]> extends infer P ? (P extends TProperties ? P : TProperties) : never;
 export interface TIntersect<T extends TObject[] = TObject[]> extends TObject {
     static: IntersectReduce<unknown, IntersectEvaluate<T, this['params']>>;
-    properties: Record<keyof IntersectReduce<unknown, IntersectEvaluate<T, this['params']>>, TSchema>;
+    properties: IntersectProperties<T>;
 }
 export declare type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
 export declare type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;

package/value/cast.js

@@ -81,7 +81,7 @@ exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
 var ValueCast;
 (function (ValueCast) {
     // -----------------------------------------------------------
-    // Conversion
+    // Convert
     // -----------------------------------------------------------
     function IsString(value) {
         return typeof value === 'string';
@@ -104,6 +104,9 @@ var ValueCast;
     function IsValueTrue(value) {
         return value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === 1n) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'));
     }
+    function IsValueFalse(value) {
+        return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === 0n) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'));
+    }
     function TryConvertString(value) {
         return IsValueToString(value) ? value.toString() : value;
     }
@@ -114,10 +117,10 @@ var ValueCast;
         return IsStringNumeric(value) ? parseInt(value) : IsValueTrue(value) ? 1 : value;
     }
     function TryConvertBoolean(value) {
-        return IsValueTrue(value) ? true : value;
+        return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
     }
     // -----------------------------------------------------------
-    // Casts
+    // Cast
     // -----------------------------------------------------------
     function Any(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);

package/value/clone.d.ts

@@ -0,0 +1,3 @@
+export declare namespace ValueClone {
+    function Clone<T extends unknown>(value: T): T;
+}

package/value/clone.js

@@ -0,0 +1,65 @@
+"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.ValueClone = void 0;
+const is_1 = require("./is");
+var ValueClone;
+(function (ValueClone) {
+    function Object(value) {
+        const keys = [...globalThis.Object.keys(value), ...globalThis.Object.getOwnPropertySymbols(value)];
+        return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {});
+    }
+    function Array(value) {
+        return value.map((element) => Clone(element));
+    }
+    function TypedArray(value) {
+        return value.slice();
+    }
+    function Value(value) {
+        return value;
+    }
+    function Clone(value) {
+        if (is_1.Is.Object(value)) {
+            return Object(value);
+        }
+        else if (is_1.Is.Array(value)) {
+            return Array(value);
+        }
+        else if (is_1.Is.TypedArray(value)) {
+            return TypedArray(value);
+        }
+        else if (is_1.Is.Value(value)) {
+            return Value(value);
+        }
+        else {
+            throw new Error('ValueClone: Unable to clone value');
+        }
+    }
+    ValueClone.Clone = Clone;
+})(ValueClone = exports.ValueClone || (exports.ValueClone = {}));

package/value/delta.d.ts

@@ -0,0 +1,22 @@
+export declare type Edit<T = unknown> = Insert<T> | Update<T> | Delete<T>;
+export interface Insert<T> {
+    brand: T;
+    type: 'insert';
+    path: string;
+    value: any;
+}
+export interface Update<T> {
+    brand: T;
+    type: 'update';
+    path: string;
+    value: any;
+}
+export interface Delete<T> {
+    brand: T;
+    type: 'delete';
+    path: string;
+}
+export declare namespace ValueDelta {
+    function Diff<T>(current: T, next: T): Edit<T>[];
+    function Patch<T>(current: T, edits: Edit<T>[]): T;
+}

package/value/delta.js

@@ -0,0 +1,169 @@
+"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.ValueDelta = void 0;
+const is_1 = require("./is");
+const clone_1 = require("./clone");
+const pointer_1 = require("./pointer");
+var ValueDelta;
+(function (ValueDelta) {
+    // ---------------------------------------------------------------------
+    // Edits
+    // ---------------------------------------------------------------------
+    function Update(path, value) {
+        return { type: 'update', path, value };
+    }
+    function Insert(path, value) {
+        return { type: 'insert', path, value };
+    }
+    function Delete(path) {
+        return { type: 'delete', path };
+    }
+    // ---------------------------------------------------------------------
+    // Diff
+    // ---------------------------------------------------------------------
+    function* Object(path, current, next) {
+        if (!is_1.Is.Object(next))
+            return yield Update(path, next);
+        const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)];
+        const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
+        for (const key of currentKeys) {
+            if (typeof key === 'symbol')
+                throw Error('ValueDelta: Cannot produce diff symbol keys');
+            if (next[key] === undefined && nextKeys.includes(key))
+                yield Update(`${path}/${String(key)}`, undefined);
+        }
+        for (const key of nextKeys) {
+            if (current[key] === undefined || next[key] === undefined)
+                continue;
+            if (typeof key === 'symbol')
+                throw Error('ValueDelta: Cannot produce diff symbol keys');
+            yield* Visit(`${path}/${String(key)}`, current[key], next[key]);
+        }
+        for (const key of nextKeys) {
+            if (typeof key === 'symbol')
+                throw Error('ValueDelta: Cannot produce diff symbol keys');
+            if (current[key] === undefined)
+                yield Insert(`${path}/${String(key)}`, next[key]);
+        }
+        for (const key of currentKeys.reverse()) {
+            if (typeof key === 'symbol')
+                throw Error('ValueDelta: Cannot produce diff symbol keys');
+            if (next[key] === undefined && !nextKeys.includes(key))
+                yield Delete(`${path}/${String(key)}`);
+        }
+    }
+    function* Array(path, current, next) {
+        if (!is_1.Is.Array(next))
+            return yield Update(path, next);
+        for (let i = 0; i < Math.min(current.length, next.length); i++) {
+            yield* Visit(`${path}/${i}`, current[i], next[i]);
+        }
+        for (let i = 0; i < next.length; i++) {
+            if (i < current.length)
+                continue;
+            yield Insert(`${path}/${i}`, next[i]);
+        }
+        for (let i = current.length - 1; i >= 0; i--) {
+            if (i < next.length)
+                continue;
+            yield Delete(`${path}/${i}`);
+        }
+    }
+    function* TypedArray(path, current, next) {
+        if (!is_1.Is.TypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name)
+            return yield Update(path, next);
+        for (let i = 0; i < Math.min(current.length, next.length); i++) {
+            yield* Visit(`${path}/${i}`, current[i], next[i]);
+        }
+    }
+    function* Value(path, current, next) {
+        if (current === next)
+            return;
+        yield Update(path, next);
+    }
+    function* Visit(path, current, next) {
+        if (is_1.Is.Object(current)) {
+            return yield* Object(path, current, next);
+        }
+        else if (is_1.Is.Array(current)) {
+            return yield* Array(path, current, next);
+        }
+        else if (is_1.Is.TypedArray(current)) {
+            return yield* TypedArray(path, current, next);
+        }
+        else if (is_1.Is.Value(current)) {
+            return yield* Value(path, current, next);
+        }
+        else {
+            console.log('left', current);
+            throw new Error('ValueDelta: Cannot produce edits for value');
+        }
+    }
+    function Diff(current, next) {
+        return [...Visit('', current, next)];
+    }
+    ValueDelta.Diff = Diff;
+    // ---------------------------------------------------------------------
+    // Patch
+    // ---------------------------------------------------------------------
+    function IsRootUpdate(edits) {
+        return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
+    }
+    function IsIdentity(edits) {
+        return edits.length === 0;
+    }
+    function Patch(current, edits) {
+        if (IsRootUpdate(edits)) {
+            return clone_1.ValueClone.Clone(edits[0].value);
+        }
+        if (IsIdentity(edits)) {
+            return clone_1.ValueClone.Clone(current);
+        }
+        const clone = clone_1.ValueClone.Clone(current);
+        for (const edit of edits) {
+            switch (edit.type) {
+                case 'insert': {
+                    pointer_1.ValuePointer.Set(clone, edit.path, edit.value);
+                    break;
+                }
+                case 'update': {
+                    pointer_1.ValuePointer.Set(clone, edit.path, edit.value);
+                    break;
+                }
+                case 'delete': {
+                    pointer_1.ValuePointer.Delete(clone, edit.path);
+                    break;
+                }
+            }
+        }
+        return clone;
+    }
+    ValueDelta.Patch = Patch;
+})(ValueDelta = exports.ValueDelta || (exports.ValueDelta = {}));

package/value/equal.d.ts

@@ -0,0 +1,3 @@
+export declare namespace ValueEqual {
+    function Equal<T>(left: T, right: unknown): right is T;
+}

package/value/equal.js

@@ -0,0 +1,74 @@
+"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.ValueEqual = void 0;
+const is_1 = require("./is");
+var ValueEqual;
+(function (ValueEqual) {
+    function Object(left, right) {
+        if (!is_1.Is.Object(right))
+            return false;
+        const leftKeys = [...globalThis.Object.keys(left), ...globalThis.Object.getOwnPropertySymbols(left)];
+        const rightKeys = [...globalThis.Object.keys(right), ...globalThis.Object.getOwnPropertySymbols(right)];
+        if (leftKeys.length !== rightKeys.length)
+            return false;
+        return leftKeys.every((key) => Equal(left[key], right[key]));
+    }
+    function Array(left, right) {
+        if (!is_1.Is.Array(right) || left.length !== right.length)
+            return false;
+        return left.every((value, index) => Equal(value, right[index]));
+    }
+    function TypedArray(left, right) {
+        if (!is_1.Is.TypedArray(right) || left.length !== right.length || globalThis.Object.getPrototypeOf(left).constructor.name !== globalThis.Object.getPrototypeOf(right).constructor.name)
+            return false;
+        return left.every((value, index) => Equal(value, right[index]));
+    }
+    function Value(left, right) {
+        return left === right;
+    }
+    function Equal(left, right) {
+        if (is_1.Is.Object(left)) {
+            return Object(left, right);
+        }
+        else if (is_1.Is.TypedArray(left)) {
+            return TypedArray(left, right);
+        }
+        else if (is_1.Is.Array(left)) {
+            return Array(left, right);
+        }
+        else if (is_1.Is.Value(left)) {
+            return Value(left, right);
+        }
+        else {
+            throw new Error('ValueEquals: Unable to compare value');
+        }
+    }
+    ValueEqual.Equal = Equal;
+})(ValueEqual = exports.ValueEqual || (exports.ValueEqual = {}));

package/value/is.d.ts

@@ -0,0 +1,10 @@
+export declare type ValueType = null | undefined | Function | symbol | bigint | number | boolean | string;
+export declare type ObjectType = Record<string | number | symbol, unknown>;
+export declare type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+export declare type ArrayType = unknown[];
+export declare namespace Is {
+    function Object(value: unknown): value is ObjectType;
+    function Array(value: unknown): value is ArrayType;
+    function Value(value: unknown): value is ValueType;
+    function TypedArray(value: unknown): value is TypedArrayType;
+}

package/value/is.js

@@ -0,0 +1,49 @@
+"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.Is = void 0;
+var Is;
+(function (Is) {
+    function Object(value) {
+        return value !== null && typeof value === 'object' && !globalThis.Array.isArray(value) && !ArrayBuffer.isView(value);
+    }
+    Is.Object = Object;
+    function Array(value) {
+        return globalThis.Array.isArray(value) && !ArrayBuffer.isView(value);
+    }
+    Is.Array = Array;
+    function Value(value) {
+        return value === null || value === undefined || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'bigint' || typeof value === 'number' || typeof value === 'boolean' || typeof value === 'string';
+    }
+    Is.Value = Value;
+    function TypedArray(value) {
+        return ArrayBuffer.isView(value);
+    }
+    Is.TypedArray = TypedArray;
+})(Is = exports.Is || (exports.Is = {}));

package/value/pointer.d.ts

@@ -0,0 +1,11 @@
+/** RFC6901 JsonPointer */
+export declare namespace ValuePointer {
+    /** Sets the value at the given pointer. If the value at the pointer does not exist it is created. */
+    function Set(value: any, pointer: string, update: any): void;
+    /** Deletes a value at the given pointer. */
+    function Delete(value: any, pointer: string): any[] | undefined;
+    /** True if a value exists at the given pointer */
+    function Has(value: any, pointer: string): boolean;
+    /** Gets the value at the given pointer */
+    function Get(value: any, pointer: string): any;
+}

package/value/pointer.js

@@ -0,0 +1,108 @@
+"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.ValuePointer = void 0;
+/** RFC6901 JsonPointer */
+var ValuePointer;
+(function (ValuePointer) {
+    function Format(pointer) {
+        if (pointer === '/')
+            return [''];
+        const split = pointer.split('/');
+        const filter = split.filter((part) => part.length > 0);
+        return filter.map((part) => part.replace(/~0/g, `~`).replace(/~1/g, `/`));
+    }
+    /** Sets the value at the given pointer. If the value at the pointer does not exist it is created. */
+    function Set(value, pointer, update) {
+        if (pointer === '')
+            throw Error('Cannot set root value');
+        const path = Format(pointer);
+        let current = value;
+        while (path.length > 1) {
+            const next = path.shift();
+            if (current[next] === undefined)
+                current[next] = {};
+            current = current[next];
+        }
+        current[path.shift()] = update;
+    }
+    ValuePointer.Set = Set;
+    /** Deletes a value at the given pointer. */
+    function Delete(value, pointer) {
+        if (pointer === '')
+            throw Error('Cannot delete root value');
+        let current = value;
+        const path = Format(pointer);
+        while (path.length > 1) {
+            const next = path.shift();
+            if (current[next] === undefined)
+                return;
+            current = current[next];
+        }
+        if (Array.isArray(current)) {
+            const index = parseInt(path.shift());
+            return current.splice(index, 1);
+        }
+        else {
+            const key = path.shift();
+            delete current[key];
+        }
+    }
+    ValuePointer.Delete = Delete;
+    /** True if a value exists at the given pointer */
+    function Has(value, pointer) {
+        if (pointer === '')
+            return true;
+        let current = value;
+        const path = Format(pointer);
+        while (path.length > 1) {
+            const next = path.shift();
+            if (current[next] === undefined)
+                return false;
+            current = current[next];
+        }
+        return current[path.shift()] !== undefined;
+    }
+    ValuePointer.Has = Has;
+    /** Gets the value at the given pointer */
+    function Get(value, pointer) {
+        if (pointer === '')
+            return value;
+        let current = value;
+        const path = Format(pointer);
+        while (path.length > 1) {
+            const next = path.shift();
+            if (current[next] === undefined)
+                return undefined;
+            current = current[next];
+        }
+        return current[path.shift()];
+    }
+    ValuePointer.Get = Get;
+})(ValuePointer = exports.ValuePointer || (exports.ValuePointer = {}));

package/value/value.d.ts

@@ -1,7 +1,13 @@
 import * as Types from '../typebox';
 import { ValueError } from '../errors/index';
-/** Creates Values from TypeBox Types */
+import { Edit } from './delta';
+export type { Edit } from './delta';
+/** The Value namespace provides type operations on values */
 export declare namespace Value {
+    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is 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 given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is possible. */
+    function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>;
     /** 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 */
@@ -10,12 +16,16 @@ export declare namespace Value {
     function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>;
     /** Returns true if the 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 given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is 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 given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is 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>;
+    /** Returns true if left and right values are structurally equal */
+    function Equal<T>(left: T, right: unknown): right is T;
+    /** Returns a structural clone of the given value */
+    function Clone<T>(value: T): T;
+    /** Returns edits to transform the current value into the next value */
+    function Diff<T>(current: T, next: T): Edit<T>[];
+    /** Returns a new value with edits applied to the given value */
+    function Patch<T>(current: T, edits: Edit<T>[]): T;
 }

package/value/value.js

@@ -29,12 +29,20 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Value = void 0;
 const index_1 = require("../errors/index");
+const equal_1 = require("./equal");
 const cast_1 = require("./cast");
+const clone_1 = require("./clone");
 const create_1 = require("./create");
 const check_1 = require("./check");
-/** Creates Values from TypeBox Types */
+const delta_1 = require("./delta");
+/** The Value namespace provides type operations on values */
 var Value;
 (function (Value) {
+    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.Cast = Cast;
     function Create(...args) {
         const [schema, references] = args.length === 2 ? [args[0], args[1]] : [args[0], []];
         return create_1.ValueCreate.Create(schema, references);
@@ -45,14 +53,29 @@ var Value;
         return check_1.ValueCheck.Check(schema, references, value);
     }
     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.Cast = Cast;
     function* Errors(...args) {
         const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
         yield* index_1.ValueErrors.Errors(schema, references, value);
     }
     Value.Errors = Errors;
+    /** Returns true if left and right values are structurally equal */
+    function Equal(left, right) {
+        return equal_1.ValueEqual.Equal(left, right);
+    }
+    Value.Equal = Equal;
+    /** Returns a structural clone of the given value */
+    function Clone(value) {
+        return clone_1.ValueClone.Clone(value);
+    }
+    Value.Clone = Clone;
+    /** Returns edits to transform the current value into the next value */
+    function Diff(current, next) {
+        return delta_1.ValueDelta.Diff(current, next);
+    }
+    Value.Diff = Diff;
+    /** Returns a new value with edits applied to the given value */
+    function Patch(current, edits) {
+        return delta_1.ValueDelta.Patch(current, edits);
+    }
+    Value.Patch = Patch;
 })(Value = exports.Value || (exports.Value = {}));