@scalar/json-magic 0.1.0

package/dist/diff/diff.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/diff/diff.ts"],
+  "sourcesContent": ["/**\n * Represents the possible types of changes that can be made to a document.\n * - 'add': A new property is added\n * - 'update': An existing property's value is changed\n * - 'delete': A property is removed\n */\ntype ChangeType = 'add' | 'update' | 'delete'\n\n/**\n * Represents a single difference between two documents.\n * @property path - Array of strings representing the path to the changed property\n * @property changes - The new value for the property (for add/update) or the old value (for delete)\n * @property type - The type of change that occurred\n */\nexport type Difference = { path: string[]; changes: any; type: ChangeType }\n\n/**\n * Get the difference between two objects.\n *\n * This function performs a breadth-first comparison between two objects and returns\n * a list of operations needed to transform the first object into the second.\n *\n * @param doc1 - The source object to compare from\n * @param doc2 - The target object to compare to\n * @returns A list of operations (add/update/delete) with their paths and changes\n *\n * @example\n * // Compare two simple objects\n * const original = { name: 'John', age: 30 }\n * const updated = { name: 'John', age: 31, city: 'New York' }\n * const differences = diff(original, updated)\n * // Returns:\n * // [\n * //   { path: ['age'], changes: 31, type: 'update' },\n * //   { path: ['city'], changes: 'New York', type: 'add' }\n * // ]\n *\n * @example\n * // Compare nested objects\n * const original = {\n *   user: { name: 'John', settings: { theme: 'light' } }\n * }\n * const updated = {\n *   user: { name: 'John', settings: { theme: 'dark' } }\n * }\n * const differences = diff(original, updated)\n * // Returns:\n * // [\n * //   { path: ['user', 'settings', 'theme'], changes: 'dark', type: 'update' }\n * // ]\n */\nexport const diff = (doc1: Record<string, unknown>, doc2: Record<string, unknown>): Difference[] => {\n  const diff: Difference[] = []\n\n  const bfs = (el1: unknown, el2: unknown, prefix = []) => {\n    // If the types are different, we know that the property has been added, deleted or updated\n    if (typeof el1 !== typeof el2) {\n      if (typeof el1 === 'undefined') {\n        diff.push({ path: prefix, changes: el2, type: 'add' })\n        return\n      }\n\n      if (typeof el2 === 'undefined') {\n        diff.push({ path: prefix, changes: el1, type: 'delete' })\n        return\n      }\n\n      diff.push({ path: prefix, changes: el2, type: 'update' })\n      return\n    }\n\n    // We now can assume that el1 and el2 are of the same type\n\n    // For nested objects, we need to recursively check the properties\n    if (typeof el1 === 'object' && typeof el2 === 'object' && el1 !== null && el2 !== null) {\n      const keys = new Set([...Object.keys(el1), ...Object.keys(el2)])\n\n      for (const key of keys) {\n        // @ts-ignore\n        bfs(el1[key], el2[key], [...prefix, key])\n      }\n      return\n    }\n\n    // For primitives, we can just compare the values\n    if (el1 !== el2) {\n      diff.push({ path: prefix, changes: el2, type: 'update' })\n    }\n  }\n\n  // Run breadth-first search\n  bfs(doc1, doc2)\n  return diff\n}\n"],
+  "mappings": "AAmDO,MAAM,OAAO,CAAC,MAA+B,SAAgD;AAClG,QAAMA,QAAqB,CAAC;AAE5B,QAAM,MAAM,CAAC,KAAc,KAAc,SAAS,CAAC,MAAM;AAEvD,QAAI,OAAO,QAAQ,OAAO,KAAK;AAC7B,UAAI,OAAO,QAAQ,aAAa;AAC9B,QAAAA,MAAK,KAAK,EAAE,MAAM,QAAQ,SAAS,KAAK,MAAM,MAAM,CAAC;AACrD;AAAA,MACF;AAEA,UAAI,OAAO,QAAQ,aAAa;AAC9B,QAAAA,MAAK,KAAK,EAAE,MAAM,QAAQ,SAAS,KAAK,MAAM,SAAS,CAAC;AACxD;AAAA,MACF;AAEA,MAAAA,MAAK,KAAK,EAAE,MAAM,QAAQ,SAAS,KAAK,MAAM,SAAS,CAAC;AACxD;AAAA,IACF;AAKA,QAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ,YAAY,QAAQ,QAAQ,QAAQ,MAAM;AACtF,YAAM,OAAO,oBAAI,IAAI,CAAC,GAAG,OAAO,KAAK,GAAG,GAAG,GAAG,OAAO,KAAK,GAAG,CAAC,CAAC;AAE/D,iBAAW,OAAO,MAAM;AAEtB,YAAI,IAAI,GAAG,GAAG,IAAI,GAAG,GAAG,CAAC,GAAG,QAAQ,GAAG,CAAC;AAAA,MAC1C;AACA;AAAA,IACF;AAGA,QAAI,QAAQ,KAAK;AACf,MAAAA,MAAK,KAAK,EAAE,MAAM,QAAQ,SAAS,KAAK,MAAM,SAAS,CAAC;AAAA,IAC1D;AAAA,EACF;AAGA,MAAI,MAAM,IAAI;AACd,SAAOA;AACT;",
+  "names": ["diff"]
+}

package/dist/diff/index.d.ts

@@ -0,0 +1,5 @@
+import { diff, type Difference } from '../diff/diff.js';
+import { apply } from '../diff/apply.js';
+import { merge } from '../diff/merge.js';
+export { diff, apply, merge, type Difference };
+//# sourceMappingURL=index.d.ts.map

