mobx-keystone-yjs 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Change Log
+
+## 1.0.0
+
+- First public release.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Javier González Garcés
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+<p align="center">
+  <h1 align="center">mobx-keystone-yjs</h1>
+</p>
+<p align="center">
+  <i>Seamlessly integrate mobx-keystone models with the Y.js ecosystem for an unmatched toolkit to build dynamic, responsive, and collaborative web applications</i>
+</p>
+
+<p align="center">
+  <a aria-label="NPM version" href="https://www.npmjs.com/package/mobx-keystone-yjs">
+    <img src="https://img.shields.io/npm/v/mobx-keystone-yjs.svg?style=for-the-badge&logo=npm&labelColor=333" />
+  </a>
+  <a aria-label="License" href="./LICENSE">
+    <img src="https://img.shields.io/npm/l/mobx-keystone-yjs.svg?style=for-the-badge&labelColor=333" />
+  </a>
+  <a aria-label="Types" href="./packages/mobx-keystone-yjs/tsconfig.json">
+    <img src="https://img.shields.io/npm/types/mobx-keystone-yjs.svg?style=for-the-badge&logo=typescript&labelColor=333" />
+  </a>
+  <br />
+  <a aria-label="CI" href="https://github.com/xaviergonz/mobx-keystone/actions/workflows/main.yml">
+    <img src="https://img.shields.io/github/actions/workflow/status/xaviergonz/mobx-keystone/main.yml?branch=master&label=CI&logo=github&style=for-the-badge&labelColor=333" />
+  </a>
+</p>
+
+> ## See a [working example](https://mobx-keystone.js.org/examples/yjs-binding) in [mobx-keystone.js.org](https://mobx-keystone.js.org)
+
+## Introduction
+
+`mobx-keystone-yjs` seamlessly integrates `mobx-keystone` models with the `Y.js` ecosystem, providing developers with an unmatched toolkit to build dynamic, responsive, and collaborative web applications. Some of the key advantages and capabilities that this integration brings to your projects are:
+
+## Real-time Collaboration and Synchronization
+
+`mobx-keystone-yjs` bridges the gap between local state management and remote synchronization, allowing multiple users to interact with the same application data in real-time. This synchronization is not just limited to client-server models but extends to peer-to-peer (P2P) environments as well. Whether you're building a collaborative text editor, a shared to-do list, or any interactive platform, this binding ensures that all participants can see and respond to changes instantly, no matter where they are, transparently.
+
+## Offline Support and Optimistic UI Changes
+
+One of the standout features of `Y.js` is its robust offline support. Users can continue to interact with the application even when disconnected from the network. Changes made offline are seamlessly integrated once the connection is reestablished, thanks to the conflict-free replicated data types (CRDTs) at the heart of `Y.js`. This functionality not only enhances the user experience but also ensures data integrity and consistency across all states. Binding this functionality to `mobx-keystone` models means that you can take advantage of these features without having to write any additional code.
+
+Optimistic UI updates play a crucial role in making applications feel more responsive. With CRDTs changes made by users can be immediately reflected in the UI, without waiting for server confirmation. This approach minimizes perceived latency, providing a smoother and more engaging user experience.
+
+## Client Synchronization and Data Integrity
+
+Binding `Y.js` and `mobx-keystone` ensures that client states are synchronized efficiently and accurately. The models are automatically updated to reflect the latest shared state, ensuring that all users have a consistent view of the data. Furthermore, the use of CRDTs in `Y.js` guarantees that even in complex, multi-user scenarios, data integrity is maintained. Conflicts are resolved automatically, ensuring that the final state is always a true representation of all users' inputs.
+
+## P2P Support and Scalability
+
+By leveraging `Y.js`'s P2P capabilities, `mobx-keystone-yjs` enables direct client-to-client communication, bypassing traditional server-based data flow. This not only reduces server load but also opens up new possibilities for applications where direct user-to-user interaction is preferred. The scalability offered by this approach means that your application can support a growing number of users without a proportional increase in server resources.
+
+## Installation
+
+> `npm install mobx-keystone-yjs`
+
+> `yarn add mobx-keystone-yjs`

package/dist/mobx-keystone-yjs.esm.js

