@arcanejs/diff 0.1.4 → 0.3.0

package/dist/chunk-KAHL2YAL.mjs

@@ -0,0 +1,52 @@
+// src/patch.ts
+var patchJson = (old, diff) => {
+  if (diff.type === "match") {
+    return old;
+  }
+  if (diff.type === "value") {
+    return diff.after;
+  }
+  if (diff.type === "splice") {
+    if (!Array.isArray(old)) {
+      throw new Error("Cannot apply splice diff to non-array value");
+    }
+    const result = [...old];
+    result.splice(diff.start, diff.count, ...diff.items);
+    return result;
+  }
+  if (diff.type === "modified-a") {
+    if (!Array.isArray(old)) {
+      throw new Error("Cannot apply changes diff to non-array value");
+    }
+    const result = [...old];
+    for (const { i, diff: d } of diff.changes) {
+      result[i] = patchJson(old[i], d);
+    }
+    return result;
+  }
+  if (Array.isArray(old)) {
+    throw new Error("Unexpected array type");
+  }
+  if (diff.type === "modified-o") {
+    if (typeof old !== "object" || old === null) {
+      throw new Error("Cannot apply modified diff to non-object value");
+    }
+    const result = { ...old, ...diff.additions };
+    for (const key of Object.keys(diff.changes || {})) {
+      const changes = diff.changes?.[key];
+      if (changes) {
+        result[key] = patchJson(old[key], changes);
+      }
+    }
+    for (const keu of Object.keys(diff.deletions || {})) {
+      delete result[keu];
+    }
+    return result;
+  }
+  const _n = diff;
+  throw new Error(`Unknown diff type: ${_n}`);
+};
+
+export {
+  patchJson
+};

package/dist/chunk-SZTK7XV4.mjs

@@ -0,0 +1,81 @@
+// src/diff.ts
+var jsonTypeMatches = (a, b) => typeof a === typeof b && Array.isArray(a) === Array.isArray(b) && a === null === (b === null);
+var diffJson = (a, b) => {
+  if (a === b) {
+    return { type: "match" };
+  }
+  if (!jsonTypeMatches(a, b)) {
+    throw new Error("Types don't match, unable to diff");
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length === b.length) {
+      const changes = [];
+      for (let i = 0; i < a.length; i++) {
+        const d = diffJson(a[i], b[i]);
+        if (d.type !== "match") {
+          changes.push({ i, diff: d });
+        }
+      }
+      if (changes.length === 0) {
+        return { type: "match" };
+      }
+      return { type: "modified-a", changes };
+    } else {
+      let start = 0;
+      while (start < a.length && start < b.length && diffJson(a[start], b[start]).type === "match") {
+        start++;
+      }
+      let endIndexA = a.length - 1;
+      let endIndexB = b.length - 1;
+      while (endIndexA >= start && endIndexB >= start && diffJson(a[endIndexA], b[endIndexB]).type === "match") {
+        endIndexA--;
+        endIndexB--;
+      }
+      const count = endIndexA - start + 1;
+      const items = b.slice(start, endIndexB + 1);
+      return { type: "splice", start, count, items };
+    }
+  }
+  if (a === null || b === null) {
+    return { type: "value", before: a, after: b };
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return { type: "value", before: a, after: b };
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+    const changes = {};
+    const additions = {};
+    const deletions = {};
+    for (const key of keys) {
+      const valueA = a[key];
+      const valueB = b[key];
+      if (valueA === void 0 && valueB !== void 0) {
+        additions[key] = valueB;
+      } else if (valueB === void 0 && valueA !== void 0) {
+        deletions[key] = valueA;
+      } else if (valueA !== void 0 && valueB !== void 0) {
+        const d = diffJson(valueA, valueB);
+        if (d.type !== "match") {
+          changes[key] = d;
+        }
+      }
+    }
+    const result = {
+      type: "modified-o",
+      ...Object.keys(changes).length === 0 ? {} : { changes },
+      ...Object.keys(additions).length === 0 ? {} : { additions },
+      ...Object.keys(deletions).length === 0 ? {} : { deletions }
+    };
+    if (result.changes || result.additions || result.deletions) {
+      return result;
+    } else {
+      return { type: "match" };
+    }
+  }
+  return { type: "value", before: a, after: b };
+};
+
+export {
+  diffJson
+};