package/dist/diff/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/diff/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAEpC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,UAAU,EAAE,CAAA"}

package/dist/diff/index.js

@@ -0,0 +1,9 @@
+import { diff } from "../diff/diff.js";
+import { apply } from "../diff/apply.js";
+import { merge } from "../diff/merge.js";
+export {
+  apply,
+  diff,
+  merge
+};
+//# sourceMappingURL=index.js.map

package/dist/diff/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/diff/index.ts"],
+  "sourcesContent": ["import { diff, type Difference } from '@/diff/diff'\nimport { apply } from '@/diff/apply'\nimport { merge } from '@/diff/merge'\n\nexport { diff, apply, merge, type Difference }\n"],
+  "mappings": "AAAA,SAAS,YAA6B;AACtC,SAAS,aAAa;AACtB,SAAS,aAAa;",
+  "names": []
+}

package/dist/diff/merge.d.ts

@@ -0,0 +1,43 @@
+import type { Difference } from '../diff/diff.js';
+/**
+ * Merges two sets of differences from the same document and resolves conflicts.
+ * This function combines changes from two diff lists while handling potential conflicts
+ * that arise when both diffs modify the same paths. It uses a trie data structure for
+ * efficient path matching and conflict detection.
+ *
+ * @param diff1 - First list of differences
+ * @param diff2 - Second list of differences
+ * @returns Object containing:
+ *   - diffs: Combined list of non-conflicting differences
+ *   - conflicts: Array of conflicting difference pairs that need manual resolution
+ *
+ * @example
+ * // Merge two sets of changes to a user profile
+ * const diff1 = [
+ *   { path: ['name'], changes: 'John', type: 'update' },
+ *   { path: ['age'], changes: 30, type: 'add' }
+ * ]
+ * const diff2 = [
+ *   { path: ['name'], changes: 'Johnny', type: 'update' },
+ *   { path: ['address'], changes: { city: 'NY' }, type: 'add' }
+ * ]
+ * const { diffs, conflicts } = merge(diff1, diff2)
+ * // Returns:
+ * // {
+ * //   diffs: [
+ * //     { path: ['age'], changes: 30, type: 'add' },
+ * //     { path: ['address'], changes: { city: 'NY' }, type: 'add' }
+ * //   ],
+ * //   conflicts: [
+ * //     [
+ * //       [{ path: ['name'], changes: 'John', type: 'update' }],
+ * //       [{ path: ['name'], changes: 'Johnny', type: 'update' }]
+ * //     ]
+ * //   ]
+ * // }
+ */
+export declare const merge: (diff1: Difference[], diff2: Difference[]) => {
+    diffs: Difference[];
+    conflicts: [Difference[], Difference[]][];
+};
+//# sourceMappingURL=merge.d.ts.map

package/dist/diff/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/diff/merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,KAAK,UAAW,UAAU,EAAE,SAAS,UAAU,EAAE;;;CA8F7D,CAAA"}

package/dist/diff/merge.js

@@ -0,0 +1,61 @@
+import { Trie } from "../diff/trie.js";
+import { isArrayEqual, isKeyCollisions, mergeObjects } from "../diff/utils.js";
+const merge = (diff1, diff2) => {
+  const trie = new Trie();
+  for (const [index, diff] of diff1.entries()) {
+    trie.addPath(diff.path, { index, changes: diff });
+  }
+  const skipDiff1 = /* @__PURE__ */ new Set();
+  const skipDiff2 = /* @__PURE__ */ new Set();
+  const conflictsMap1 = /* @__PURE__ */ new Map();
+  const conflictsMap2 = /* @__PURE__ */ new Map();
+  for (const [index, diff] of diff2.entries()) {
+    trie.findMatch(diff.path, (value) => {
+      if (diff.type === "delete") {
+        if (value.changes.type === "delete") {
+          if (value.changes.path.length > diff.path.length) {
+            skipDiff1.add(value.index);
+          } else {
+            skipDiff2.add(value.index);
+          }
+        } else {
+          skipDiff1.add(value.index);
+          skipDiff2.add(index);
+          const conflictEntry = conflictsMap2.get(index);
+          if (conflictEntry !== void 0) {
+            conflictEntry[0].push(value.changes);
+          } else {
+            conflictsMap2.set(index, [[value.changes], [diff]]);
+          }
+        }
+      }
+      if (diff.type === "add" || diff.type === "update") {
+        if (isArrayEqual(diff.path, value.changes.path) && value.changes.type !== "delete" && !isKeyCollisions(diff.changes, value.changes.changes)) {
+          skipDiff1.add(value.index);
+          if (typeof diff.changes === "object") {
+            mergeObjects(diff.changes, value.changes.changes);
+          }
+          return;
+        }
+        skipDiff1.add(value.index);
+        skipDiff2.add(index);
+        const conflictEntry = conflictsMap1.get(value.index);
+        if (conflictEntry !== void 0) {
+          conflictEntry[1].push(diff);
+        } else {
+          conflictsMap1.set(value.index, [[value.changes], [diff]]);
+        }
+      }
+    });
+  }
+  const conflicts = [...conflictsMap1.values(), ...conflictsMap2.values()];
+  const diffs = [
+    ...diff1.filter((_, index) => !skipDiff1.has(index)),
+    ...diff2.filter((_, index) => !skipDiff2.has(index))
+  ];
+  return { diffs, conflicts };
+};
+export {
+  merge
+};
+//# sourceMappingURL=merge.js.map

