@sinclair/typebox 0.25.3 → 0.25.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.3",
+  "version": "0.25.4",
   "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/value.d.ts

@@ -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;
 }