package/dist/diff.d.mts

@@ -0,0 +1,40 @@
+type JSONPrimitive = string | number | boolean | null;
+type JSONObject = {
+    [member: string]: JSONValue | undefined;
+};
+type JSONArray = JSONValue[];
+type JSONValue = JSONPrimitive | JSONObject | JSONArray;
+type PossibleRecursiveDiff<V extends JSONValue | undefined> = V extends JSONValue ? NestedDiff<V> : never;
+type NestedDiff<V extends JSONValue> = (V extends JSONPrimitive ? {
+    type: "value";
+    before: V;
+    after: V;
+} : never) | (V extends JSONArray ? {
+    type: "splice";
+    start: number;
+    count: number;
+    items: V;
+} : never) | (V extends JSONArray ? {
+    type: "modified-a";
+    changes: Array<{
+        i: number;
+        diff: PossibleRecursiveDiff<V[number]>;
+    }>;
+} : never) | (V extends JSONObject ? {
+    type: "modified-o";
+    additions?: {
+        [K in keyof V]: V[K];
+    };
+    deletions?: {
+        [K in keyof V]: V[K];
+    };
+    changes?: {
+        [K in keyof V]: PossibleRecursiveDiff<V[K]>;
+    };
+} : never);
+type Diff<V extends JSONValue> = NestedDiff<V> | {
+    type: "match";
+};
+declare const diffJson: <V extends JSONValue>(a: V | undefined, b: V | undefined) => Diff<V>;
+
+export { type Diff, type JSONArray, type JSONObject, type JSONPrimitive, type JSONValue, type NestedDiff, diffJson };

package/dist/diff.d.ts

@@ -0,0 +1,40 @@
+type JSONPrimitive = string | number | boolean | null;
+type JSONObject = {
+    [member: string]: JSONValue | undefined;
+};
+type JSONArray = JSONValue[];
+type JSONValue = JSONPrimitive | JSONObject | JSONArray;
+type PossibleRecursiveDiff<V extends JSONValue | undefined> = V extends JSONValue ? NestedDiff<V> : never;
+type NestedDiff<V extends JSONValue> = (V extends JSONPrimitive ? {
+    type: "value";
+    before: V;
+    after: V;
+} : never) | (V extends JSONArray ? {
+    type: "splice";
+    start: number;
+    count: number;
+    items: V;
+} : never) | (V extends JSONArray ? {
+    type: "modified-a";
+    changes: Array<{
+        i: number;
+        diff: PossibleRecursiveDiff<V[number]>;
+    }>;
+} : never) | (V extends JSONObject ? {
+    type: "modified-o";
+    additions?: {
+        [K in keyof V]: V[K];
+    };
+    deletions?: {
+        [K in keyof V]: V[K];
+    };
+    changes?: {
+        [K in keyof V]: PossibleRecursiveDiff<V[K]>;
+    };
+} : never);
+type Diff<V extends JSONValue> = NestedDiff<V> | {
+    type: "match";
+};
+declare const diffJson: <V extends JSONValue>(a: V | undefined, b: V | undefined) => Diff<V>;
+
+export { type Diff, type JSONArray, type JSONObject, type JSONPrimitive, type JSONValue, type NestedDiff, diffJson };

package/dist/diff.js