package/dist/diff/merge.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/diff/merge.ts"],
+  "sourcesContent": ["import type { Difference } from '@/diff/diff'\nimport { Trie } from '@/diff/trie'\nimport { isArrayEqual, isKeyCollisions, mergeObjects } from '@/diff/utils'\n\n/**\n * Merges two sets of differences from the same document and resolves conflicts.\n * This function combines changes from two diff lists while handling potential conflicts\n * that arise when both diffs modify the same paths. It uses a trie data structure for\n * efficient path matching and conflict detection.\n *\n * @param diff1 - First list of differences\n * @param diff2 - Second list of differences\n * @returns Object containing:\n *   - diffs: Combined list of non-conflicting differences\n *   - conflicts: Array of conflicting difference pairs that need manual resolution\n *\n * @example\n * // Merge two sets of changes to a user profile\n * const diff1 = [\n *   { path: ['name'], changes: 'John', type: 'update' },\n *   { path: ['age'], changes: 30, type: 'add' }\n * ]\n * const diff2 = [\n *   { path: ['name'], changes: 'Johnny', type: 'update' },\n *   { path: ['address'], changes: { city: 'NY' }, type: 'add' }\n * ]\n * const { diffs, conflicts } = merge(diff1, diff2)\n * // Returns:\n * // {\n * //   diffs: [\n * //     { path: ['age'], changes: 30, type: 'add' },\n * //     { path: ['address'], changes: { city: 'NY' }, type: 'add' }\n * //   ],\n * //   conflicts: [\n * //     [\n * //       [{ path: ['name'], changes: 'John', type: 'update' }],\n * //       [{ path: ['name'], changes: 'Johnny', type: 'update' }]\n * //     ]\n * //   ]\n * // }\n */\nexport const merge = (diff1: Difference[], diff2: Difference[]) => {\n  // Here we need to use a trie to optimize searching for a prefix\n  // With the naive approach time complexity of the algorithm would be\n  //                         O(n * m)\n  //                           ^   ^\n  // n is the length off diff1 |   | m length of diff2\n  //\n  // Assuming that the maximum depth of the nested objects would be constant lets say 0 <= D <= 100\n  // we try to optimize for that using the tire data structure.\n  // So the new time complexity would be O(n * D) where D is the maximum depth of the nested object\n  const trie = new Trie<{ index: number; changes: Difference }>()\n\n  // Create the trie\n  for (const [index, diff] of diff1.entries()) {\n    trie.addPath(diff.path, { index, changes: diff })\n  }\n\n  const skipDiff1 = new Set<number>()\n  const skipDiff2 = new Set<number>()\n\n  // Keep related conflicts together for easy A, B pick conflict resolution\n  // map key is going to be conflicting index of first diff list where the diff will be\n  // a delete operation or an add/update operation with a one to many conflicts\n  const conflictsMap1 = new Map<number, [Difference[], Difference[]]>()\n  // map key will be the index from the second diff list where the diff will be\n  // a delete operation with one to many conflicts\n  const conflictsMap2 = new Map<number, [Difference[], Difference[]]>()\n\n  for (const [index, diff] of diff2.entries()) {\n    trie.findMatch(diff.path, (value) => {\n      if (diff.type === 'delete') {\n        if (value.changes.type === 'delete') {\n          // Keep the highest depth delete operation and skip the other\n          if (value.changes.path.length > diff.path.length) {\n            skipDiff1.add(value.index)\n          } else {\n            skipDiff2.add(value.index)\n          }\n        } else {\n          // Take care of updates/add on the same path (we are sure they will be on the\n          // same path since the change comes from the same document)\n          skipDiff1.add(value.index)\n          skipDiff2.add(index)\n\n          const conflictEntry = conflictsMap2.get(index)\n\n          if (conflictEntry !== undefined) {\n            conflictEntry[0].push(value.changes)\n          } else {\n            conflictsMap2.set(index, [[value.changes], [diff]])\n          }\n        }\n      }\n\n      if (diff.type === 'add' || diff.type === 'update') {\n        // For add -> add / update -> update operation we try to first see if we can merge this operations\n        if (\n          isArrayEqual(diff.path, value.changes.path) &&\n          value.changes.type !== 'delete' &&\n          !isKeyCollisions(diff.changes, value.changes.changes)\n        ) {\n          skipDiff1.add(value.index)\n          // For non primitive values we merge object keys into diff2\n          if (typeof diff.changes === 'object') {\n            mergeObjects(diff.changes, value.changes.changes)\n          }\n          return\n        }\n\n        // add/update -> delete operations always resolve in conflicts\n        skipDiff1.add(value.index)\n        skipDiff2.add(index)\n\n        const conflictEntry = conflictsMap1.get(value.index)\n\n        if (conflictEntry !== undefined) {\n          conflictEntry[1].push(diff)\n        } else {\n          conflictsMap1.set(value.index, [[value.changes], [diff]])\n        }\n      }\n    })\n  }\n\n  const conflicts: [Difference[], Difference[]][] = [...conflictsMap1.values(), ...conflictsMap2.values()]\n\n  // Filter all changes that should be skipped because of conflicts\n  // or auto conflict resolution\n  const diffs: Difference[] = [\n    ...diff1.filter((_, index) => !skipDiff1.has(index)),\n    ...diff2.filter((_, index) => !skipDiff2.has(index)),\n  ]\n\n  return { diffs, conflicts }\n}\n"],
+  "mappings": "AACA,SAAS,YAAY;AACrB,SAAS,cAAc,iBAAiB,oBAAoB;AAuCrD,MAAM,QAAQ,CAAC,OAAqB,UAAwB;AAUjE,QAAM,OAAO,IAAI,KAA6C;AAG9D,aAAW,CAAC,OAAO,IAAI,KAAK,MAAM,QAAQ,GAAG;AAC3C,SAAK,QAAQ,KAAK,MAAM,EAAE,OAAO,SAAS,KAAK,CAAC;AAAA,EAClD;AAEA,QAAM,YAAY,oBAAI,IAAY;AAClC,QAAM,YAAY,oBAAI,IAAY;AAKlC,QAAM,gBAAgB,oBAAI,IAA0C;AAGpE,QAAM,gBAAgB,oBAAI,IAA0C;AAEpE,aAAW,CAAC,OAAO,IAAI,KAAK,MAAM,QAAQ,GAAG;AAC3C,SAAK,UAAU,KAAK,MAAM,CAAC,UAAU;AACnC,UAAI,KAAK,SAAS,UAAU;AAC1B,YAAI,MAAM,QAAQ,SAAS,UAAU;AAEnC,cAAI,MAAM,QAAQ,KAAK,SAAS,KAAK,KAAK,QAAQ;AAChD,sBAAU,IAAI,MAAM,KAAK;AAAA,UAC3B,OAAO;AACL,sBAAU,IAAI,MAAM,KAAK;AAAA,UAC3B;AAAA,QACF,OAAO;AAGL,oBAAU,IAAI,MAAM,KAAK;AACzB,oBAAU,IAAI,KAAK;AAEnB,gBAAM,gBAAgB,cAAc,IAAI,KAAK;AAE7C,cAAI,kBAAkB,QAAW;AAC/B,0BAAc,CAAC,EAAE,KAAK,MAAM,OAAO;AAAA,UACrC,OAAO;AACL,0BAAc,IAAI,OAAO,CAAC,CAAC,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC;AAAA,UACpD;AAAA,QACF;AAAA,MACF;AAEA,UAAI,KAAK,SAAS,SAAS,KAAK,SAAS,UAAU;AAEjD,YACE,aAAa,KAAK,MAAM,MAAM,QAAQ,IAAI,KAC1C,MAAM,QAAQ,SAAS,YACvB,CAAC,gBAAgB,KAAK,SAAS,MAAM,QAAQ,OAAO,GACpD;AACA,oBAAU,IAAI,MAAM,KAAK;AAEzB,cAAI,OAAO,KAAK,YAAY,UAAU;AACpC,yBAAa,KAAK,SAAS,MAAM,QAAQ,OAAO;AAAA,UAClD;AACA;AAAA,QACF;AAGA,kBAAU,IAAI,MAAM,KAAK;AACzB,kBAAU,IAAI,KAAK;AAEnB,cAAM,gBAAgB,cAAc,IAAI,MAAM,KAAK;AAEnD,YAAI,kBAAkB,QAAW;AAC/B,wBAAc,CAAC,EAAE,KAAK,IAAI;AAAA,QAC5B,OAAO;AACL,wBAAc,IAAI,MAAM,OAAO,CAAC,CAAC,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC;AAAA,QAC1D;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAEA,QAAM,YAA4C,CAAC,GAAG,cAAc,OAAO,GAAG,GAAG,cAAc,OAAO,CAAC;AAIvG,QAAM,QAAsB;AAAA,IAC1B,GAAG,MAAM,OAAO,CAAC,GAAG,UAAU,CAAC,UAAU,IAAI,KAAK,CAAC;AAAA,IACnD,GAAG,MAAM,OAAO,CAAC,GAAG,UAAU,CAAC,UAAU,IAAI,KAAK,CAAC;AAAA,EACrD;AAEA,SAAO,EAAE,OAAO,UAAU;AAC5B;",
+  "names": []
+}

