@sinclair/typebox 0.24.40 → 0.24.41

package/package.json

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

package/typebox.d.ts

@@ -116,9 +116,11 @@ export declare type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? []
 export declare type UnionStringLiteralToTuple<T> = T extends TUnion<infer L> ? {
     [I in keyof L]: L[I] extends TLiteral<infer C> ? C : never;
 } : never;
-export declare type TKeyOf<T extends TObject> = {
+export declare type UnionLiteralsFromObject<T extends TObject> = {
     [K in ObjectPropertyKeys<T>]: TLiteral<K>;
 } extends infer R ? UnionToTuple<R[keyof R]> : never;
+export interface TKeyOf<T extends TObject> extends TUnion<UnionLiteralsFromObject<T>> {
+}
 export declare type TLiteralValue = string | number | boolean;
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
     [Kind]: 'Literal';
@@ -329,7 +331,7 @@ export declare class TypeBuilder {
     /** Creates a intersect type. */
     Intersect<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TIntersect<T>;
     /** Creates a keyof type */
-    KeyOf<T extends TObject>(object: T, options?: SchemaOptions): TUnion<TKeyOf<T>>;
+    KeyOf<T extends TObject>(object: T, options?: SchemaOptions): TKeyOf<T>;
     /** Creates a literal type. */
     Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
     /** Creates a never type */

package/value/cast.js

@@ -31,6 +31,7 @@ exports.ValueCast = exports.ValueCastUnknownTypeError = exports.ValueCastRecursi
 const Types = require("../typebox");
 const create_1 = require("./create");
 const check_1 = require("./check");
+const clone_1 = require("./clone");
 var UnionValueCast;
 (function (UnionValueCast) {
     // ----------------------------------------------------------------------------------------------
@@ -68,7 +69,7 @@ var UnionValueCast;
         return select;
     }
     function Create(union, references, value) {
-        return check_1.ValueCheck.Check(union, references, value) ? value : ValueCast.Cast(Select(union, references, value), references, value);
+        return check_1.ValueCheck.Check(union, references, value) ? clone_1.ValueClone.Clone(value) : ValueCast.Cast(Select(union, references, value), references, value);
     }
     UnionValueCast.Create = Create;
 })(UnionValueCast || (UnionValueCast = {}));
@@ -166,8 +167,8 @@ var ValueCast;
     }
     function Array(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
-            return value;
-        const created = IsArray(value) ? value : create_1.ValueCreate.Create(schema, references);
+            return clone_1.ValueClone.Clone(value);
+        const created = IsArray(value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
         const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...globalThis.Array.from({ length: schema.minItems - created.length }, () => null)] : created;
         const maximum = IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
         const casted = maximum.map((value) => Visit(schema.items, references, value));
@@ -219,7 +220,7 @@ var ValueCast;
     }
     function Object(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
-            return value;
+            return clone_1.ValueClone.Clone(value);
         if (value === null || typeof value !== 'object')
             return create_1.ValueCreate.Create(schema, references);
         const required = new Set(schema.required || []);
@@ -236,7 +237,7 @@ var ValueCast;
     }
     function Record(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
-            return value;
+            return clone_1.ValueClone.Clone(value);
         if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value))
             return create_1.ValueCreate.Create(schema, references);
         const subschemaKey = globalThis.Object.keys(schema.patternProperties)[0];
@@ -268,7 +269,7 @@ var ValueCast;
     }
     function Tuple(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
-            return value;
+            return clone_1.ValueClone.Clone(value);
         if (!globalThis.Array.isArray(value))
             return create_1.ValueCreate.Create(schema, references);
         if (schema.items === undefined)

package/value/index.d.ts

@@ -1,2 +1,3 @@
 export { ValueError, ValueErrorType } from '../errors/index';
+export * from './pointer';
 export * from './value';

package/value/index.js

@@ -44,4 +44,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueErrorType = void 0;
 var index_1 = require("../errors/index");
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
+__exportStar(require("./pointer"), exports);
 __exportStar(require("./value"), exports);

package/value/pointer.d.ts

@@ -1,11 +1,22 @@
-/** RFC6901 JsonPointer */
+export declare class ValuePointerRootSetError extends Error {
+    readonly value: unknown;
+    readonly path: string;
+    readonly update: unknown;
+    constructor(value: unknown, path: string, update: unknown);
+}
+export declare class ValuePointerRootDeleteError extends Error {
+    readonly value: unknown;
+    readonly path: string;
+    constructor(value: unknown, path: string);
+}
+/** ValuePointer performs mutable operations on values using RFC6901 Json Pointers */
 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;
+    function Set(value: unknown, path: string, update: unknown): void;
+    /** Deletes a value at the given path. */
+    function Delete(value: any, path: string): any[] | undefined;
+    /** True if a value exists at the given path */
+    function Has(value: any, path: string): boolean;
+    /** Gets the value at the given path */
+    function Get(value: any, path: string): any;
 }

package/value/pointer.js