@@ -0,0 +1,105 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/diff.ts
+var diff_exports = {};
+__export(diff_exports, {
+  diffJson: () => diffJson
+});
+module.exports = __toCommonJS(diff_exports);
+var jsonTypeMatches = (a, b) => typeof a === typeof b && Array.isArray(a) === Array.isArray(b) && a === null === (b === null);
+var diffJson = (a, b) => {
+  if (a === b) {
+    return { type: "match" };
+  }
+  if (!jsonTypeMatches(a, b)) {
+    throw new Error("Types don't match, unable to diff");
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length === b.length) {
+      const changes = [];
+      for (let i = 0; i < a.length; i++) {
+        const d = diffJson(a[i], b[i]);
+        if (d.type !== "match") {
+          changes.push({ i, diff: d });
+        }
+      }
+      if (changes.length === 0) {
+        return { type: "match" };
+      }
+      return { type: "modified-a", changes };
+    } else {
+      let start = 0;
+      while (start < a.length && start < b.length && diffJson(a[start], b[start]).type === "match") {
+        start++;
+      }
+      let endIndexA = a.length - 1;
+      let endIndexB = b.length - 1;
+      while (endIndexA >= start && endIndexB >= start && diffJson(a[endIndexA], b[endIndexB]).type === "match") {
+        endIndexA--;
+        endIndexB--;
+      }
+      const count = endIndexA - start + 1;
+      const items = b.slice(start, endIndexB + 1);
+      return { type: "splice", start, count, items };
+    }
+  }
+  if (a === null || b === null) {
+    return { type: "value", before: a, after: b };
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return { type: "value", before: a, after: b };
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+    const changes = {};
+    const additions = {};
+    const deletions = {};
+    for (const key of keys) {
+      const valueA = a[key];
+      const valueB = b[key];
+      if (valueA === void 0 && valueB !== void 0) {
+        additions[key] = valueB;
+      } else if (valueB === void 0 && valueA !== void 0) {
+        deletions[key] = valueA;
+      } else if (valueA !== void 0 && valueB !== void 0) {
+        const d = diffJson(valueA, valueB);
+        if (d.type !== "match") {
+          changes[key] = d;
+        }
+      }
+    }
+    const result = {
+      type: "modified-o",
+      ...Object.keys(changes).length === 0 ? {} : { changes },
+      ...Object.keys(additions).length === 0 ? {} : { additions },
+      ...Object.keys(deletions).length === 0 ? {} : { deletions }
+    };
+    if (result.changes || result.additions || result.deletions) {
+      return result;
+    } else {
+      return { type: "match" };
+    }
+  }
+  return { type: "value", before: a, after: b };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  diffJson
+});

package/dist/diff.mjs

@@ -0,0 +1,6 @@
+import {
+  diffJson
+} from "./chunk-SZTK7XV4.mjs";
+export {
+  diffJson
+};

package/dist/index.d.mts

@@ -1,3 +1,2 @@
-declare const diffJson: () => string;
-
-export { diffJson };
+export { Diff, JSONArray, JSONObject, JSONPrimitive, JSONValue, NestedDiff, diffJson } from './diff.mjs';
+export { patchJson } from './patch.mjs';

package/dist/index.d.ts

@@ -1,3 +1,2 @@
-declare const diffJson: () => string;
-
-export { diffJson };
+export { Diff, JSONArray, JSONObject, JSONPrimitive, JSONValue, NestedDiff, diffJson } from './diff.js';
+export { patchJson } from './patch.js';

package/dist/index.js

@@ -20,13 +20,139 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  diffJson: () => diffJson
+  diffJson: () => diffJson,
+  patchJson: () => patchJson
 });
 module.exports = __toCommonJS(src_exports);