package/dist/diff/trie.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Trie data structure
+ *
+ * Read more: https://en.wikipedia.org/wiki/Trie
+ */
+/**
+ * Represents a node in the trie data structure.
+ * Each node can store a value and has a map of child nodes.
+ *
+ * @template Value - The type of value that can be stored in the node
+ */
+export declare class TrieNode<Value> {
+    value: Value | null;
+    children: Record<string, TrieNode<Value>>;
+    constructor(value: Value | null, children: Record<string, TrieNode<Value>>);
+}
+/**
+ * A trie (prefix tree) data structure implementation.
+ * This class provides efficient storage and retrieval of values associated with string paths.
+ *
+ * @template Value - The type of value to store at each node
+ *
+ * @example
+ * const trie = new Trie<number>()
+ * trie.addPath(['a', 'b', 'c'], 1)
+ * trie.addPath(['a', 'b', 'd'], 2)
+ * trie.findMatch(['a', 'b'], (value) => console.log(value)) // Logs: 1, 2
+ */
+export declare class Trie<Value> {
+    private root;
+    constructor();
+    /**
+     * Adds a value to the trie at the specified path.
+     * Creates new nodes as needed to build the path.
+     *
+     * @param path - Array of strings representing the path to store the value
+     * @param value - The value to store at the end of the path
+     *
+     * @example
+     * const trie = new Trie<number>()
+     * trie.addPath(['users', 'john', 'age'], 30)
+     */
+    addPath(path: string[], value: Value): void;
+    /**
+     * Finds all matches along a given path in the trie.
+     * This method traverses both the exact path and all deeper paths,
+     * executing a callback for each matching value found.
+     *
+     * The search is performed in two phases:
+     * 1. Traverse the exact path, checking for matches at each node
+     * 2. Perform a depth-first search from the end of the path to find all deeper matches
+     *
+     * @param path - Array of strings representing the path to search
+     * @param callback - Function to execute for each matching value found
+     *
+     * @example
+     * const trie = new Trie<number>()
+     * trie.addPath(['a', 'b', 'c'], 1)
+     * trie.addPath(['a', 'b', 'd'], 2)
+     * trie.findMatch(['a', 'b'], (value) => console.log(value)) // Logs: 1, 2
+     */
+    findMatch(path: string[], callback: (value: Value) => void): void;
+}
+//# sourceMappingURL=trie.d.ts.map

