mobx-keystone-yjs 1.3.1 → 1.4.0

package/src/binding/convertYjsDataToJson.ts

@@ -0,0 +1,31 @@
+import { modelSnapshotOutWithMetadata } from "mobx-keystone"
+import * as Y from "yjs"
+import { JsonValue } from "../jsonTypes"
+import { YjsTextModel } from "./YjsTextModel"
+
+export function convertYjsDataToJson(
+  yjsData: Y.Array<unknown> | Y.Map<unknown> | Y.Text | unknown
+): JsonValue {
+  if (yjsData instanceof Y.Array) {
+    return yjsData.map((v) => convertYjsDataToJson(v))
+  }
+
+  if (yjsData instanceof Y.Map) {
+    const obj: Record<string, JsonValue> = {}
+    yjsData.forEach((v, k) => {
+      obj[k] = convertYjsDataToJson(v)
+    })
+    return obj
+  }
+
+  if (yjsData instanceof Y.Text) {
+    const deltas = yjsData.toDelta()
+
+    return modelSnapshotOutWithMetadata(YjsTextModel, {
+      deltaList: deltas.length > 0 ? [{ $frozen: true, data: deltas }] : [],
+    }) as JsonValue
+  }
+
+  // assume it's a primitive
+  return yjsData as JsonValue
+}

package/src/binding/convertYjsEventToPatches.ts

@@ -1,85 +1,92 @@
-import { Patch } from "mobx-keystone"
-import * as Y from "yjs"
-import { JsonArray, JsonObject, JsonValue } from "../jsonTypes"
-import { failure } from "../utils/error"
-
-export function convertYjsEventToPatches(event: Y.YEvent<any>): Patch[] {
-  const patches: Patch[] = []
-
-  if (event instanceof Y.YMapEvent) {
-    const source = event.target as Y.Map<any>
-
-    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) {
-        // remove X items at retain position
-        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: Y.Map<any> | Y.Array<any> | JsonValue) {
-  if (v instanceof Y.Map || v instanceof Y.Array) {
-    return v.toJSON() as JsonObject | JsonArray
-  } else {
-    return v
-  }
-}
+import { Patch } from "mobx-keystone"
+import * as Y from "yjs"
+import { JsonArray, JsonObject, JsonValue } from "../jsonTypes"
+import { failure } from "../utils/error"
+
+export function convertYjsEventToPatches(event: Y.YEvent<any>): Patch[] {
+  const patches: Patch[] = []
+
+  if (event instanceof Y.YMapEvent) {
+    const source = event.target as Y.Map<any>
+
+    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) {
+        // remove X items at retain position
+        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++
+        })
+      }
+    })
+  } else if (event instanceof Y.YTextEvent) {
+    const path = [...event.path, "deltaList", -1 /* last item */]
+    patches.push({
+      op: "add",
+      path,
+      value: { $frozen: true, data: event.delta },
+    })
+  }
+
+  return patches
+}
+
+function toPlainValue(v: Y.Map<any> | Y.Array<any> | JsonValue) {
+  if (v instanceof Y.Map || v instanceof Y.Array) {
+    return v.toJSON() as JsonObject | JsonArray
+  } else {
+    return v
+  }
+}

package/src/binding/resolveYjsPath.ts

@@ -0,0 +1,27 @@
+import * as Y from "yjs"
+import { failure } from "../utils/error"
+import { getOrCreateYjsCollectionAtom } from "../utils/getOrCreateYjsCollectionAtom"
+
+export function resolveYjsPath(yjsObject: unknown, path: readonly (string | number)[]): unknown {
+  let currentYjsObject: unknown = yjsObject
+
+  path.forEach((pathPart, i) => {
+    if (currentYjsObject instanceof Y.Map) {
+      getOrCreateYjsCollectionAtom(currentYjsObject).reportObserved()
+      const key = String(pathPart)
+      currentYjsObject = currentYjsObject.get(key)
+    } else if (currentYjsObject instanceof Y.Array) {
+      getOrCreateYjsCollectionAtom(currentYjsObject).reportObserved()
+      const key = Number(pathPart)
+      currentYjsObject = currentYjsObject.get(key)
+    } else {
+      throw failure(
+        `Y.Map or Y.Array was expected at path ${JSON.stringify(
+          path.slice(0, i)
+        )} in order to resolve path ${JSON.stringify(path)}, but got ${currentYjsObject} instead`
+      )
+    }
+  })
+
+  return currentYjsObject
+}

