@sinclair/typebox 0.27.0 → 0.27.2

package/errors/errors.js

@@ -505,12 +505,12 @@ var ValueErrors;
                 return;
             errors.push(...variantErrors);
         }
-        for (const error of errors) {
-            yield error;
-        }
         if (errors.length > 0) {
             yield { type: ValueErrorType.Union, schema, path, value, message: 'Expected value of union' };
         }
+        for (const error of errors) {
+            yield error;
+        }
     }
     function* Uint8Array(schema, references, path, value) {
         if (!(value instanceof globalThis.Uint8Array)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.0",
+  "version": "0.27.2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -96,6 +96,7 @@ License MIT
   - [Diff](#values-diff)
   - [Patch](#values-patch)
   - [Errors](#values-errors)
+  - [Mutate](#values-mutate)
   - [Pointer](#values-pointer)
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
@@ -1053,7 +1054,6 @@ const E = Value.Diff(A, B)                           // const E = [
 const C = Value.Patch<typeof B>(A, E)                // const C = { x: 3 }
 ```
 
-
 <a name='values-errors'></a>
 
 ### Errors
@@ -1076,6 +1076,29 @@ const R = [...Value.Errors(T, { x: '42' })]          // const R = [{
                                                      // }]
 ```
 
+<a name='values-mutate'></a>
+
+### Mutate
+
+Use the Mutate function to perform a deep mutable value assignment while retaining internal references.
+
+```typescript
+const Y = { z: 1 }                                   // const Y = { z: 1 } 
+
+const X = { y: Y }                                   // const X = { y: { z: 1 } }
+
+const A = { x: X }                                   // const A = { x: { y: { z: 1 } } }             
+
+
+Value.Mutate(A, { x: { y: { z: 2 } } })              // const A' = { x: { y: { z: 2 } } }   
+
+const R0 = A.x.y.z === 2                             // const R0 = 2
+
+const R1 = A.x.y === Y                               // const R1 = true
+
+const R2 = A.x === X                                 // const R2 = true
+```     
+
 <a name='values-pointer'></a>
 
 ### Pointer
@@ -1087,10 +1110,13 @@ import { ValuePointer } from '@sinclair/typebox/value'
 
 const A = { x: 0, y: 0, z: 0 }
 
-ValuePointer.Set(A, '/x', 1)                         // const A = { x: 1, y: 0, z: 0 }
-ValuePointer.Set(A, '/y', 1)                         // const A = { x: 1, y: 1, z: 0 }
-ValuePointer.Set(A, '/z', 1)                         // const A = { x: 1, y: 1, z: 1 }
+ValuePointer.Set(A, '/x', 1)                         // const A' = { x: 1, y: 0, z: 0 }
+
+ValuePointer.Set(A, '/y', 1)                         // const A' = { x: 1, y: 1, z: 0 }
+
+ValuePointer.Set(A, '/z', 1)                         // const A' = { x: 1, y: 1, z: 1 }
 ```
+
 <a name='typecheck'></a>
 
 ## TypeCheck

package/value/index.d.ts

@@ -1,5 +1,6 @@
 export { ValueError, ValueErrorIterator, ValueErrorType } from '../errors/index';
 export { ValueHash } from './hash';
 export { Edit, Insert, Update, Delete } from './delta';
+export { Mutable } from './mutate';
 export * from './pointer';
 export * from './value';

package/value/mutate.d.ts

@@ -0,0 +1,13 @@
+export declare class ValueMutateTypeMismatchError extends Error {
+    constructor();
+}
+export declare class ValueMutateInvalidRootMutationError extends Error {
+    constructor();
+}
+export type Mutable = {
+    [key: string]: unknown;
+} | unknown[];
+export declare namespace ValueMutate {
+    /** Performs a deep mutable value assignment while retaining internal references. */
+    function Mutate(current: Mutable, next: Mutable): void;
+}

package/value/mutate.js

@@ -0,0 +1,121 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 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.ValueMutate = exports.ValueMutateInvalidRootMutationError = exports.ValueMutateTypeMismatchError = void 0;
+const is_1 = require("./is");
+const pointer_1 = require("./pointer");
+const clone_1 = require("./clone");
+class ValueMutateTypeMismatchError extends Error {
+    constructor() {
+        super('ValueMutate: Cannot assign due type mismatch of assignable values');
+    }
+}
+exports.ValueMutateTypeMismatchError = ValueMutateTypeMismatchError;
+class ValueMutateInvalidRootMutationError extends Error {
+    constructor() {
+        super('ValueMutate: Only object and array types can be mutated at the root level');
+    }
+}
+exports.ValueMutateInvalidRootMutationError = ValueMutateInvalidRootMutationError;
+var ValueMutate;
+(function (ValueMutate) {
+    function Object(root, path, current, next) {
+        if (!is_1.Is.Object(current)) {
+            pointer_1.ValuePointer.Set(root, path, clone_1.ValueClone.Clone(next));
+        }
+        else {
+            const currentKeys = globalThis.Object.keys(current);
+            const nextKeys = globalThis.Object.keys(next);
+            for (const currentKey of currentKeys) {
+                if (!nextKeys.includes(currentKey)) {
+                    delete current[currentKey];
+                }
+            }
+            for (const nextKey of nextKeys) {
+                if (!currentKeys.includes(nextKey)) {
+                    current[nextKey] = null;
+                }
+            }
+            for (const nextKey of nextKeys) {
+                Visit(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
+            }
+        }
+    }
+    function Array(root, path, current, next) {
+        if (!is_1.Is.Array(current)) {
+            pointer_1.ValuePointer.Set(root, path, clone_1.ValueClone.Clone(next));
+        }
+        else {
+            for (let index = 0; index < next.length; index++) {
+                Visit(root, `${path}/${index}`, current[index], next[index]);
+            }
+            current.splice(next.length);
+        }
+    }
+    function TypedArray(root, path, current, next) {
+        if (is_1.Is.TypedArray(current) && current.length === next.length) {
+            for (let i = 0; i < current.length; i++) {
+                current[i] = next[i];
+            }
+        }
+        else {
+            pointer_1.ValuePointer.Set(root, path, clone_1.ValueClone.Clone(next));
+        }
+    }
+    function Value(root, path, current, next) {
+        if (current === next)
+            return;
+        pointer_1.ValuePointer.Set(root, path, next);
+    }
+    function Visit(root, path, current, next) {
+        if (is_1.Is.Array(next)) {
+            return Array(root, path, current, next);
+        }
+        else if (is_1.Is.TypedArray(next)) {
+            return TypedArray(root, path, current, next);
+        }
+        else if (is_1.Is.Object(next)) {
+            return Object(root, path, current, next);
+        }
+        else if (is_1.Is.Value(next)) {
+            return Value(root, path, current, next);
+        }
+    }
+    /** Performs a deep mutable value assignment while retaining internal references. */
+    function Mutate(current, next) {
+        if (is_1.Is.TypedArray(current) || is_1.Is.Value(current) || is_1.Is.TypedArray(next) || is_1.Is.Value(next)) {
+            throw new ValueMutateInvalidRootMutationError();
+        }
+        if ((is_1.Is.Object(current) && is_1.Is.Array(next)) || (is_1.Is.Array(current) && is_1.Is.Object(next))) {
+            throw new ValueMutateTypeMismatchError();
+        }
+        Visit(current, '', current, next);
+    }
+    ValueMutate.Mutate = Mutate;
+})(ValueMutate = exports.ValueMutate || (exports.ValueMutate = {}));

package/value/value.d.ts

@@ -1,5 +1,6 @@
 import * as Types from '../typebox';
 import { ValueErrorIterator } from '../errors/index';
+import { Mutable } from './mutate';
 import { Edit } from './delta';
 /** Provides functions to perform structural updates to JavaScript values */
 export declare namespace Value {
@@ -33,4 +34,6 @@ export declare namespace Value {
     function Hash(value: unknown): bigint;
     /** Returns a new value with edits applied to the given value */
     function Patch<T = any>(current: unknown, edits: Edit[]): T;
+    /** Performs a deep mutable value assignment while retaining internal references. */
+    function Mutate(current: Mutable, next: Mutable): void;
 }

package/value/value.js

@@ -29,6 +29,7 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Value = void 0;
 const index_1 = require("../errors/index");
+const mutate_1 = require("./mutate");
 const hash_1 = require("./hash");
 const equal_1 = require("./equal");
 const cast_1 = require("./cast");
@@ -90,4 +91,9 @@ var Value;
         return delta_1.ValueDelta.Patch(current, edits);
     }
     Value.Patch = Patch;
+    /** Performs a deep mutable value assignment while retaining internal references. */
+    function Mutate(current, next) {
+        mutate_1.ValueMutate.Mutate(current, next);
+    }
+    Value.Mutate = Mutate;
 })(Value = exports.Value || (exports.Value = {}));