package/dist/diff/trie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trie.d.ts","sourceRoot":"","sources":["../../src/diff/trie.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,qBAAa,QAAQ,CAAC,KAAK;IAEhB,KAAK,EAAE,KAAK,GAAG,IAAI;IACnB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;gBADzC,KAAK,EAAE,KAAK,GAAG,IAAI,EACnB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;CAEnD;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,IAAI,CAAC,KAAK;IACrB,OAAO,CAAC,IAAI,CAAiB;;IAK7B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK;IAcpC;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI;CAgC3D"}

package/dist/diff/trie.js

@@ -0,0 +1,82 @@
+class TrieNode {
+  constructor(value, children) {
+    this.value = value;
+    this.children = children;
+  }
+}
+class Trie {
+  root;
+  constructor() {
+    this.root = new TrieNode(null, {});
+  }
+  /**
+   * Adds a value to the trie at the specified path.
+   * Creates new nodes as needed to build the path.
+   *
+   * @param path - Array of strings representing the path to store the value
+   * @param value - The value to store at the end of the path
+   *
+   * @example
+   * const trie = new Trie<number>()
+   * trie.addPath(['users', 'john', 'age'], 30)
+   */
+  addPath(path, value) {
+    let current = this.root;
+    for (const dir of path) {
+      if (current.children[dir]) {
+        current = current.children[dir];
+      } else {
+        current.children[dir] = new TrieNode(null, {});
+        current = current.children[dir];
+      }
+    }
+    current.value = value;
+  }
+  /**
+   * Finds all matches along a given path in the trie.
+   * This method traverses both the exact path and all deeper paths,
+   * executing a callback for each matching value found.
+   *
+   * The search is performed in two phases:
+   * 1. Traverse the exact path, checking for matches at each node
+   * 2. Perform a depth-first search from the end of the path to find all deeper matches
+   *
+   * @param path - Array of strings representing the path to search
+   * @param callback - Function to execute for each matching value found
+   *
+   * @example
+   * const trie = new Trie<number>()
+   * trie.addPath(['a', 'b', 'c'], 1)
+   * trie.addPath(['a', 'b', 'd'], 2)
+   * trie.findMatch(['a', 'b'], (value) => console.log(value)) // Logs: 1, 2
+   */
+  findMatch(path, callback) {
+    let current = this.root;
+    for (const dir of path) {
+      if (current.value !== null) {
+        callback(current.value);
+      }
+      const next = current.children[dir];
+      if (!next) {
+        return;
+      }
+      current = next;
+    }
+    const dfs = (current2) => {
+      for (const child of Object.keys(current2?.children ?? {})) {
+        if (current2 && Object.hasOwn(current2.children, child)) {
+          dfs(current2?.children[child]);
+        }
+      }
+      if (current2?.value) {
+        callback(current2.value);
+      }
+    };
+    dfs(current);
+  }
+}
+export {
+  Trie,
+  TrieNode
+};
+//# sourceMappingURL=trie.js.map