@@ -27,82 +27,122 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValuePointer = void 0;
-/** RFC6901 JsonPointer */
+exports.ValuePointer = exports.ValuePointerRootDeleteError = exports.ValuePointerRootSetError = void 0;
+class ValuePointerRootSetError extends Error {
+    constructor(value, path, update) {
+        super('ValuePointer: Cannot set root value');
+        this.value = value;
+        this.path = path;
+        this.update = update;
+    }
+}
+exports.ValuePointerRootSetError = ValuePointerRootSetError;
+class ValuePointerRootDeleteError extends Error {
+    constructor(value, path) {
+        super('ValuePointer: Cannot delete root value');
+        this.value = value;
+        this.path = path;
+    }
+}
+exports.ValuePointerRootDeleteError = ValuePointerRootDeleteError;
+/** ValuePointer performs mutable operations on values using RFC6901 Json Pointers */
 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, `/`));
+    /** Formats the path into navigable components */
+    function* Format(path) {
+        function clear(chars) {
+            while (chars.length > 0)
+                chars.shift();
+        }
+        const chars = [];
+        for (let i = 0; i < path.length; i++) {
+            const char = path.charAt(i);
+            if (char === '/') {
+                if (i !== 0) {
+                    yield chars.join('');
+                    clear(chars);
+                }
+            }
+            else if (char === '~' && path.charAt(i + 1) === '0' && (path.charAt(i + 2) === '/' || i !== path.length - 1)) {
+                chars.push('~');
+                i += 1;
+            }
+            else if (char === '~' && path.charAt(i + 1) === '1' && (path.charAt(i + 2) === '/' || i !== path.length - 1)) {
+                chars.push('/');
+                i += 1;
+            }
+            else {
+                chars.push(char);
+            }
+        }
+        yield chars.join('');
+        clear(chars);
     }
     /** 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);
+    function Set(value, path, update) {
+        if (path === '')
+            throw new ValuePointerRootSetError(value, path, update);
+        const pointer = [...Format(path)];
         let current = value;
-        while (path.length > 1) {
-            const next = path.shift();
+        while (pointer.length > 1) {
+            const next = pointer.shift();
             if (current[next] === undefined)
                 current[next] = {};
             current = current[next];
         }
-        current[path.shift()] = update;
+        current[pointer.shift()] = update;
     }
     ValuePointer.Set = Set;
-    /** Deletes a value at the given pointer. */
-    function Delete(value, pointer) {
-        if (pointer === '')
-            throw Error('Cannot delete root value');
+    /** Deletes a value at the given path. */
+    function Delete(value, path) {
+        if (path === '')
+            throw new ValuePointerRootDeleteError(value, path);
         let current = value;
-        const path = Format(pointer);
-        while (path.length > 1) {
-            const next = path.shift();
+        const pointer = [...Format(path)];
+        while (pointer.length > 1) {
+            const next = pointer.shift();
             if (current[next] === undefined)
                 return;
             current = current[next];
         }
-        if (Array.isArray(current)) {
-            const index = parseInt(path.shift());
+        if (globalThis.Array.isArray(current)) {
+            const index = parseInt(pointer.shift());
             return current.splice(index, 1);
         }
         else {
-            const key = path.shift();
+            const key = pointer.shift();
             delete current[key];
         }
     }
     ValuePointer.Delete = Delete;
-    /** True if a value exists at the given pointer */
-    function Has(value, pointer) {
-        if (pointer === '')
+    /** True if a value exists at the given path */
+    function Has(value, path) {
+        if (path === '')
             return true;
         let current = value;
-        const path = Format(pointer);
-        while (path.length > 1) {
-            const next = path.shift();
+        const pointer = [...Format(path)];
+        while (pointer.length > 1) {
+            const next = pointer.shift();
             if (current[next] === undefined)
                 return false;
             current = current[next];
         }
-        return current[path.shift()] !== undefined;
+        return current[pointer.shift()] !== undefined;
     }
     ValuePointer.Has = Has;
-    /** Gets the value at the given pointer */
-    function Get(value, pointer) {
-        if (pointer === '')
+    /** Gets the value at the given path */
+    function Get(value, path) {
+        if (path === '')
             return value;
         let current = value;
-        const path = Format(pointer);
-        while (path.length > 1) {
-            const next = path.shift();
+        const pointer = [...Format(path)];
+        while (pointer.length > 1) {
+            const next = pointer.shift();
             if (current[next] === undefined)
                 return undefined;
             current = current[next];
         }
-        return current[path.shift()];
+        return current[pointer.shift()];
     }
     ValuePointer.Get = Get;
 })(ValuePointer = exports.ValuePointer || (exports.ValuePointer = {}));

package/value/value.d.ts

@@ -2,7 +2,7 @@ import * as Types from '../typebox';
 import { ValueError } from '../errors/index';
 import { Edit } from './delta';
 export type { Edit } from './delta';
-/** The Value namespace provides type operations on values */
+/** Value performs immutable 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>;

package/value/value.js

@@ -35,7 +35,7 @@ const clone_1 = require("./clone");
 const create_1 = require("./create");
 const check_1 = require("./check");
 const delta_1 = require("./delta");
-/** The Value namespace provides type operations on values */
+/** Value performs immutable operations on values */
 var Value;
 (function (Value) {
     function Cast(...args) {