@@ -0,0 +1,272 @@
+import { onPatches, onSnapshot, getParentToChildPath, onGlobalPatches, fromSnapshot, applyPatches } from "mobx-keystone";
+import * as Y from "yjs";
+class MobxKeystoneYjsError extends Error {
+  constructor(msg) {
+    super(msg);
+    Object.setPrototypeOf(this, MobxKeystoneYjsError.prototype);
+  }
+}
+function failure(msg) {
+  return new MobxKeystoneYjsError(msg);
+}
+function isJSONPrimitive(v) {
+  const t = typeof v;
+  return t === "string" || t === "number" || t === "boolean" || v === null;
+}
+function isJSONArray(v) {
+  return Array.isArray(v);
+}
+function isJSONObject(v) {
+  return !isJSONArray(v) && typeof v === "object";
+}
+function toYDataType(v) {
+  if (isJSONPrimitive(v)) {
+    return v;
+  } else if (isJSONArray(v)) {
+    const arr = new Y.Array();
+    applyJsonArray(arr, v);
+    return arr;
+  } else if (isJSONObject(v)) {
+    const map = new Y.Map();
+    applyJsonObject(map, v);
+    return map;
+  } else {
+    return void 0;
+  }
+}
+function applyJsonArray(dest, source) {
+  dest.push(source.map(toYDataType));
+}
+function applyJsonObject(dest, source) {
+  Object.entries(source).forEach(([k, v]) => {
+    dest.set(k, toYDataType(v));
+  });
+}
+function applyMobxKeystonePatchToYjsObject(patch, yjs) {
+  if (patch.path.length > 1) {
+    const [key, ...rest] = patch.path;
+    if (yjs instanceof Y.Map) {
+      const child = yjs.get(String(key));
+      if (child === void 0) {
+        throw failure(`invalid patch path, key "${key}" not found in Yjs map - patch: ${JSON.stringify(patch)}`);
+      }
+      applyMobxKeystonePatchToYjsObject({ ...patch, path: rest }, child);
+    } else if (yjs instanceof Y.Array) {
+      const child = yjs.get(Number(key));
+      if (child === void 0) {
+        throw failure(`invalid patch path, key "${key}" not found in Yjs array - patch: ${JSON.stringify(patch)}`);
+      }
+      applyMobxKeystonePatchToYjsObject({ ...patch, path: rest }, child);
+    } else {
+      throw failure(`invalid patch path, key "${key}" not found in unknown Yjs object - patch: ${JSON.stringify(patch)}`);
+    }
+  } else if (patch.path.length === 1) {
+    if (yjs instanceof Y.Map) {
+      const key = String(patch.path[0]);
+      switch (patch.op) {
+        case "add":
+        case "replace": {
+          yjs.set(key, toYDataType(patch.value));
+          break;
+        }
+        case "remove": {
+          yjs.delete(key);
+          break;
+        }
+        default: {
+          throw failure(`invalid patch operation for map`);
+        }
+      }
+    } else if (yjs instanceof Y.Array) {
+      const key = patch.path[0];
+      switch (patch.op) {
+        case "replace": {
+          if (key === "length") {
+            if (yjs.length > patch.value) {
+              const toDelete = yjs.length - patch.value;
+              yjs.delete(patch.value, toDelete);
+            } else if (yjs.length < patch.value) {
+              const toInsert = patch.value - yjs.length;
+              yjs.insert(yjs.length, Array(toInsert).fill(void 0));
+            }
+          } else {
+            yjs.delete(Number(key));
+            yjs.insert(Number(key), [toYDataType(patch.value)]);
+          }
+          break;
+        }
+        case "add": {
+          yjs.insert(Number(key), [toYDataType(patch.value)]);
+          break;
+        }
+        case "remove": {
+          yjs.delete(Number(key));
+          break;
+        }
+        default: {
+          throw failure(`invalid patch operation for array`);
+        }
+      }
+    } else {
+      throw failure(`invalid patch path, the Yjs object is of an unkown type, so key "${patch.path[0]}" cannot be found in it`);
+    }
+  } else {
+    throw failure(`invalid patch path, it cannot be empty`);
+  }
+}
+function convertYjsEventToPatches(event) {
+  const patches = [];
+  if (event instanceof Y.YMapEvent) {
+    const source = event.target;
+    event.changes.keys.forEach((change, key) => {
+      const path = [...event.path, key];
+      switch (change.action) {
+        case "add":
+          patches.push({
+            op: "add",
+            path,
+            value: toPlainValue(source.get(key))
+          });
+          break;
+        case "update":
+          patches.push({
+            op: "replace",
+            path,
+            value: toPlainValue(source.get(key))
+          });
+          break;
+        case "delete":
+          patches.push({
+            op: "remove",
+            path
+          });
+          break;
+        default:
+          throw failure(`unsupported Yjs map event action: ${change.action}`);
+      }
+    });
+  } else if (event instanceof Y.YArrayEvent) {
+    let retain = 0;
+    event.changes.delta.forEach((change) => {
+      if (change.retain) {
+        retain += change.retain;
+      }
+      if (change.delete) {
+        const path = [...event.path, retain];
+        for (let i = 0; i < change.delete; i++) {
+          patches.push({
+            op: "remove",
+            path
+          });
+        }
+      }
+      if (change.insert) {
+        const newValues = Array.isArray(change.insert) ? change.insert : [change.insert];
+        newValues.forEach((v) => {
+          const path = [...event.path, retain];
+          patches.push({
+            op: "add",
+            path,
+            value: toPlainValue(v)
+          });
+          retain++;
+        });
+      }
+    });
+  }
+  return patches;
+}
+function toPlainValue(v) {
+  if (v instanceof Y.Map || v instanceof Y.Array) {
+    return v.toJSON();
+  } else {
+    return v;
+  }
+}
+function bindYjsToMobxKeystone({ yjsDoc, yjsObject, mobxKeystoneType }) {
+  const yjsJson = yjsObject.toJSON();
+  const initializationGlobalPatches = [];
+  const createBoundObject = () => {
+    const disposeOnGlobalPatches = onGlobalPatches((target, patches) => {
+      initializationGlobalPatches.push({ target, patches });
+    });
+    try {
+      return fromSnapshot(mobxKeystoneType, yjsJson);
+    } finally {
+      disposeOnGlobalPatches();
+    }
+  };
+  const boundObject = createBoundObject();
+  let applyingMobxKeystoneChanges = 0;
+  const yjsOrigin = Symbol("bindYjsToMobxKeystoneTransactionOrigin");
+  const observeDeepCb = (events) => {
+    const patches = [];
+    events.forEach((event) => {
+      if (event.transaction.origin !== yjsOrigin) {
+        patches.push(...convertYjsEventToPatches(event));
+      }
+    });
+    if (patches.length > 0) {
+      applyingMobxKeystoneChanges++;
+      try {
+        applyPatches(boundObject, patches);
+      } finally {
+        applyingMobxKeystoneChanges--;
+      }
+    }
+  };
+  yjsObject.observeDeep(observeDeepCb);
+  let pendingPatches = [];
+  const disposeOnPatches = onPatches(boundObject, (patches) => {
+    if (applyingMobxKeystoneChanges > 0) {
+      return;
+    }
+    pendingPatches.push(...patches);
+  });
+  const disposeOnSnapshot = onSnapshot(boundObject, () => {
+    if (pendingPatches.length === 0) {
+      return;
+    }
+    const patches = pendingPatches;
+    pendingPatches = [];
+    yjsDoc.transact(() => {
+      patches.forEach((patch) => {
+        applyMobxKeystonePatchToYjsObject(patch, yjsObject);
+      });
+    }, yjsOrigin);
+  });
+  yjsDoc.transact(() => {
+    let boundObjectFound = false;
+    initializationGlobalPatches.forEach(({ target, patches }) => {
+      if (!boundObjectFound) {
+        if (target !== boundObject) {
+          return;
+        }
+        boundObjectFound = true;
+      }
+      const parentToChildPath = getParentToChildPath(boundObject, target);
+      if (parentToChildPath !== void 0) {
+        patches.forEach((patch) => {
+          applyMobxKeystonePatchToYjsObject({
+            ...patch,
+            path: [...parentToChildPath, ...patch.path]
+          }, yjsObject);
+        });
+      }
+    });
+  }, yjsOrigin);
+  return {
+    boundObject,
+    dispose: () => {
+      disposeOnPatches();
+      disposeOnSnapshot();
+      yjsObject.unobserveDeep(observeDeepCb);
+    },
+    yjsOrigin
+  };
+}
+export {
+  MobxKeystoneYjsError,
+  bindYjsToMobxKeystone
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mobx-keystone-yjs.esm.mjs","sources":["../src/utils/error.ts","../src/binding/toYDataType.ts","../src/binding/applyMobxKeystonePatchToYjsObject.ts","../src/binding/convertYjsEventToPatches.ts","../src/binding/bindYjsToMobxKeystone.ts"],"sourcesContent":["/**\r\n * A mobx-keystone-yjs error.\r\n */\r\nexport class MobxKeystoneYjsError extends Error {\r\n  constructor(msg: string) {\r\n    super(msg)\r\n\r\n    // Set the prototype explicitly.\r\n    Object.setPrototypeOf(this, MobxKeystoneYjsError.prototype)\r\n  }\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport function failure(msg: string) {\r\n  return new MobxKeystoneYjsError(msg)\r\n}\r\n","import * as Y from \"yjs\"\r\nimport { JSONValue, JSONArray, JSONObject, JSONPrimitive } from \"../jsonTypes\"\r\n\r\nfunction isJSONPrimitive(v: JSONValue): v is JSONPrimitive {\r\n  const t = typeof v\r\n  return t === \"string\" || t === \"number\" || t === \"boolean\" || v === null\r\n}\r\n\r\nfunction isJSONArray(v: JSONValue): v is JSONArray {\r\n  return Array.isArray(v)\r\n}\r\n\r\nfunction isJSONObject(v: JSONValue): v is JSONObject {\r\n  return !isJSONArray(v) && typeof v === \"object\"\r\n}\r\n\r\nexport function toYDataType(v: JSONValue) {\r\n  if (isJSONPrimitive(v)) {\r\n    return v\r\n  } else if (isJSONArray(v)) {\r\n    const arr = new Y.Array()\r\n    applyJsonArray(arr, v)\r\n    return arr\r\n  } else if (isJSONObject(v)) {\r\n    const map = new Y.Map()\r\n    applyJsonObject(map, v)\r\n    return map\r\n  } else {\r\n    return undefined\r\n  }\r\n}\r\n\r\nfunction applyJsonArray(dest: Y.Array<unknown>, source: JSONArray) {\r\n  dest.push(source.map(toYDataType))\r\n}\r\n\r\nfunction applyJsonObject(dest: Y.Map<unknown>, source: JSONObject) {\r\n  Object.entries(source).forEach(([k, v]) => {\r\n    dest.set(k, toYDataType(v))\r\n  })\r\n}\r\n","import { Patch } from \"mobx-keystone\"\r\nimport { failure } from \"../utils/error\"\r\nimport * as Y from \"yjs\"\r\nimport { toYDataType } from \"./toYDataType\"\r\n\r\nexport function applyMobxKeystonePatchToYjsObject(patch: Patch, yjs: unknown): void {\r\n  if (patch.path.length > 1) {\r\n    const [key, ...rest] = patch.path\r\n\r\n    if (yjs instanceof Y.Map) {\r\n      const child = yjs.get(String(key))\r\n      if (child === undefined) {\r\n        throw failure(\r\n          `invalid patch path, key \"${key}\" not found in Yjs map - patch: ${JSON.stringify(patch)}`\r\n        )\r\n      }\r\n      applyMobxKeystonePatchToYjsObject({ ...patch, path: rest }, child)\r\n    } else if (yjs instanceof Y.Array) {\r\n      const child = yjs.get(Number(key))\r\n      if (child === undefined) {\r\n        throw failure(\r\n          `invalid patch path, key \"${key}\" not found in Yjs array - patch: ${JSON.stringify(\r\n            patch\r\n          )}`\r\n        )\r\n      }\r\n      applyMobxKeystonePatchToYjsObject({ ...patch, path: rest }, child)\r\n    } else {\r\n      throw failure(\r\n        `invalid patch path, key \"${key}\" not found in unknown Yjs object - patch: ${JSON.stringify(\r\n          patch\r\n        )}`\r\n      )\r\n    }\r\n  } else if (patch.path.length === 1) {\r\n    if (yjs instanceof Y.Map) {\r\n      const key = String(patch.path[0])\r\n\r\n      switch (patch.op) {\r\n        case \"add\":\r\n        case \"replace\": {\r\n          yjs.set(key, toYDataType(patch.value))\r\n          break\r\n        }\r\n        case \"remove\": {\r\n          yjs.delete(key)\r\n          break\r\n        }\r\n        default: {\r\n          throw failure(`invalid patch operation for map`)\r\n        }\r\n      }\r\n    } else if (yjs instanceof Y.Array) {\r\n      const key = patch.path[0]\r\n\r\n      switch (patch.op) {\r\n        case \"replace\": {\r\n          if (key === \"length\") {\r\n            if (yjs.length > patch.value) {\r\n              const toDelete = yjs.length - patch.value\r\n              yjs.delete(patch.value, toDelete)\r\n            } else if (yjs.length < patch.value) {\r\n              const toInsert = patch.value - yjs.length\r\n              yjs.insert(yjs.length, Array(toInsert).fill(undefined))\r\n            }\r\n          } else {\r\n            yjs.delete(Number(key))\r\n            yjs.insert(Number(key), [toYDataType(patch.value)])\r\n          }\r\n          break\r\n        }\r\n        case \"add\": {\r\n          yjs.insert(Number(key), [toYDataType(patch.value)])\r\n          break\r\n        }\r\n        case \"remove\": {\r\n          yjs.delete(Number(key))\r\n          break\r\n        }\r\n        default: {\r\n          throw failure(`invalid patch operation for array`)\r\n        }\r\n      }\r\n    } else {\r\n      throw failure(\r\n        `invalid patch path, the Yjs object is of an unkown type, so key \"${patch.path[0]}\" cannot be found in it`\r\n      )\r\n    }\r\n  } else {\r\n    throw failure(`invalid patch path, it cannot be empty`)\r\n  }\r\n}\r\n","import { Patch } from \"mobx-keystone\"\r\nimport * as Y from \"yjs\"\r\nimport { JSONArray, JSONObject, JSONValue } from \"../jsonTypes\"\r\nimport { failure } from \"../utils/error\"\r\n\r\nexport function convertYjsEventToPatches(event: Y.YEvent<any>): Patch[] {\r\n  const patches: Patch[] = []\r\n\r\n  if (event instanceof Y.YMapEvent) {\r\n    const source = event.target as Y.Map<any>\r\n\r\n    event.changes.keys.forEach((change, key) => {\r\n      const path = [...event.path, key]\r\n\r\n      switch (change.action) {\r\n        case \"add\":\r\n          patches.push({\r\n            op: \"add\",\r\n            path,\r\n            value: toPlainValue(source.get(key)),\r\n          })\r\n          break\r\n\r\n        case \"update\":\r\n          patches.push({\r\n            op: \"replace\",\r\n            path,\r\n            value: toPlainValue(source.get(key)),\r\n          })\r\n          break\r\n\r\n        case \"delete\":\r\n          patches.push({\r\n            op: \"remove\",\r\n            path,\r\n          })\r\n          break\r\n\r\n        default:\r\n          throw failure(`unsupported Yjs map event action: ${change.action}`)\r\n      }\r\n    })\r\n  } else if (event instanceof Y.YArrayEvent) {\r\n    let retain = 0\r\n    event.changes.delta.forEach((change) => {\r\n      if (change.retain) {\r\n        retain += change.retain\r\n      }\r\n\r\n      if (change.delete) {\r\n        // remove X items at retain position\r\n        const path = [...event.path, retain]\r\n        for (let i = 0; i < change.delete; i++) {\r\n          patches.push({\r\n            op: \"remove\",\r\n            path,\r\n          })\r\n        }\r\n      }\r\n\r\n      if (change.insert) {\r\n        const newValues = Array.isArray(change.insert) ? change.insert : [change.insert]\r\n        newValues.forEach((v) => {\r\n          const path = [...event.path, retain]\r\n          patches.push({\r\n            op: \"add\",\r\n            path,\r\n            value: toPlainValue(v),\r\n          })\r\n          retain++\r\n        })\r\n      }\r\n    })\r\n  }\r\n\r\n  return patches\r\n}\r\n\r\nfunction toPlainValue(v: Y.Map<any> | Y.Array<any> | JSONValue) {\r\n  if (v instanceof Y.Map || v instanceof Y.Array) {\r\n    return v.toJSON() as JSONObject | JSONArray\r\n  } else {\r\n    return v\r\n  }\r\n}\r\n","import {\r\n  AnyDataModel,\r\n  AnyModel,\r\n  AnyStandardType,\r\n  ModelClass,\r\n  Patch,\r\n  TypeToData,\r\n  applyPatches,\r\n  fromSnapshot,\r\n  getParentToChildPath,\r\n  onGlobalPatches,\r\n  onPatches,\r\n  onSnapshot,\r\n} from \"mobx-keystone\"\r\nimport * as Y from \"yjs\"\r\nimport { applyMobxKeystonePatchToYjsObject } from \"./applyMobxKeystonePatchToYjsObject\"\r\nimport { convertYjsEventToPatches } from \"./convertYjsEventToPatches\"\r\n\r\nexport function bindYjsToMobxKeystone<\r\n  TType extends AnyStandardType | ModelClass<AnyModel> | ModelClass<AnyDataModel>,\r\n>({\r\n  yjsDoc,\r\n  yjsObject,\r\n  mobxKeystoneType,\r\n}: {\r\n  yjsDoc: Y.Doc\r\n  yjsObject: Y.Map<unknown> | Y.Array<unknown>\r\n  mobxKeystoneType: TType\r\n}): {\r\n  boundObject: TypeToData<TType>\r\n  dispose(): void\r\n  yjsOrigin: symbol\r\n} {\r\n  const yjsJson = yjsObject.toJSON()\r\n\r\n  const initializationGlobalPatches: { target: object; patches: Patch[] }[] = []\r\n\r\n  const createBoundObject = () => {\r\n    const disposeOnGlobalPatches = onGlobalPatches((target, patches) => {\r\n      initializationGlobalPatches.push({ target, patches })\r\n    })\r\n\r\n    try {\r\n      return fromSnapshot(mobxKeystoneType, yjsJson as any)\r\n    } finally {\r\n      disposeOnGlobalPatches()\r\n    }\r\n  }\r\n\r\n  const boundObject = createBoundObject()\r\n\r\n  let applyingMobxKeystoneChanges = 0\r\n  const yjsOrigin = Symbol(\"bindYjsToMobxKeystoneTransactionOrigin\")\r\n\r\n  // bind any changes from yjs to mobx-keystone\r\n  const observeDeepCb = (events: Y.YEvent<any>[]) => {\r\n    const patches: Patch[] = []\r\n    events.forEach((event) => {\r\n      if (event.transaction.origin !== yjsOrigin) {\r\n        patches.push(...convertYjsEventToPatches(event))\r\n      }\r\n    })\r\n\r\n    if (patches.length > 0) {\r\n      applyingMobxKeystoneChanges++\r\n      try {\r\n        applyPatches(boundObject, patches)\r\n      } finally {\r\n        applyingMobxKeystoneChanges--\r\n      }\r\n    }\r\n  }\r\n\r\n  yjsObject.observeDeep(observeDeepCb)\r\n\r\n  // bind any changes from mobx-keystone to yjs\r\n  let pendingPatches: Patch[] = []\r\n  const disposeOnPatches = onPatches(boundObject, (patches) => {\r\n    if (applyingMobxKeystoneChanges > 0) {\r\n      return\r\n    }\r\n\r\n    pendingPatches.push(...patches)\r\n  })\r\n\r\n  // this is only used so we can transact all patches to the snapshot boundary\r\n  const disposeOnSnapshot = onSnapshot(boundObject, () => {\r\n    if (pendingPatches.length === 0) {\r\n      return\r\n    }\r\n\r\n    const patches = pendingPatches\r\n    pendingPatches = []\r\n\r\n    yjsDoc.transact(() => {\r\n      patches.forEach((patch) => {\r\n        applyMobxKeystonePatchToYjsObject(patch, yjsObject)\r\n      })\r\n    }, yjsOrigin)\r\n  })\r\n\r\n  // sync initial patches, that might include setting defaults, IDs, etc\r\n  yjsDoc.transact(() => {\r\n    // we need to skip initializations until we hit the initialization of the bound object\r\n    // this is because default objects might be created and initialized before the main object\r\n    // but we just need to catch when those are actually assigned to the bound object\r\n    let boundObjectFound = false\r\n\r\n    initializationGlobalPatches.forEach(({ target, patches }) => {\r\n      if (!boundObjectFound) {\r\n        if (target !== boundObject) {\r\n          return // skip\r\n        }\r\n        boundObjectFound = true\r\n      }\r\n\r\n      const parentToChildPath = getParentToChildPath(boundObject, target)\r\n      // this is undefined only if target is not a child of boundModel\r\n      if (parentToChildPath !== undefined) {\r\n        patches.forEach((patch) => {\r\n          applyMobxKeystonePatchToYjsObject(\r\n            {\r\n              ...patch,\r\n              path: [...parentToChildPath, ...patch.path],\r\n            },\r\n            yjsObject\r\n          )\r\n        })\r\n      }\r\n    })\r\n  }, yjsOrigin)\r\n\r\n  return {\r\n    boundObject,\r\n    dispose: () => {\r\n      disposeOnPatches()\r\n      disposeOnSnapshot()\r\n      yjsObject.unobserveDeep(observeDeepCb)\r\n    },\r\n    yjsOrigin,\r\n  }\r\n}\r\n"],"names":[],"mappings":"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"}