package/dist/diff/trie.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/diff/trie.ts"],
+  "sourcesContent": ["/**\n * Trie data structure\n *\n * Read more: https://en.wikipedia.org/wiki/Trie\n */\n\n/**\n * Represents a node in the trie data structure.\n * Each node can store a value and has a map of child nodes.\n *\n * @template Value - The type of value that can be stored in the node\n */\nexport class TrieNode<Value> {\n  constructor(\n    public value: Value | null,\n    public children: Record<string, TrieNode<Value>>,\n  ) {}\n}\n\n/**\n * A trie (prefix tree) data structure implementation.\n * This class provides efficient storage and retrieval of values associated with string paths.\n *\n * @template Value - The type of value to store at each node\n *\n * @example\n * const trie = new Trie<number>()\n * trie.addPath(['a', 'b', 'c'], 1)\n * trie.addPath(['a', 'b', 'd'], 2)\n * trie.findMatch(['a', 'b'], (value) => console.log(value)) // Logs: 1, 2\n */\nexport class Trie<Value> {\n  private root: TrieNode<Value>\n  constructor() {\n    this.root = new TrieNode<Value>(null, {})\n  }\n\n  /**\n   * Adds a value to the trie at the specified path.\n   * Creates new nodes as needed to build the path.\n   *\n   * @param path - Array of strings representing the path to store the value\n   * @param value - The value to store at the end of the path\n   *\n   * @example\n   * const trie = new Trie<number>()\n   * trie.addPath(['users', 'john', 'age'], 30)\n   */\n  addPath(path: string[], value: Value) {\n    let current = this.root\n    for (const dir of path) {\n      if (current.children[dir]) {\n        current = current.children[dir]\n      } else {\n        current.children[dir] = new TrieNode<Value>(null, {})\n        current = current.children[dir]\n      }\n    }\n\n    current.value = value\n  }\n\n  /**\n   * Finds all matches along a given path in the trie.\n   * This method traverses both the exact path and all deeper paths,\n   * executing a callback for each matching value found.\n   *\n   * The search is performed in two phases:\n   * 1. Traverse the exact path, checking for matches at each node\n   * 2. Perform a depth-first search from the end of the path to find all deeper matches\n   *\n   * @param path - Array of strings representing the path to search\n   * @param callback - Function to execute for each matching value found\n   *\n   * @example\n   * const trie = new Trie<number>()\n   * trie.addPath(['a', 'b', 'c'], 1)\n   * trie.addPath(['a', 'b', 'd'], 2)\n   * trie.findMatch(['a', 'b'], (value) => console.log(value)) // Logs: 1, 2\n   */\n  findMatch(path: string[], callback: (value: Value) => void) {\n    let current = this.root\n\n    for (const dir of path) {\n      // Note: the last callback wont fire here because it will fire on the dfs\n      if (current.value !== null) {\n        callback(current.value)\n      }\n\n      const next = current.children[dir]\n      if (!next) {\n        return\n      }\n\n      current = next\n    }\n\n    const dfs = (current: TrieNode<Value> | undefined) => {\n      for (const child of Object.keys(current?.children ?? {})) {\n        if (current && Object.hasOwn(current.children, child)) {\n          dfs(current?.children[child])\n        }\n      }\n\n      if (current?.value) {\n        callback(current.value)\n      }\n    }\n\n    // Dfs for the rest of the path\n    dfs(current)\n  }\n}\n"],
+  "mappings": "AAYO,MAAM,SAAgB;AAAA,EAC3B,YACS,OACA,UACP;AAFO;AACA;AAAA,EACN;AACL;AAcO,MAAM,KAAY;AAAA,EACf;AAAA,EACR,cAAc;AACZ,SAAK,OAAO,IAAI,SAAgB,MAAM,CAAC,CAAC;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,QAAQ,MAAgB,OAAc;AACpC,QAAI,UAAU,KAAK;AACnB,eAAW,OAAO,MAAM;AACtB,UAAI,QAAQ,SAAS,GAAG,GAAG;AACzB,kBAAU,QAAQ,SAAS,GAAG;AAAA,MAChC,OAAO;AACL,gBAAQ,SAAS,GAAG,IAAI,IAAI,SAAgB,MAAM,CAAC,CAAC;AACpD,kBAAU,QAAQ,SAAS,GAAG;AAAA,MAChC;AAAA,IACF;AAEA,YAAQ,QAAQ;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBA,UAAU,MAAgB,UAAkC;AAC1D,QAAI,UAAU,KAAK;AAEnB,eAAW,OAAO,MAAM;AAEtB,UAAI,QAAQ,UAAU,MAAM;AAC1B,iBAAS,QAAQ,KAAK;AAAA,MACxB;AAEA,YAAM,OAAO,QAAQ,SAAS,GAAG;AACjC,UAAI,CAAC,MAAM;AACT;AAAA,MACF;AAEA,gBAAU;AAAA,IACZ;AAEA,UAAM,MAAM,CAACA,aAAyC;AACpD,iBAAW,SAAS,OAAO,KAAKA,UAAS,YAAY,CAAC,CAAC,GAAG;AACxD,YAAIA,YAAW,OAAO,OAAOA,SAAQ,UAAU,KAAK,GAAG;AACrD,cAAIA,UAAS,SAAS,KAAK,CAAC;AAAA,QAC9B;AAAA,MACF;AAEA,UAAIA,UAAS,OAAO;AAClB,iBAASA,SAAQ,KAAK;AAAA,MACxB;AAAA,IACF;AAGA,QAAI,OAAO;AAAA,EACb;AACF;",
+  "names": ["current"]
+}

package/dist/diff/utils.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Deep check for objects for collisions
+ * Check primitives if their values are different
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @returns true if there is a collision, false otherwise
+ *
+ * @example
+ * // Objects with different values for same key
+ * isKeyCollisions({ a: 1 }, { a: 2 }) // true
+ *
+ * // Objects with different types
+ * isKeyCollisions({ a: 1 }, { a: '1' }) // true
+ *
+ * // Objects with no collisions
+ * isKeyCollisions({ a: 1 }, { b: 2 }) // false
+ *
+ * // Nested objects with collision
+ * isKeyCollisions({ a: { b: 1 } }, { a: { b: 2 } }) // true
+ */
+export declare const isKeyCollisions: (a: unknown, b: unknown) => boolean;
+/**
+ * Deep merges two objects, combining their properties recursively.
+ *
+ * ⚠️ Note: This operation assumes there are no key collisions between the objects.
+ * Use isKeyCollisions() to check for collisions before merging.
+ *
+ * @param a - Target object to merge into
+ * @param b - Source object to merge from
+ * @returns The merged object (mutates and returns a)
+ *
+ * @example
+ * // Simple merge
+ * const a = { name: 'John' }
+ * const b = { age: 30 }
+ * mergeObjects(a, b) // { name: 'John', age: 30 }
+ *
+ * // Nested merge
+ * const a = { user: { name: 'John' } }
+ * const b = { user: { age: 30 } }
+ * mergeObjects(a, b) // { user: { name: 'John', age: 30 } }
+ */
+export declare const mergeObjects: (a: Record<string, unknown>, b: Record<string, unknown>) => Record<string, unknown>;
+/**
+ * Checks if two arrays have the same elements in the same order.
+ *
+ * @param a - First array to compare
+ * @param b - Second array to compare
+ * @returns True if arrays have same length and elements, false otherwise
+ *
+ * @example
+ * // Arrays with same elements
+ * isArrayEqual([1, 2, 3], [1, 2, 3]) // true
+ *
+ * // Arrays with different elements
+ * isArrayEqual([1, 2, 3], [1, 2, 4]) // false
+ *
+ * // Arrays with different lengths
+ * isArrayEqual([1, 2], [1, 2, 3]) // false
+ */
+export declare const isArrayEqual: <T>(a: T[], b: T[]) => boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/diff/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/diff/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,MAAO,OAAO,KAAK,OAAO,YAsBrD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,YAAY,MAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAe3G,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE,YAY7C,CAAA"}