-var diffJson = () => {
-  return "not implemented yet!!";
+
+// src/diff.ts
+var jsonTypeMatches = (a, b) => typeof a === typeof b && Array.isArray(a) === Array.isArray(b) && a === null === (b === null);
+var diffJson = (a, b) => {
+  if (a === b) {
+    return { type: "match" };
+  }
+  if (!jsonTypeMatches(a, b)) {
+    throw new Error("Types don't match, unable to diff");
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length === b.length) {
+      const changes = [];
+      for (let i = 0; i < a.length; i++) {
+        const d = diffJson(a[i], b[i]);
+        if (d.type !== "match") {
+          changes.push({ i, diff: d });
+        }
+      }
+      if (changes.length === 0) {
+        return { type: "match" };
+      }
+      return { type: "modified-a", changes };
+    } else {
+      let start = 0;
+      while (start < a.length && start < b.length && diffJson(a[start], b[start]).type === "match") {
+        start++;
+      }
+      let endIndexA = a.length - 1;
+      let endIndexB = b.length - 1;
+      while (endIndexA >= start && endIndexB >= start && diffJson(a[endIndexA], b[endIndexB]).type === "match") {
+        endIndexA--;
+        endIndexB--;
+      }
+      const count = endIndexA - start + 1;
+      const items = b.slice(start, endIndexB + 1);
+      return { type: "splice", start, count, items };
+    }
+  }
+  if (a === null || b === null) {
+    return { type: "value", before: a, after: b };
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return { type: "value", before: a, after: b };
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+    const changes = {};
+    const additions = {};
+    const deletions = {};
+    for (const key of keys) {
+      const valueA = a[key];
+      const valueB = b[key];
+      if (valueA === void 0 && valueB !== void 0) {
+        additions[key] = valueB;
+      } else if (valueB === void 0 && valueA !== void 0) {
+        deletions[key] = valueA;
+      } else if (valueA !== void 0 && valueB !== void 0) {
+        const d = diffJson(valueA, valueB);
+        if (d.type !== "match") {
+          changes[key] = d;
+        }
+      }
+    }
+    const result = {
+      type: "modified-o",
+      ...Object.keys(changes).length === 0 ? {} : { changes },
+      ...Object.keys(additions).length === 0 ? {} : { additions },
+      ...Object.keys(deletions).length === 0 ? {} : { deletions }
+    };
+    if (result.changes || result.additions || result.deletions) {
+      return result;
+    } else {
+      return { type: "match" };
+    }
+  }
+  return { type: "value", before: a, after: b };
+};
+
+// src/patch.ts
+var patchJson = (old, diff) => {
+  if (diff.type === "match") {
+    return old;
+  }
+  if (diff.type === "value") {
+    return diff.after;
+  }
+  if (diff.type === "splice") {
+    if (!Array.isArray(old)) {
+      throw new Error("Cannot apply splice diff to non-array value");
+    }
+    const result = [...old];
+    result.splice(diff.start, diff.count, ...diff.items);
+    return result;
+  }
+  if (diff.type === "modified-a") {
+    if (!Array.isArray(old)) {
+      throw new Error("Cannot apply changes diff to non-array value");
+    }
+    const result = [...old];
+    for (const { i, diff: d } of diff.changes) {
+      result[i] = patchJson(old[i], d);
+    }
+    return result;
+  }
+  if (Array.isArray(old)) {
+    throw new Error("Unexpected array type");
+  }
+  if (diff.type === "modified-o") {
+    if (typeof old !== "object" || old === null) {
+      throw new Error("Cannot apply modified diff to non-object value");
+    }
+    const result = { ...old, ...diff.additions };
+    for (const key of Object.keys(diff.changes || {})) {
+      const changes = diff.changes?.[key];
+      if (changes) {
+        result[key] = patchJson(old[key], changes);
+      }
+    }
+    for (const keu of Object.keys(diff.deletions || {})) {
+      delete result[keu];
+    }
+    return result;
+  }
+  const _n = diff;
+  throw new Error(`Unknown diff type: ${_n}`);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  diffJson
+  diffJson,
+  patchJson
 });

package/dist/index.mjs

