feat(presence): Add support for presences

Author: Calyhre

lib/json1.ts

@@ -20,8 +20,8 @@
 // import log from './log'
 import deepEqual from './deepEqual.js'
 import deepClone from './deepClone.js'
-import {ReadCursor, WriteCursor, readCursor, writeCursor, advancer, eachChildOf, isValidPathItem} from './cursor.js'
-import { Doc, JSONOpComponent, Path, Key, JSONOp, JSONOpList, Conflict, ConflictType } from './types.js'
+import { ReadCursor, WriteCursor, readCursor, writeCursor, advancer, eachChildOf, isValidPathItem } from './cursor.js'
+import { Doc, JSONOpComponent, Path, Presence, Key, JSONOp, JSONOpList, Conflict, ConflictType } from './types.js'
 
 const RELEASE_MODE = process.env.JSON1_RELEASE_MODE
 const log: (...args: any) => void = RELEASE_MODE ? (() => {}) : require('./log').default
@@ -57,6 +57,7 @@ export const type = {
 
   apply,
   transformPosition,
+  transformPresence,
   compose,
   tryTransform,
   transform,
@@ -688,7 +689,11 @@ function transformPosition(path: Path, op: JSONOp): Path | null {
       if (et) {
         const e = getEdit(c!)
         log('Embedded edit', e, et)
-        if (et.transformPosition) path[i] = et.transformPosition(path[i], e)
+        if (et.transformPosition) {
+            path[i] = et.transformPosition(path[i], e)
+        } else if (et.transformCursor) {
+            path[i] = et.transformCursor(path[i], e)
+        }
         // Its invalid for the operation to have drops inside the embedded edit here.
         break
       }
@@ -721,6 +726,25 @@ function transformPosition(path: Path, op: JSONOp): Path | null {
   return path
 }
 
+function transformPresence(presence: Presence | null, op: JSONOp, isOwnOperation: boolean): Presence | null {
+    if (!presence || !presence.start || !presence.end) {
+        return null
+    }
+
+    const start = transformPosition(presence.start, op)
+    const end = transformPosition(presence.end, op)
+
+    if (start && end) {
+        return { start, end }
+    } else if (start) {
+        return { start, end: start }
+    } else if (end) {
+        return { start: end, end }
+    }
+
+    return null
+}
+
 
 // ****** Compose
 

lib/types.ts

@@ -57,6 +57,10 @@ export type JSONOp = null | JSONOpList
 
 export type Key = number | string
 export type Path = Key[]
+export type Presence = {
+    start: Path,
+    end: Path,
+}
 
 /**
  * JSON documents must be able to round-trip through JSON.stringify /

package-lock.json

@@ -12,6 +12,7 @@
     "mocha": "^7.1.1",
     "ot-fuzzer": "1.3",
     "ot-simple": "^1.0.0",
+    "rich-text": "^4.1.0",
     "terser": "^4.6.7",
     "typescript": "^3.9.5"
   },

package.json

@@ -0,0 +1,86 @@
+const assert = require("assert");
+const Delta = require("quill-delta");
+const { type } = require("../dist/json1.release");
+
+type.registerSubtype(require("rich-text"));
+
+describe("presences", () => {
+  it("transforms json1 only presences", () => {
+    const op = ["z", 0, { i: "hello" }];
+    const presenceBefore = { start: ["z", 0], end: ["z", 1] };
+    const presenceAfter = { start: ["z", 1], end: ["z", 2] };
+
+    assert.deepStrictEqual(
+      type.transformPresence(presenceBefore, op),
+      presenceAfter
+    );
+  });
+
+  it("transforms json1 + text-unicode presences", () => {
+    const op = ["z", [0, { i: "hello" }], [2, { es: ["hi"] }]];
+    const presenceBefore = { start: ["z", 1, 1], end: ["z", 2, 0] };
+    const presenceAfter = { start: ["z", 2, 3], end: ["z", 3, 0] };
+
+    assert.deepStrictEqual(
+      type.transformPresence(presenceBefore, op),
+      presenceAfter
+    );
+  });
+
+  it("transforms json1 + rich-text presences", () => {
+    const op = [
+      "z",
+      [0, { i: "hello" }],
+      [4, { et: "rich-text", e: new Delta([{ insert: "bye" }]) }],
+    ];
+    const presenceBefore = { start: ["z", 3, 1], end: ["z", 4, 0] };
+    const presenceAfter = { start: ["z", 4, 4], end: ["z", 5, 0] };
+
+    assert.deepStrictEqual(
+      type.transformPresence(presenceBefore, op),
+      presenceAfter
+    );
+  });
+
+  it("does nothing on null presences", () => {
+    const op = ["z", 0, { i: "hello" }];
+
+    assert.deepStrictEqual(type.transformPresence(null, op), null);
+  });
+
+  it("returns null on missing start or end", () => {
+    const op = ["z", 0, { i: "hello" }];
+
+    assert.deepStrictEqual(
+      type.transformPresence({ start: null, end: [] }, op),
+      null
+    );
+
+    assert.deepStrictEqual(
+      type.transformPresence({ start: [], end: null }, op),
+      null
+    );
+  });
+
+  it("returns collapsed presence when start container is removed", () => {
+    const op = ["z", 0, { r: true }];
+    const presenceBefore = { start: ["z", 0], end: ["z", 1] };
+    const presenceAfter = { start: ["z", 0], end: ["z", 0] };
+
+    assert.deepStrictEqual(
+      type.transformPresence(presenceBefore, op),
+      presenceAfter
+    );
+  });
+
+  it("returns collapsed presence when end container is removed", () => {
+    const op = ["z", 1, { r: true }];
+    const presenceBefore = { start: ["z", 0], end: ["z", 1] };
+    const presenceAfter = { start: ["z", 0], end: ["z", 0] };
+
+    assert.deepStrictEqual(
+      type.transformPresence(presenceBefore, op),
+      presenceAfter
+    );
+  });
+});