@sinclair/typebox 0.24.40 → 0.24.42

package/package.json

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

package/readme.md

@@ -76,6 +76,7 @@ License MIT
   - [Diff](#values-diff)
   - [Patch](#values-patch)
   - [Errors](#values-errors)
+  - [Pointer](#values-pointer)
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [Compiler](#typecheck-compiler)
@@ -870,6 +871,21 @@ const R = [...Value.Errors(T, { x: '42' })]          // const R = [{
                                                      // }]
 ```
 
+<a name='values-pointer'></a>
+
+### Pointer
+
+Use ValuePointer to perform mutable updates on existing values using [RFC6901](https://www.rfc-editor.org/rfc/rfc6901) Json Pointers.
+
+```typescript
+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 }
+```
 <a name='typecheck'></a>
 
 ## TypeCheck

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';
@@ -229,15 +231,15 @@ export interface TRequired<T extends TObject | TRef<TObject>> extends TObject {
     static: Required<Static<T, this['params']>>;
 }
 export declare type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
-export interface StringOptions<TFormat extends string> extends SchemaOptions {
+export interface StringOptions<Format extends string> extends SchemaOptions {
     minLength?: number;
     maxLength?: number;
     pattern?: string;
-    format?: TFormat;
+    format?: Format;
     contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64';
     contentMediaType?: string;
 }
-export interface TString extends TSchema, StringOptions<string> {
+export interface TString<Format extends string = string> extends TSchema, StringOptions<Format> {
     [Kind]: 'String';
     static: string;
     type: 'string';
@@ -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 */
@@ -371,7 +373,7 @@ export declare class TypeBuilder {
     /** Removes Kind and Modifier symbol property keys from this schema */
     Strict<T extends TSchema>(schema: T): T;
     /** Creates a string type */
-    String<TCustomFormatOption extends string>(options?: StringOptions<StringFormatOption | TCustomFormatOption>): TString;
+    String<Format extends string>(options?: StringOptions<StringFormatOption | Format>): TString<Format>;
     /** Creates a tuple type */
     Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
     /** Creates a undefined 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,10 +1,23 @@
-/** 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 */
+    /** Formats the given pointer into navigable key components */
+    function Format(pointer: string): IterableIterator<string>;
+    /** 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: unknown): void;
+    /** Deletes a value at the given pointer */
+    function Delete(value: any, pointer: string): void;
+    /** Returns 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

@@ -27,67 +27,103 @@ 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, `/`));
+    function Escape(component) {
+        return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~');
+    }
+    /** Formats the given pointer into navigable key components */
+    function* Format(pointer) {
+        if (pointer === '')
+            return;
+        let [start, end] = [0, 0];
+        for (let i = 0; i < pointer.length; i++) {
+            const char = pointer.charAt(i);
+            if (char === '/') {
+                if (i === 0) {
+                    start = i + 1;
+                }
+                else {
+                    end = i;
+                    yield Escape(pointer.slice(start, end));
+                    start = i + 1;
+                }
+            }
+            else {
+                end = i;
+            }
+        }
+        yield Escape(pointer.slice(start));
     }
-    /** Sets the value at the given pointer. If the value at the pointer does not exist it is created. */
+    ValuePointer.Format = Format;
+    /** 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];
+            throw new ValuePointerRootSetError(value, pointer, update);
+        let [owner, next, key] = [null, value, ''];
+        for (const component of Format(pointer)) {
+            if (next[component] === undefined)
+                next[component] = {};
+            owner = next;
+            next = next[component];
+            key = component;
         }
-        current[path.shift()] = update;
+        owner[key] = update;
     }
     ValuePointer.Set = Set;
-    /** Deletes a value at the given pointer. */
+    /** 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)
+            throw new ValuePointerRootDeleteError(value, pointer);
+        let [owner, next, key] = [null, value, ''];
+        for (const component of Format(pointer)) {
+            if (next[component] === undefined || next[component] === null)
                 return;
-            current = current[next];
+            owner = next;
+            next = next[component];
+            key = component;
         }
-        if (Array.isArray(current)) {
-            const index = parseInt(path.shift());
-            return current.splice(index, 1);
+        if (globalThis.Array.isArray(owner)) {
+            const index = parseInt(key);
+            owner.splice(index, 1);
         }
         else {
-            const key = path.shift();
-            delete current[key];
+            delete owner[key];
         }
     }
     ValuePointer.Delete = Delete;
-    /** True if a value exists at the given pointer */
+    /** Returns 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)
+        let [owner, next, key] = [null, value, ''];
+        for (const component of Format(pointer)) {
+            if (next[component] === undefined)
                 return false;
-            current = current[next];
+            owner = next;
+            next = next[component];
+            key = component;
         }
-        return current[path.shift()] !== undefined;
+        return globalThis.Object.getOwnPropertyNames(owner).includes(key);
     }
     ValuePointer.Has = Has;
     /** Gets the value at the given pointer */
@@ -95,14 +131,12 @@ var ValuePointer;
         if (pointer === '')
             return value;
         let current = value;
-        const path = Format(pointer);
-        while (path.length > 1) {
-            const next = path.shift();
-            if (current[next] === undefined)
+        for (const component of Format(pointer)) {
+            if (current[component] === undefined)
                 return undefined;
-            current = current[next];
+            current = current[component];
         }
-        return current[path.shift()];
+        return current;
     }
     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) {