@sinclair/typebox 0.24.41 → 0.24.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.41",
+  "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

@@ -231,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';
@@ -373,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/pointer.d.ts

@@ -11,12 +11,14 @@ export declare class ValuePointerRootDeleteError extends Error {
 }
 /** 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: 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;
+    /** 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

@@ -48,101 +48,95 @@ exports.ValuePointerRootDeleteError = ValuePointerRootDeleteError;
 /** ValuePointer performs mutable operations on values using RFC6901 Json Pointers */
 var ValuePointer;
 (function (ValuePointer) {
-    /** 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);
+    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) {
-                    yield chars.join('');
-                    clear(chars);
+                if (i === 0) {
+                    start = i + 1;
+                }
+                else {
+                    end = i;
+                    yield Escape(pointer.slice(start, end));
+                    start = i + 1;
                 }
-            }
-            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);
+                end = i;
             }
         }
-        yield chars.join('');
-        clear(chars);
+        yield Escape(pointer.slice(start));
     }
-    /** Sets the value at the given pointer. If the value at the pointer does not exist it is created. */
-    function Set(value, path, update) {
-        if (path === '')
-            throw new ValuePointerRootSetError(value, path, update);
-        const pointer = [...Format(path)];
-        let current = value;
-        while (pointer.length > 1) {
-            const next = pointer.shift();
-            if (current[next] === undefined)
-                current[next] = {};
-            current = current[next];
+    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 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[pointer.shift()] = update;
+        owner[key] = update;
     }
     ValuePointer.Set = Set;
-    /** Deletes a value at the given path. */
-    function Delete(value, path) {
-        if (path === '')
-            throw new ValuePointerRootDeleteError(value, path);
-        let current = value;
-        const pointer = [...Format(path)];
-        while (pointer.length > 1) {
-            const next = pointer.shift();
-            if (current[next] === undefined)
+    /** Deletes a value at the given pointer */
+    function Delete(value, pointer) {
+        if (pointer === '')
+            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 (globalThis.Array.isArray(current)) {
-            const index = parseInt(pointer.shift());
-            return current.splice(index, 1);
+        if (globalThis.Array.isArray(owner)) {
+            const index = parseInt(key);
+            owner.splice(index, 1);
         }
         else {
-            const key = pointer.shift();
-            delete current[key];
+            delete owner[key];
         }
     }
     ValuePointer.Delete = Delete;
-    /** True if a value exists at the given path */
-    function Has(value, path) {
-        if (path === '')
+    /** Returns true if a value exists at the given pointer */
+    function Has(value, pointer) {
+        if (pointer === '')
             return true;
-        let current = value;
-        const pointer = [...Format(path)];
-        while (pointer.length > 1) {
-            const next = pointer.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[pointer.shift()] !== undefined;
+        return globalThis.Object.getOwnPropertyNames(owner).includes(key);
     }
     ValuePointer.Has = Has;
-    /** Gets the value at the given path */
-    function Get(value, path) {
-        if (path === '')
+    /** Gets the value at the given pointer */
+    function Get(value, pointer) {
+        if (pointer === '')
             return value;
         let current = value;
-        const pointer = [...Format(path)];
-        while (pointer.length > 1) {
-            const next = pointer.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[pointer.shift()];
+        return current;
     }
     ValuePointer.Get = Get;
 })(ValuePointer = exports.ValuePointer || (exports.ValuePointer = {}));