@sinclair/typebox 0.25.2 → 0.25.4

package/package.json

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

@@ -32,50 +32,9 @@ const Types = require("../typebox");
 const create_1 = require("./create");
 const check_1 = require("./check");
 const clone_1 = require("./clone");
-var UnionValueCast;
-(function (UnionValueCast) {
-    // ----------------------------------------------------------------------------------------------
-    // The following will score a schema against a value. For objects, the score is the tally of
-    // points awarded for each property of the value. Property points are (1.0 / propertyCount)
-    // to prevent large property counts biasing results. Properties that match literal values are
-    // maximally awarded as literals are typically used as union discriminator fields.
-    // ----------------------------------------------------------------------------------------------
-    function Score(schema, references, value) {
-        if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
-            const object = schema;
-            const keys = Object.keys(value);
-            const entries = globalThis.Object.entries(object.properties);
-            const [point, max] = [1 / entries.length, entries.length];
-            return entries.reduce((acc, [key, schema]) => {
-                const literal = schema[Types.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
-                const checks = check_1.ValueCheck.Check(schema, references, value[key]) ? point : 0;
-                const exists = keys.includes(key) ? point : 0;
-                return acc + (literal + checks + exists);
-            }, 0);
-        }
-        else {
-            return check_1.ValueCheck.Check(schema, references, value) ? 1 : 0;
-        }
-    }
-    function Select(union, references, value) {
-        let [select, best] = [union.anyOf[0], 0];
-        for (const schema of union.anyOf) {
-            const score = Score(schema, references, value);
-            if (score > best) {
-                select = schema;
-                best = score;
-            }
-        }
-        return select;
-    }
-    function Create(union, 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 = {}));
-// -----------------------------------------------------------
+// ----------------------------------------------------------------------------------------------
 // Errors
-// -----------------------------------------------------------
+// ----------------------------------------------------------------------------------------------
 class ValueCastReferenceTypeError extends Error {
     constructor(schema) {
         super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`);
@@ -112,11 +71,58 @@ class ValueCastUnknownTypeError extends Error {
     }
 }
 exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
+// ----------------------------------------------------------------------------------------------
+// The following will score a schema against a value. For objects, the score is the tally of
+// points awarded for each property of the value. Property points are (1.0 / propertyCount)
+// to prevent large property counts biasing results. Properties that match literal values are
+// maximally awarded as literals are typically used as union discriminator fields.
+// ----------------------------------------------------------------------------------------------
+var UnionCastCreate;
+(function (UnionCastCreate) {
+    function Score(schema, references, value) {
+        if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
+            const object = schema;
+            const keys = Object.keys(value);
+            const entries = globalThis.Object.entries(object.properties);
+            const [point, max] = [1 / entries.length, entries.length];
+            return entries.reduce((acc, [key, schema]) => {
+                const literal = schema[Types.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
+                const checks = check_1.ValueCheck.Check(schema, references, value[key]) ? point : 0;
+                const exists = keys.includes(key) ? point : 0;
+                return acc + (literal + checks + exists);
+            }, 0);
+        }
+        else {
+            return check_1.ValueCheck.Check(schema, references, value) ? 1 : 0;
+        }
+    }
+    function Select(union, references, value) {
+        let [select, best] = [union.anyOf[0], 0];
+        for (const schema of union.anyOf) {
+            const score = Score(schema, references, value);
+            if (score > best) {
+                select = schema;
+                best = score;
+            }
+        }
+        return select;
+    }
+    function Create(union, references, value) {
+        if (union.default !== undefined) {
+            return union.default;
+        }
+        else {
+            const schema = Select(union, references, value);
+            return ValueCast.Cast(schema, references, value);
+        }
+    }
+    UnionCastCreate.Create = Create;
+})(UnionCastCreate || (UnionCastCreate = {}));
 var ValueCast;
 (function (ValueCast) {
-    // -----------------------------------------------------------
+    // ----------------------------------------------------------------------------------------------
     // Guards
-    // -----------------------------------------------------------
+    // ----------------------------------------------------------------------------------------------
     function IsArray(value) {
         return typeof value === 'object' && globalThis.Array.isArray(value);
     }
@@ -144,9 +150,9 @@ var ValueCast;
     function IsValueFalse(value) {
         return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === 0n) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'));
     }
-    // -----------------------------------------------------------
+    // ----------------------------------------------------------------------------------------------
     // Convert
-    // -----------------------------------------------------------
+    // ----------------------------------------------------------------------------------------------
     function TryConvertString(value) {
         return IsValueToString(value) ? value.toString() : value;
     }
@@ -159,11 +165,11 @@ var ValueCast;
     function TryConvertBoolean(value) {
         return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
     }
-    // -----------------------------------------------------------
+    // ----------------------------------------------------------------------------------------------
     // Cast
-    // -----------------------------------------------------------
+    // ----------------------------------------------------------------------------------------------
     function Any(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
     function Array(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
@@ -198,9 +204,6 @@ var ValueCast;
     function Date(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
-    function Enum(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
-    }
     function Function(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
@@ -209,13 +212,13 @@ var ValueCast;
         return check_1.ValueCheck.Check(schema, references, conversion) ? conversion : create_1.ValueCreate.Create(schema, references);
     }
     function Literal(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
     function Never(schema, references, value) {
         throw new ValueCastNeverTypeError(schema);
     }
     function Null(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
     function Number(schema, references, value) {
         const conversion = TryConvertNumber(value);
@@ -289,19 +292,19 @@ var ValueCast;
         return schema.items.map((schema, index) => Visit(schema, references, value[index]));
     }
     function Undefined(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
     function Union(schema, references, value) {
-        return UnionValueCast.Create(schema, references, value);
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : UnionCastCreate.Create(schema, references, value);
     }
     function Uint8Array(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
     function Unknown(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
     function Void(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
     function Visit(schema, references, value) {
         const anyReferences = schema.$id === undefined ? references : [schema, ...references];
@@ -317,8 +320,6 @@ var ValueCast;
                 return Constructor(anySchema, anyReferences, value);
             case 'Date':
                 return Date(anySchema, anyReferences, value);
-            case 'Enum':
-                return Enum(anySchema, anyReferences, value);
             case 'Function':
                 return Function(anySchema, anyReferences, value);
             case 'Integer':

package/value/create.js

@@ -110,17 +110,6 @@ var ValueCreate;
             return new globalThis.Date(0);
         }
     }
-    function Enum(schema, references) {
-        if (schema.default !== undefined) {
-            return schema.default;
-        }
-        else if (schema.anyOf.length === 0) {
-            throw new Error('ValueCreate.Enum: Cannot create default enum value as this enum has no items');
-        }
-        else {
-            return schema.anyOf[0].const;
-        }
-    }
     function Function(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
@@ -318,8 +307,6 @@ var ValueCreate;
                 return Constructor(anySchema, anyReferences);
             case 'Date':
                 return Date(anySchema, anyReferences);
-            case 'Enum':
-                return Enum(anySchema, anyReferences);
             case 'Function':
                 return Function(anySchema, anyReferences);
             case 'Integer':

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