@sinclair/typebox 0.25.3 → 0.25.5

package/conditional/conditional.d.ts

@@ -6,7 +6,7 @@ export interface TExclude<T extends Types.TUnion, U extends Types.TUnion> extend
 export interface TExtract<T extends Types.TSchema, U extends Types.TUnion> extends Types.TUnion<any[]> {
     static: Extract<Types.Static<T, this['params']>, Types.Static<U, this['params']>>;
 }
-/** Conditional Types */
+/** Conditional type mapping for TypeBox types */
 export declare namespace Conditional {
     /** (Experimental) Creates a conditional expression type */
     function Extends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema>(left: L, right: R, ok: T, fail: U): TExtends<L, R, T, U>;

package/conditional/conditional.js

@@ -31,7 +31,7 @@ exports.Conditional = void 0;
 const Types = require("../typebox");
 const structural_1 = require("./structural");
 const index_1 = require("../guard/index");
-/** Conditional Types */
+/** Conditional type mapping for TypeBox types */
 var Conditional;
 (function (Conditional) {
     /** (Experimental) Creates a conditional expression type */

package/errors/errors.d.ts

@@ -60,6 +60,7 @@ export declare class ValueErrorsUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+/** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 export declare namespace ValueErrors {
     function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): IterableIterator<ValueError>;
 }

package/errors/errors.js

@@ -94,6 +94,7 @@ class ValueErrorsUnknownTypeError extends Error {
     }
 }
 exports.ValueErrorsUnknownTypeError = ValueErrorsUnknownTypeError;
+/** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 var ValueErrors;
 (function (ValueErrors) {
     function* Any(schema, references, path, value) { }

package/format/format.d.ts

@@ -1,5 +1,5 @@
 export declare type FormatValidationFunction = (value: string) => boolean;
-/** Shared string formats used by the TypeCompiler and Value modules */
+/** Provides functions to create custom string formats */
 export declare namespace Format {
     /** Clears all formats */
     function Clear(): void;

package/format/format.js

@@ -28,7 +28,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Format = void 0;
-/** Shared string formats used by the TypeCompiler and Value modules */
+/** Provides functions to create custom string formats */
 var Format;
 (function (Format) {
     const formats = new Map();

package/guard/guard.d.ts

@@ -3,7 +3,7 @@ export declare class TypeGuardInvalidTypeError extends Error {
     readonly schema: unknown;
     constructor(schema: unknown);
 }
-/** TypeGuard tests that values conform to a known TypeBox type specification */
+/** Provides functionality to test if values are TypeBox types */
 export declare namespace TypeGuard {
     /** Returns true if the given schema is TAny */
     function TAny(schema: unknown): schema is Types.TAny;

package/guard/guard.js

@@ -36,7 +36,7 @@ class TypeGuardInvalidTypeError extends Error {
     }
 }
 exports.TypeGuardInvalidTypeError = TypeGuardInvalidTypeError;
-/** TypeGuard tests that values conform to a known TypeBox type specification */
+/** Provides functionality to test if values are TypeBox types */
 var TypeGuard;
 (function (TypeGuard) {
     function IsObject(value) {

package/package.json

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

package/readme.md

@@ -832,7 +832,7 @@ const R = Value.Equal(                               // const R = true
 Use the Diff function to produce a sequence of edits to transform one value into another.
 
 ```typescript
-const E = Value.Diff<any>(                          // const E = [
+const E = Value.Diff(                               // const E = [
   { x: 1, y: 2, z: 3 },                             //   { type: 'update', path: '/y', value: 4 },
   { y: 4, z: 5, w: 6 }                              //   { type: 'update', path: '/z', value: 5 },
 )                                                   //   { type: 'insert', path: '/w', value: 6 },
@@ -851,12 +851,12 @@ const A = { x: 1, y: 2 }
 
 const B = { x: 3 }
 
-const E = Value.Diff<any>(A, B)                      // const E = [
+const E = Value.Diff(A, B)                           // const E = [
                                                      //   { type: 'update', path: '/x', value: 3 },
                                                      //   { type: 'delete', path: '/y' }
                                                      // ]
 
-const C = Value.Patch<any>(A, E)                     // const C = { x: 3 }
+const C = Value.Patch<typeof B>(A, E)                // const C = { x: 3 }
 ```
 
 

package/value/delta.d.ts

@@ -1,22 +1,43 @@
-export declare type Edit<T = unknown> = Insert<T> | Update<T> | Delete<T>;
-export interface Insert<T> {
-    brand: T;
-    type: 'insert';
-    path: string;
-    value: any;
+import { Static } from '../typebox';
+export declare type Insert = Static<typeof Insert>;
+export declare const Insert: import("../typebox").TObject<{
+    type: import("../typebox").TLiteral<"insert">;
+    path: import("../typebox").TString<string>;
+    value: import("../typebox").TUnknown;
+}>;
+export declare type Update = Static<typeof Update>;
+export declare const Update: import("../typebox").TObject<{
+    type: import("../typebox").TLiteral<"update">;
+    path: import("../typebox").TString<string>;
+    value: import("../typebox").TUnknown;
+}>;
+export declare type Delete = Static<typeof Delete>;
+export declare const Delete: import("../typebox").TObject<{
+    type: import("../typebox").TLiteral<"delete">;
+    path: import("../typebox").TString<string>;
+}>;
+export declare type Edit = Static<typeof Edit>;
+export declare const Edit: import("../typebox").TUnion<[import("../typebox").TObject<{
+    type: import("../typebox").TLiteral<"insert">;
+    path: import("../typebox").TString<string>;
+    value: import("../typebox").TUnknown;
+}>, import("../typebox").TObject<{
+    type: import("../typebox").TLiteral<"update">;
+    path: import("../typebox").TString<string>;
+    value: import("../typebox").TUnknown;
+}>, import("../typebox").TObject<{
+    type: import("../typebox").TLiteral<"delete">;
+    path: import("../typebox").TString<string>;
+}>]>;
+export declare class ValueDeltaObjectWithSymbolKeyError extends Error {
+    readonly key: unknown;
+    constructor(key: unknown);
 }
-export interface Update<T> {
-    brand: T;
-    type: 'update';
-    path: string;
-    value: any;
-}
-export interface Delete<T> {
-    brand: T;
-    type: 'delete';
-    path: string;
+export declare class ValueDeltaUnableToDiffUnknownValue extends Error {
+    readonly value: unknown;
+    constructor(value: unknown);
 }
 export declare namespace ValueDelta {
-    function Diff<T>(current: T, next: T): Edit<T>[];
-    function Patch<T>(current: T, edits: Edit<T>[]): T;
+    function Diff(current: unknown, next: unknown): Edit[];
+    function Patch<T = any>(current: unknown, edits: Edit[]): T;
 }

package/value/delta.js

@@ -27,10 +27,46 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueDelta = void 0;
+exports.ValueDelta = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Edit = exports.Delete = exports.Update = exports.Insert = void 0;
+const typebox_1 = require("../typebox");
 const is_1 = require("./is");
 const clone_1 = require("./clone");
 const pointer_1 = require("./pointer");
+exports.Insert = typebox_1.Type.Object({
+    type: typebox_1.Type.Literal('insert'),
+    path: typebox_1.Type.String(),
+    value: typebox_1.Type.Unknown(),
+});
+exports.Update = typebox_1.Type.Object({
+    type: typebox_1.Type.Literal('update'),
+    path: typebox_1.Type.String(),
+    value: typebox_1.Type.Unknown(),
+});
+exports.Delete = typebox_1.Type.Object({
+    type: typebox_1.Type.Literal('delete'),
+    path: typebox_1.Type.String(),
+});
+exports.Edit = typebox_1.Type.Union([exports.Insert, exports.Update, exports.Delete]);
+// ---------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------
+class ValueDeltaObjectWithSymbolKeyError extends Error {
+    constructor(key) {
+        super('ValueDelta: Cannot diff objects with symbol keys');
+        this.key = key;
+    }
+}
+exports.ValueDeltaObjectWithSymbolKeyError = ValueDeltaObjectWithSymbolKeyError;
+class ValueDeltaUnableToDiffUnknownValue extends Error {
+    constructor(value) {
+        super('ValueDelta: Unable to create diff edits for unknown value');
+        this.value = value;
+    }
+}
+exports.ValueDeltaUnableToDiffUnknownValue = ValueDeltaUnableToDiffUnknownValue;
+// ---------------------------------------------------------------------
+// ValueDelta
+// ---------------------------------------------------------------------
 var ValueDelta;
 (function (ValueDelta) {
     // ---------------------------------------------------------------------
@@ -55,7 +91,7 @@ var ValueDelta;
         const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
         for (const key of currentKeys) {
             if (typeof key === 'symbol')
-                throw Error('ValueDelta: Cannot produce diff symbol keys');
+                throw new ValueDeltaObjectWithSymbolKeyError(key);
             if (next[key] === undefined && nextKeys.includes(key))
                 yield Update(`${path}/${String(key)}`, undefined);
         }
@@ -63,27 +99,22 @@ var ValueDelta;
             if (current[key] === undefined || next[key] === undefined)
                 continue;
             if (typeof key === 'symbol')
-                throw Error('ValueDelta: Cannot produce diff symbol keys');
+                throw new ValueDeltaObjectWithSymbolKeyError(key);
             yield* Visit(`${path}/${String(key)}`, current[key], next[key]);
         }
         for (const key of nextKeys) {
             if (typeof key === 'symbol')
-                throw Error('ValueDelta: Cannot produce diff symbol keys');
+                throw new ValueDeltaObjectWithSymbolKeyError(key);
             if (current[key] === undefined)
                 yield Insert(`${path}/${String(key)}`, next[key]);
         }
         for (const key of currentKeys.reverse()) {
             if (typeof key === 'symbol')
-                throw Error('ValueDelta: Cannot produce diff symbol keys');
+                throw new ValueDeltaObjectWithSymbolKeyError(key);
             if (next[key] === undefined && !nextKeys.includes(key))
                 yield Delete(`${path}/${String(key)}`);
         }
     }
-    function* Date(path, current, next) {
-        if (is_1.Is.Date(next) && current.getTime() === next.getTime())
-            return;
-        yield Update(path, next);
-    }
     function* Array(path, current, next) {
         if (!is_1.Is.Array(next))
             return yield Update(path, next);
@@ -117,9 +148,6 @@ var ValueDelta;
         if (is_1.Is.Object(current)) {
             return yield* Object(path, current, next);
         }
-        else if (is_1.Is.Date(current)) {
-            return yield* Date(path, current, next);
-        }
         else if (is_1.Is.Array(current)) {
             return yield* Array(path, current, next);
         }
@@ -130,7 +158,7 @@ var ValueDelta;
             return yield* Value(path, current, next);
         }
         else {
-            throw new Error('ValueDelta: Cannot produce edits for value');
+            throw new ValueDeltaUnableToDiffUnknownValue(current);
         }
     }
     function Diff(current, next) {

package/value/pointer.d.ts

@@ -9,7 +9,7 @@ export declare class ValuePointerRootDeleteError extends Error {
     readonly path: string;
     constructor(value: unknown, path: string);
 }
-/** ValuePointer performs mutable operations on values using RFC6901 Json Pointers */
+/** Provides functionality to update values through RFC6901 string pointers */
 export declare namespace ValuePointer {
     /** Formats the given pointer into navigable key components */
     function Format(pointer: string): IterableIterator<string>;

package/value/pointer.js

@@ -45,7 +45,7 @@ class ValuePointerRootDeleteError extends Error {
     }
 }
 exports.ValuePointerRootDeleteError = ValuePointerRootDeleteError;
-/** ValuePointer performs mutable operations on values using RFC6901 Json Pointers */
+/** Provides functionality to update values through RFC6901 string pointers */
 var ValuePointer;
 (function (ValuePointer) {
     function Escape(component) {

package/value/value.d.ts

@@ -1,8 +1,8 @@
 import * as Types from '../typebox';
 import { ValueError } from '../errors/index';
 import { Edit } from './delta';
-export type { Edit } from './delta';
-/** Value performs immutable operations on values */
+export { Edit, Insert, Update, Delete } from './delta';
+/** Provides functions to perform structural updates to JavaScript 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>;
@@ -25,7 +25,7 @@ export declare namespace Value {
     /** Returns a structural clone of the given value */
     function Clone<T>(value: T): T;
     /** Returns edits to transform the current value into the next value */
-    function Diff<T>(current: T, next: T): Edit<T>[];
+    function Diff(current: unknown, next: unknown): Edit[];
     /** Returns a new value with edits applied to the given value */
-    function Patch<T>(current: T, edits: Edit<T>[]): T;
+    function Patch<T = any>(current: unknown, edits: Edit[]): T;
 }

package/value/value.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Value = void 0;
+exports.Value = exports.Delete = exports.Update = exports.Insert = exports.Edit = void 0;
 const index_1 = require("../errors/index");
 const equal_1 = require("./equal");
 const cast_1 = require("./cast");
@@ -35,7 +35,12 @@ const clone_1 = require("./clone");
 const create_1 = require("./create");
 const check_1 = require("./check");
 const delta_1 = require("./delta");
-/** Value performs immutable operations on values */
+var delta_2 = require("./delta");
+Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return delta_2.Edit; } });
+Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return delta_2.Insert; } });
+Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return delta_2.Update; } });
+Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return delta_2.Delete; } });
+/** Provides functions to perform structural updates to JavaScript values */
 var Value;
 (function (Value) {
     function Cast(...args) {