@sinclair/typebox 0.26.8 → 0.27.1

package/value/check.js

@@ -315,13 +315,6 @@ var ValueCheck;
         const target = references[index];
         return Visit(target, references, value);
     }
-    function Self(schema, references, value) {
-        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-        if (index === -1)
-            throw new ValueCheckDereferenceError(schema);
-        const target = references[index];
-        return Visit(target, references, value);
-    }
     function String(schema, references, value) {
         if (!IsString(value)) {
             return false;
@@ -353,6 +346,19 @@ var ValueCheck;
         }
         return true;
     }
+    function TemplateLiteral(schema, references, value) {
+        if (!IsString(value)) {
+            return false;
+        }
+        return new RegExp(schema.pattern).test(value);
+    }
+    function This(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueCheckDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
     function Tuple(schema, references, value) {
         if (!globalThis.Array.isArray(value)) {
             return false;
@@ -442,12 +448,14 @@ var ValueCheck;
                 return Record(schema_, references_, value);
             case 'Ref':
                 return Ref(schema_, references_, value);
-            case 'Self':
-                return Self(schema_, references_, value);
             case 'String':
                 return String(schema_, references_, value);
             case 'Symbol':
                 return Symbol(schema_, references_, value);
+            case 'TemplateLiteral':
+                return TemplateLiteral(schema_, references_, value);
+            case 'This':
+                return This(schema_, references_, value);
             case 'Tuple':
                 return Tuple(schema_, references_, value);
             case 'Undefined':

package/value/convert.d.ts

@@ -4,8 +4,8 @@ export declare class ValueConvertUnknownTypeError extends Error {
     constructor(schema: Types.TSchema);
 }
 export declare class ValueConvertDereferenceError extends Error {
-    readonly schema: Types.TRef | Types.TSelf;
-    constructor(schema: Types.TRef | Types.TSelf);
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
 }
 export declare namespace ValueConvert {
     function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): unknown;

package/value/convert.js

@@ -252,19 +252,22 @@ var ValueConvert;
         const target = references[index];
         return Visit(target, references, value);
     }
-    function Self(schema, references, value) {
-        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-        if (index === -1)
-            throw new ValueConvertDereferenceError(schema);
-        const target = references[index];
-        return Visit(target, references, value);
-    }
     function String(schema, references, value) {
         return TryConvertString(value);
     }
     function Symbol(schema, references, value) {
         return value;
     }
+    function TemplateLiteral(schema, references, value) {
+        return value;
+    }
+    function This(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueConvertDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
     function Tuple(schema, references, value) {
         if (IsArray(value) && schema.items !== undefined) {
             return value.map((value, index) => {
@@ -335,12 +338,14 @@ var ValueConvert;
                 return Record(schema_, references_, value);
             case 'Ref':
                 return Ref(schema_, references_, value);
-            case 'Self':
-                return Self(schema_, references_, value);
             case 'String':
                 return String(schema_, references_, value);
             case 'Symbol':
                 return Symbol(schema_, references_, value);
+            case 'TemplateLiteral':
+                return TemplateLiteral(schema_, references_, value);
+            case 'This':
+                return This(schema_, references_, value);
             case 'Tuple':
                 return Tuple(schema_, references_, value);
             case 'Undefined':

package/value/create.d.ts

@@ -11,9 +11,13 @@ export declare class ValueCreateIntersectTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare class ValueCreateTempateLiteralTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare class ValueCreateDereferenceError extends Error {
-    readonly schema: Types.TRef | Types.TSelf;
-    constructor(schema: Types.TRef | Types.TSelf);
+    readonly schema: Types.TRef | Types.TThis;
+    constructor(schema: Types.TRef | Types.TThis);
 }
 export declare namespace ValueCreate {
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */

package/value/create.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = exports.ValueCreateDereferenceError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
+exports.ValueCreate = exports.ValueCreateDereferenceError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
 const Types = require("../typebox");
 const check_1 = require("./check");
 // --------------------------------------------------------------------------
@@ -54,6 +54,13 @@ class ValueCreateIntersectTypeError extends Error {
     }
 }
 exports.ValueCreateIntersectTypeError = ValueCreateIntersectTypeError;
+class ValueCreateTempateLiteralTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Can only create template literal values from patterns that produce finite sequences. Consider using a default value.');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateTempateLiteralTypeError = ValueCreateTempateLiteralTypeError;
 class ValueCreateDereferenceError extends Error {
     constructor(schema) {
         super(`ValueCreate: Unable to dereference schema with $id '${schema.$ref}'`);
@@ -241,7 +248,7 @@ var ValueCreate;
         if ('default' in schema) {
             return schema.default;
         }
-        else if (!(keyPattern === '^.*$' || keyPattern === '^(0|[1-9][0-9]*)$')) {
+        else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
             const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
             return propertyKeys.reduce((acc, key) => {
                 return { ...acc, [key]: Create(valueSchema, references) };
@@ -263,18 +270,6 @@ var ValueCreate;
             return Visit(target, references);
         }
     }
-    function Self(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            const index = references.findIndex((foreign) => foreign.$id === schema.$id);
-            if (index === -1)
-                throw new ValueCreateDereferenceError(schema);
-            const target = references[index];
-            return Visit(target, references);
-        }
-    }
     function String(schema, references) {
         if (schema.pattern !== undefined) {
             if (!('default' in schema)) {
@@ -317,6 +312,28 @@ var ValueCreate;
             return globalThis.Symbol();
         }
     }
+    function TemplateLiteral(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        const expression = Types.TemplateLiteralParser.ParseExact(schema.pattern);
+        if (!Types.TemplateLiteralFinite.Check(expression))
+            throw new ValueCreateTempateLiteralTypeError(schema);
+        const sequence = Types.TemplateLiteralGenerator.Generate(expression);
+        return sequence.next().value;
+    }
+    function This(schema, references) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            const index = references.findIndex((foreign) => foreign.$id === schema.$id);
+            if (index === -1)
+                throw new ValueCreateDereferenceError(schema);
+            const target = references[index];
+            return Visit(target, references);
+        }
+    }
     function Tuple(schema, references) {
         if ('default' in schema) {
             return schema.default;
@@ -423,12 +440,14 @@ var ValueCreate;
                 return Record(schema_, references_);
             case 'Ref':
                 return Ref(schema_, references_);
-            case 'Self':
-                return Self(schema_, references_);
             case 'String':
                 return String(schema_, references_);
             case 'Symbol':
                 return Symbol(schema_, references_);
+            case 'TemplateLiteral':
+                return TemplateLiteral(schema_, references_);
+            case 'This':
+                return This(schema_, references_);
             case 'Tuple':
                 return Tuple(schema_, references_);
             case 'Undefined':

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 = {}));