package/dist/diff/utils.js

@@ -0,0 +1,48 @@
+const isKeyCollisions = (a, b) => {
+  if (typeof a !== typeof b) {
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+    for (const key of keys) {
+      if (a[key] !== void 0 && b[key] !== void 0) {
+        if (isKeyCollisions(a[key], b[key])) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  return a !== b;
+};
+const mergeObjects = (a, b) => {
+  for (const key in b) {
+    if (!(key in a)) {
+      a[key] = b[key];
+    } else {
+      const aValue = a[key];
+      const bValue = b[key];
+      if (typeof aValue === "object" && aValue !== null && typeof bValue === "object" && bValue !== null) {
+        a[key] = mergeObjects(aValue, bValue);
+      }
+    }
+  }
+  return a;
+};
+const isArrayEqual = (a, b) => {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i <= a.length; ++i) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+export {
+  isArrayEqual,
+  isKeyCollisions,
+  mergeObjects
+};
+//# sourceMappingURL=utils.js.map

package/dist/diff/utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/diff/utils.ts"],
+  "sourcesContent": ["/**\n * Deep check for objects for collisions\n * Check primitives if their values are different\n *\n * @param a - First value to compare\n * @param b - Second value to compare\n * @returns true if there is a collision, false otherwise\n *\n * @example\n * // Objects with different values for same key\n * isKeyCollisions({ a: 1 }, { a: 2 }) // true\n *\n * // Objects with different types\n * isKeyCollisions({ a: 1 }, { a: '1' }) // true\n *\n * // Objects with no collisions\n * isKeyCollisions({ a: 1 }, { b: 2 }) // false\n *\n * // Nested objects with collision\n * isKeyCollisions({ a: { b: 1 } }, { a: { b: 2 } }) // true\n */\nexport const isKeyCollisions = (a: unknown, b: unknown) => {\n  if (typeof a !== typeof b) {\n    return true\n  }\n\n  if (typeof a === 'object' && typeof b === 'object' && a !== null && b !== null) {\n    const keys = new Set([...Object.keys(a), ...Object.keys(b)])\n\n    for (const key of keys) {\n      // @ts-ignore\n      if (a[key] !== undefined && b[key] !== undefined) {\n        // @ts-ignore\n        if (isKeyCollisions(a[key], b[key])) {\n          return true\n        }\n      }\n    }\n    return false\n  }\n\n  // We handle all primitives here\n  return a !== b\n}\n\n/**\n * Deep merges two objects, combining their properties recursively.\n *\n * \u26A0\uFE0F Note: This operation assumes there are no key collisions between the objects.\n * Use isKeyCollisions() to check for collisions before merging.\n *\n * @param a - Target object to merge into\n * @param b - Source object to merge from\n * @returns The merged object (mutates and returns a)\n *\n * @example\n * // Simple merge\n * const a = { name: 'John' }\n * const b = { age: 30 }\n * mergeObjects(a, b) // { name: 'John', age: 30 }\n *\n * // Nested merge\n * const a = { user: { name: 'John' } }\n * const b = { user: { age: 30 } }\n * mergeObjects(a, b) // { user: { name: 'John', age: 30 } }\n */\nexport const mergeObjects = (a: Record<string, unknown>, b: Record<string, unknown>): Record<string, unknown> => {\n  for (const key in b) {\n    if (!(key in a)) {\n      a[key] = b[key]\n    } else {\n      const aValue = a[key]\n      const bValue = b[key]\n\n      if (typeof aValue === 'object' && aValue !== null && typeof bValue === 'object' && bValue !== null) {\n        a[key] = mergeObjects(aValue as Record<string, unknown>, bValue as Record<string, unknown>)\n      }\n    }\n  }\n\n  return a\n}\n\n/**\n * Checks if two arrays have the same elements in the same order.\n *\n * @param a - First array to compare\n * @param b - Second array to compare\n * @returns True if arrays have same length and elements, false otherwise\n *\n * @example\n * // Arrays with same elements\n * isArrayEqual([1, 2, 3], [1, 2, 3]) // true\n *\n * // Arrays with different elements\n * isArrayEqual([1, 2, 3], [1, 2, 4]) // false\n *\n * // Arrays with different lengths\n * isArrayEqual([1, 2], [1, 2, 3]) // false\n */\nexport const isArrayEqual = <T>(a: T[], b: T[]) => {\n  if (a.length !== b.length) {\n    return false\n  }\n\n  for (let i = 0; i <= a.length; ++i) {\n    if (a[i] !== b[i]) {\n      return false\n    }\n  }\n\n  return true\n}\n"],
+  "mappings": "AAqBO,MAAM,kBAAkB,CAAC,GAAY,MAAe;AACzD,MAAI,OAAO,MAAM,OAAO,GAAG;AACzB,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,MAAM,YAAY,OAAO,MAAM,YAAY,MAAM,QAAQ,MAAM,MAAM;AAC9E,UAAM,OAAO,oBAAI,IAAI,CAAC,GAAG,OAAO,KAAK,CAAC,GAAG,GAAG,OAAO,KAAK,CAAC,CAAC,CAAC;AAE3D,eAAW,OAAO,MAAM;AAEtB,UAAI,EAAE,GAAG,MAAM,UAAa,EAAE,GAAG,MAAM,QAAW;AAEhD,YAAI,gBAAgB,EAAE,GAAG,GAAG,EAAE,GAAG,CAAC,GAAG;AACnC,iBAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAGA,SAAO,MAAM;AACf;AAuBO,MAAM,eAAe,CAAC,GAA4B,MAAwD;AAC/G,aAAW,OAAO,GAAG;AACnB,QAAI,EAAE,OAAO,IAAI;AACf,QAAE,GAAG,IAAI,EAAE,GAAG;AAAA,IAChB,OAAO;AACL,YAAM,SAAS,EAAE,GAAG;AACpB,YAAM,SAAS,EAAE,GAAG;AAEpB,UAAI,OAAO,WAAW,YAAY,WAAW,QAAQ,OAAO,WAAW,YAAY,WAAW,MAAM;AAClG,UAAE,GAAG,IAAI,aAAa,QAAmC,MAAiC;AAAA,MAC5F;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAmBO,MAAM,eAAe,CAAI,GAAQ,MAAW;AACjD,MAAI,EAAE,WAAW,EAAE,QAAQ;AACzB,WAAO;AAAA,EACT;AAEA,WAAS,IAAI,GAAG,KAAK,EAAE,QAAQ,EAAE,GAAG;AAClC,QAAI,EAAE,CAAC,MAAM,EAAE,CAAC,GAAG;AACjB,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/magic-proxy/index.d.ts

@@ -0,0 +1,2 @@
+export { createMagicProxy, getRaw } from './proxy.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/magic-proxy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/magic-proxy/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA"}

package/dist/magic-proxy/index.js

@@ -0,0 +1,6 @@
+import { createMagicProxy, getRaw } from "./proxy.js";
+export {
+  createMagicProxy,
+  getRaw
+};
+//# sourceMappingURL=index.js.map

package/dist/magic-proxy/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/magic-proxy/index.ts"],
+  "sourcesContent": ["// biome-ignore lint/performance/noBarrelFile: <explanation>\nexport { createMagicProxy, getRaw } from './proxy'\n"],
+  "mappings": "AACA,SAAS,kBAAkB,cAAc;",
+  "names": []
+}

package/dist/magic-proxy/proxy.d.ts

@@ -0,0 +1,63 @@
+import type { UnknownObject } from '../types.js';
+/**
+ * Creates a proxy that automatically resolves JSON references ($ref) in an object.
+ * The proxy intercepts property access and automatically resolves any $ref references
+ * to their target values in the source document.
+ *
+ * @param targetObject - The object to create a proxy for
+ * @param sourceDocument - The source document containing the reference targets (defaults to targetObject)
+ * @param resolvedProxyCache - Optional cache to store resolved proxies and prevent duplicate proxies
+ * @returns A proxy that automatically resolves $ref references
+ *
+ * @example
+ * // Basic usage with local references
+ * const doc = {
+ *   components: {
+ *     schemas: {
+ *       User: { type: 'object', properties: { name: { type: 'string' } } }
+ *     }
+ *   },
+ *   paths: {
+ *     '/users': {
+ *       get: {
+ *         responses: {
+ *           200: {
+ *             content: {
+ *               'application/json': {
+ *                 schema: { $ref: '#/components/schemas/User' }
+ *               }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const proxy = createMagicProxy(doc)
+ * // Accessing the schema will automatically resolve the $ref
+ * console.log(proxy.paths['/users'].get.responses[200].content['application/json'].schema)
+ * // Output: { type: 'object', properties: { name: { type: 'string' } } }
+ *
+ * @example
+ * // Using with a cache to prevent duplicate proxies
+ * const cache = new WeakMap()
+ * const proxy1 = createMagicProxy(doc, doc, cache)
+ * const proxy2 = createMagicProxy(doc, doc, cache)
+ * // proxy1 and proxy2 are the same instance due to caching
+ * console.log(proxy1 === proxy2) // true
+ */
+export declare function createMagicProxy<T extends UnknownObject | UnknownObject[]>(targetObject: T, sourceDocument?: T, resolvedProxyCache?: WeakMap<object, T>): T;
+export declare const TARGET_SYMBOL: unique symbol;
+/**
+ * Gets the raw (non-proxied) version of an object created by createMagicProxy.
+ * This is useful when you need to access the original object without the magic proxy wrapper.
+ *
+ * @param obj - The magic proxy object to get the raw version of
+ * @returns The raw version of the object
+ * @example
+ * const proxy = createMagicProxy({ foo: { $ref: '#/bar' } })
+ * const raw = getRaw(proxy) // { foo: { $ref: '#/bar' } }
+ */
+export declare function getRaw<T extends UnknownObject>(obj: T): T;
+//# sourceMappingURL=proxy.d.ts.map

package/dist/magic-proxy/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/magic-proxy/proxy.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AA8H5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,EAAE,EACxE,YAAY,EAAE,CAAC,EACf,cAAc,GAAE,CAAgB,EAChC,kBAAkB,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,GACtC,CAAC,CAyBH;AAED,eAAO,MAAM,aAAa,eAA6B,CAAA;AACvD;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,aAAa,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAMzD"}