@@ -1,7 +1,10 @@
-// src/index.ts
-var diffJson = () => {
-  return "not implemented yet!!";
-};
-export {
+import {
   diffJson
+} from "./chunk-SZTK7XV4.mjs";
+import {
+  patchJson
+} from "./chunk-KAHL2YAL.mjs";
+export {
+  diffJson,
+  patchJson
 };

package/dist/patch.d.mts

@@ -0,0 +1,5 @@
+import { JSONValue, Diff } from './diff.mjs';
+
+declare const patchJson: <V extends JSONValue>(old: V | undefined, diff: Diff<V>) => V | undefined;
+
+export { patchJson };

package/dist/patch.d.ts

@@ -0,0 +1,5 @@
+import { JSONValue, Diff } from './diff.js';
+
+declare const patchJson: <V extends JSONValue>(old: V | undefined, diff: Diff<V>) => V | undefined;
+
+export { patchJson };

package/dist/patch.js

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/patch.ts
+var patch_exports = {};
+__export(patch_exports, {
+  patchJson: () => patchJson
+});
+module.exports = __toCommonJS(patch_exports);
+var patchJson = (old, diff) => {
+  if (diff.type === "match") {
+    return old;
+  }
+  if (diff.type === "value") {
+    return diff.after;
+  }
+  if (diff.type === "splice") {
+    if (!Array.isArray(old)) {
+      throw new Error("Cannot apply splice diff to non-array value");
+    }
+    const result = [...old];
+    result.splice(diff.start, diff.count, ...diff.items);
+    return result;
+  }
+  if (diff.type === "modified-a") {
+    if (!Array.isArray(old)) {
+      throw new Error("Cannot apply changes diff to non-array value");
+    }
+    const result = [...old];
+    for (const { i, diff: d } of diff.changes) {
+      result[i] = patchJson(old[i], d);
+    }
+    return result;
+  }
+  if (Array.isArray(old)) {
+    throw new Error("Unexpected array type");
+  }
+  if (diff.type === "modified-o") {
+    if (typeof old !== "object" || old === null) {
+      throw new Error("Cannot apply modified diff to non-object value");
+    }
+    const result = { ...old, ...diff.additions };
+    for (const key of Object.keys(diff.changes || {})) {
+      const changes = diff.changes?.[key];
+      if (changes) {
+        result[key] = patchJson(old[key], changes);
+      }
+    }
+    for (const keu of Object.keys(diff.deletions || {})) {
+      delete result[keu];
+    }
+    return result;
+  }
+  const _n = diff;
+  throw new Error(`Unknown diff type: ${_n}`);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  patchJson
+});

package/dist/patch.mjs

@@ -0,0 +1,6 @@
+import {
+  patchJson
+} from "./chunk-KAHL2YAL.mjs";
+export {
+  patchJson
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcanejs/diff",
-  "version": "0.1.4",
+  "version": "0.3.0",
   "private": false,
   "description": "Create and apply JSON diffs of JSON objects",
   "keywords": [
@@ -25,12 +25,25 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./diff": {
+      "import": "./dist/diff.mjs",
+      "require": "./dist/diff.js",
+      "types": "./dist/diff.d.ts"
+    },
+    "./patch": {
+      "import": "./dist/patch.mjs",
+      "require": "./dist/patch.js",
+      "types": "./dist/patch.d.ts"
     }
   },
   "devDependencies": {
     "@types/eslint": "^8.56.5",
+    "@types/jest": "^29.5.12",
     "@types/node": "^20.11.24",
     "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.0",
     "tsup": "^8.1.0",
     "typescript": "^5.3.3",
     "@arcanejs/eslint-config": "0.0.0",
@@ -45,6 +58,8 @@
   "scripts": {
     "lint": "eslint . --max-warnings 0",
     "build": "tsup",
-    "dev": "tsup --watch"
+    "dev": "tsup --watch",
+    "test": "jest",
+    "test:watch": "jest --watch"
   }
 }