feat(json-ot): 🎸 add string type transform() function

Author: streamich

src/json-ot/types/ot-string/StringType.ts

@@ -170,6 +170,19 @@ const chunk = (component: StringTypeOpComponent, offset: number, maxLength: numb
   }
 };
 
+/**
+ * Combine two operations into one, such that the changes produced by the
+ * by the single operation are the same as if the two operations were applied
+ * in sequence.
+ * 
+ * ```
+ * apply(str, combine(op1, op2)) === apply(apply(str, op1), op2)
+ * ```
+ * 
+ * @param op1 First operation.
+ * @param op2 Second operation.
+ * @returns A combined operation.
+ */
 export const compose = (op1: StringTypeOp, op2: StringTypeOp): StringTypeOp => {
   const op3: StringTypeOp = [];
   const len1 = op1.length;
@@ -237,3 +250,87 @@ export const compose = (op1: StringTypeOp, op2: StringTypeOp): StringTypeOp => {
   trim(op3);
   return op3;
 };
+
+/**
+ * Transforms an operation such that the transformed operations can be
+ * applied to a string in reverse order.
+ * 
+ * ```
+ * apply(apply(doc, op1), transform(op2, op1)) === apply(apply(doc, op2), transform(op1, op2))
+ * ```
+ * 
+ * @param op1 The operation to transform.
+ * @param op2 The operation to transform against.
+ * @returns A new operation with user intentions preserved.
+ */
+ export const transform = (op1: StringTypeOp, op2: StringTypeOp, leftInsertFirst: boolean): StringTypeOp => {
+  const op3: StringTypeOp = [];
+  const len1 = op1.length;
+  const len2 = op2.length;
+  let i1 = 0;
+  let i2 = 0;
+  let off1 = 0;
+  for (; i2 < len2; i2++) {
+    const comp2 = op2[i2];
+    let doDelete = false;
+    switch (typeof comp2) {
+      case 'number': {
+        if (comp2 > 0) {
+          let length2 = comp2;
+          while (length2 > 0) {
+            const comp1 = op1[i1];
+            const comp = i1 >= len1 ? length2 : chunk(comp1, off1, length2);
+            const compLength = componentLength(comp);
+            const length1 = componentLength(comp1 || comp);
+            append(op3, comp);
+            off1 += compLength;
+            if (off1 >= length1) {
+              i1++;
+              off1 = 0;
+            }
+            if (typeof comp !== 'string') length2 -= compLength;
+          }
+        } else doDelete = true;
+        break;
+      }
+      case 'string': {
+        if (leftInsertFirst) {
+          if (typeof op1[i1] === 'string') {
+            const comp = chunk(op1[i1++], off1, Infinity);
+            off1 = 0;
+            append(op3, comp)
+          }
+        }
+        append(op3, comp2.length);
+        break;
+      }
+      case 'object': {
+        doDelete = true;
+        break;
+      }
+    }
+    if (doDelete) {
+      const isReversible = comp2 instanceof Array;
+      const length2 = isReversible ? comp2[0].length : -comp2;
+      let off2 = 0;
+      while (off2 < length2) {
+        const remaining = length2 - off2;
+        const comp1 = op1[i1];
+        const comp = i1 >= len1 ? remaining : chunk(comp1, off1, remaining);
+        const compLength = componentLength(comp);
+        const length1 = componentLength(comp1 || comp);
+        if (typeof comp === 'string') append(op3, comp);
+        else off2 += compLength;
+        off1 += compLength;
+        if (off1 >= length1) {
+          i1++;
+          off1 = 0;
+        }
+      }
+    }
+  }
+  if (i1 < len1 && off1) append(op3, chunk(op1[i1++], off1, Infinity));
+  for (; i1 < len1; i1++) append(op3, op1[i1]);
+  trim(op3);
+  return op3;
+};

src/json-ot/types/ot-string/__tests__/StringType.spec.ts

@@ -1,4 +1,4 @@
-import {validate, append, normalize, apply, compose} from '../StringType';
+import {validate, append, normalize, apply, compose, transform} from '../StringType';
 import {StringTypeOp} from '../types';
 
 describe('validate()', () => {
@@ -131,3 +131,61 @@ describe('compose()', () => {
     }
   });
 });
+
+describe('transform()', () => {
+  test('can transform two inserts', () => {
+    const op1: StringTypeOp = [1, 'a'];
+    const op2: StringTypeOp = [3, 'b'];
+    const op3 = transform(op1, op2, true);
+    const op4 = transform(op2, op1, false);
+    expect(op3).toStrictEqual([1, 'a']);
+    expect(op4).toStrictEqual([4, 'b']);
+  });
+
+  test('insert at the same place', () => {
+    const op1: StringTypeOp = [3, 'a'];
+    const op2: StringTypeOp = [3, 'b'];
+    const op3 = transform(op1, op2, true);
+    const op4 = transform(op2, op1, false);
+    expect(op3).toStrictEqual([3, 'a']);
+    expect(op4).toStrictEqual([4, 'b']);
+  });
+
+  test('can transform two deletes', () => {
+    const op1: StringTypeOp = [1, -1];
+    const op2: StringTypeOp = [3, -1];
+    const op3 = transform(op1, op2, true);
+    const op4 = transform(op2, op1, false);
+    expect(op3).toStrictEqual([1, -1]);
+    expect(op4).toStrictEqual([2, -1]);
+  });
+
+  // type TestCase = [name: string, str: string, op1: StringTypeOp, op2: StringTypeOp, expected: string, only?: boolean];
+
+  // const testCases: TestCase[] = [
+  //   ['insert-insert', 'abc', [1, 'a'], [1, 'b'], 'ababc'],
+  //   ['insert-delete', 'abc', [1, 'a'], [1, -1], 'abc'],
+  //   ['insert-delete-2', 'abc', [1, 'a'], [2, -1], 'aac'],
+  //   ['insert in previous insert', 'aabb', [2, '1111'], [4, '22'], 'aa112211bb'],
+  //   ['fuzzer bug #1', 'd6', ['}B'], [['}'], ';0q', 2, ['6']], ';0qBd'],
+  //   ['fuzzer bug #2', 'Ai', [['A'], '#', -1], [-1], ''],
+  //   ['fuzzer bug #3', 'M}', ['!y1'], ["'/*s", 2, ',/@', -2, ['}']], "'/*s!y,/@"],
+  //   ['fuzzer bug #4', '8sL', [-2, 'w', ['L']], [['w']], ''],
+  //   ['fuzzer bug #5', '%V=', [2, ';'], ['3O"', 1, 'J', -2], '3O"%J='],
+  // ];
+
+  // describe('can compose', () => {
+  //   for (const [name, str, op1, op2, expected, only] of testCases) {
+  //     (only ? test.only : test)(`${name}`, () => {
+  //       const res1 = apply(apply(str, op1), op2);
+  //       // console.log('res1', res1);
+  //       const op3 = compose(op1, op2);
+  //       // console.log('op3', op3);
+  //       const res2 = apply(str, op3);
+  //       // console.log('res2', res2);
+  //       expect(res2).toStrictEqual(res1);
+  //       expect(res2).toStrictEqual(expected);
+  //     });
+  //   }
+  // });
+});