package/src/binding/yjsBindingContext.ts

@@ -1,12 +1,42 @@
-import { AnyType, createContext } from "mobx-keystone"
-import * as Y from "yjs"
-
-export interface YjsBindingContext {
-  yjsDoc: Y.Doc
-  yjsObject: Y.Map<unknown> | Y.Array<unknown>
-  mobxKeystoneType: AnyType
-  yjsOrigin: symbol
-  boundObject: unknown | undefined
-}
-
-export const yjsBindingContext = createContext<YjsBindingContext | undefined>(undefined)
+import { AnyType, createContext } from "mobx-keystone"
+import * as Y from "yjs"
+
+/**
+ * Context with info on how a mobx-keystone model is bound to a Y.js data structure.
+ */
+export interface YjsBindingContext {
+  /**
+   * The Y.js document.
+   */
+  yjsDoc: Y.Doc
+
+  /**
+   * The bound Y.js data structure.
+   */
+  yjsObject: Y.Map<unknown> | Y.Array<unknown> | Y.Text
+
+  /**
+   * The mobx-keystone model type.
+   */
+  mobxKeystoneType: AnyType
+
+  /**
+   * The origin symbol used for transactions.
+   */
+  yjsOrigin: symbol
+
+  /**
+   * The bound mobx-keystone instance.
+   */
+  boundObject: unknown | undefined
+
+  /**
+   * Whether we are currently applying Y.js changes to the mobx-keystone model.
+   */
+  isApplyingYjsChangesToMobxKeystone: boolean
+}
+
+/**
+ * Context with info on how a mobx-keystone model is bound to a Y.js data structure.
+ */
+export const yjsBindingContext = createContext<YjsBindingContext | undefined>(undefined)

package/src/index.ts

@@ -1,9 +1,10 @@
-export { bindYjsToMobxKeystone } from "./binding/bindYjsToMobxKeystone"
-export {
-  applyJsonArrayYArray,
-  applyJsonObjectToYMap,
-  convertJsonToYjsData,
-} from "./binding/convertJsonToYjsData"
-export { yjsBindingContext } from "./binding/yjsBindingContext"
-export type { YjsBindingContext } from "./binding/yjsBindingContext"
-export { MobxKeystoneYjsError } from "./utils/error"
+export { YjsTextModel, yjsTextModelId } from "./binding/YjsTextModel"
+export { bindYjsToMobxKeystone } from "./binding/bindYjsToMobxKeystone"
+export {
+  applyJsonArrayToYArray,
+  applyJsonObjectToYMap,
+  convertJsonToYjsData,
+} from "./binding/convertJsonToYjsData"
+export { yjsBindingContext } from "./binding/yjsBindingContext"
+export type { YjsBindingContext } from "./binding/yjsBindingContext"
+export { MobxKeystoneYjsError } from "./utils/error"

package/src/utils/getOrCreateYjsCollectionAtom.ts

@@ -0,0 +1,18 @@
+import { IAtom, createAtom } from "mobx"
+import * as Y from "yjs"
+
+const yjsCollectionAtoms = new WeakMap<Y.Map<unknown> | Y.Array<unknown>, IAtom>()
+
+/**
+ * @internal
+ */
+export const getOrCreateYjsCollectionAtom = (
+  yjsCollection: Y.Map<unknown> | Y.Array<unknown>
+): IAtom => {
+  let atom = yjsCollectionAtoms.get(yjsCollection)
+  if (!atom) {
+    atom = createAtom(`yjsCollectionAtom`)
+    yjsCollectionAtoms.set(yjsCollection, atom)
+  }
+  return atom
+}