Add ot-string type

.git-cz.json

@@ -11,6 +11,7 @@
     "json-crdt-patch",
     "json-equal",
     "json-expression",
+    "json-ot",
     "json-pack",
     "json-patch",
     "json-patch-ot",

package.json

@@ -95,6 +95,7 @@
     "messagepack": "^1.1.12",
     "msgpack-lite": "^0.1.26",
     "msgpack5": "^5.3.2",
+    "ot-text": "^1.0.2",
     "pako": "^2.0.4",
     "prettier": "^2.5.1",
     "pretty-quick": "^3.1.3",

src/__tests__/msgpack-documents.ts

@@ -1,5 +1,5 @@
-import {JsonPackExtension, JsonPackValue} from "../json-pack";
-import {encodeFull} from "../json-pack/util";
+import {JsonPackExtension, JsonPackValue} from '../json-pack';
+import {encodeFull} from '../json-pack/util';
 
 export interface JsonDocument {
   name: string;
@@ -24,9 +24,7 @@ export const msgPackDocuments: JsonDocument[] = [
   },
   {
     name: 'MessagePack value in array',
-    json: [
-      new JsonPackValue(encodeFull(null)),
-    ],
+    json: [new JsonPackValue(encodeFull(null))],
   },
   {
     name: 'MessagePack extension',
@@ -36,7 +34,7 @@ export const msgPackDocuments: JsonDocument[] = [
     name: 'MessagePack extension in object',
     json: {
       foo: new JsonPackExtension(1, new Uint8Array([1, 2, 3])),
-    }
+    },
   },
   {
     name: 'MessagePack extension in array',

src/demo/ot-text.ts

@@ -0,0 +1,21 @@
+/* tslint:disable no-console */
+
+/**
+ * Run this demo with:
+ *
+ *     npx ts-node src/demo/ot-text.ts
+ */
+
+const {type} = require('ot-text');
+
+const op1 = [1, 'a'];
+const op2 = [3, 'b'];
+
+// const op1 = [3, 'a'];
+// const op2 = [3, 'b'];
+
+const op3 = type.transform(op1, op2, 'left');
+const op4 = type.transform(op2, op1, 'right');
+
+console.log('op3', op3);
+console.log('op4', op4);

src/json-binary/index.ts

@@ -33,7 +33,8 @@ const unwrapBinary = (value: unknown): unknown => {
         }
         case 'string': {
           if (item.length < minDataUri) continue;
-          if (item.substring(0, binUriStartLength) === binUriStart) value[i] = fromBase64(item.substring(binUriStartLength));
+          if (item.substring(0, binUriStartLength) === binUriStart)
+            value[i] = fromBase64(item.substring(binUriStartLength));
           else if (item.substring(0, msgPackUriStartLength) === msgPackUriStart)
             value[i] = new JsonPackValue(fromBase64(item.substring(msgPackUriStartLength)));
           else if (item.substring(0, msgPackExtStartLength) === msgPackExtStart) value[i] = parseExtDataUri(item);
@@ -57,8 +58,8 @@ const unwrapBinary = (value: unknown): unknown => {
             (value as any)[key] = buf;
           } else if (item.substring(0, msgPackUriStartLength) === msgPackUriStart) {
             (value as any)[key] = new JsonPackValue(fromBase64(item.substring(msgPackUriStartLength)));
-          }
-          else if (item.substring(0, msgPackExtStartLength) === msgPackExtStart) (value as any)[key] = parseExtDataUri(item);
+          } else if (item.substring(0, msgPackExtStartLength) === msgPackExtStart)
+            (value as any)[key] = parseExtDataUri(item);
         }
       }
     }
@@ -67,7 +68,8 @@ const unwrapBinary = (value: unknown): unknown => {
   if (typeof value === 'string') {
     if (value.length < minDataUri) return value;
     if (value.substring(0, binUriStartLength) === binUriStart) return fromBase64(value.substring(binUriStartLength));
-    if (value.substring(0, msgPackUriStartLength) === msgPackUriStart) return new JsonPackValue(fromBase64(value.substring(msgPackUriStartLength)));
+    if (value.substring(0, msgPackUriStartLength) === msgPackUriStart)
+      return new JsonPackValue(fromBase64(value.substring(msgPackUriStartLength)));
     if (value.substring(0, msgPackExtStartLength) === msgPackExtStart) return parseExtDataUri(value);
     else return value;
   }

src/json-block/Block.ts

@@ -43,16 +43,12 @@ export class BasicBlock<Data, Patch> {
 
   public apply(patch: Patch): void {
     this.model.apply(patch);
-    this.v$.next(this.v$.getValue() + 1);
+    this.v$.next(this.v$.getValue());
   }
 }
 
 export type PatchResponse<Patch> = true | false | Patch;
 
-export interface BranchDependencies<Patch> {
-  readonly merge: (baseVersion: number, patches: Patch[]) => Promise<BranchMergeResponse<Patch>>;
-}
-
 export interface BranchMergeResponse<Patch> {
   version: number;
   batches: PatchResponse<Patch>[][];
@@ -66,31 +62,23 @@ export class Branch<Data, Patch> {
   protected readonly head$: BehaviorSubject<BasicBlock<Data, Patch>>;
 
   /**
-   * List of patches applied locally to the head, but not saved
-   * on the server. This is delta between the base and the head.
+   * List of patches applied locally to the head, but not yet
+   * added to the `batches` list.
    */
   protected patches: Patch[];
 
-  /** Number of patches currently being merged to the server. */
-  protected merging: number = 0;
+  /** List of batches to be persisted on the server. */
+  protected batches: Patch[][] = [];
 
   constructor(base: BasicBlock<Data, Patch>) {
     this.base$ = new BehaviorSubject(base);
     this.patches = [];
     this.head$ = new BehaviorSubject(base.fork());
   }
 
-  public async merge(opts: BranchDependencies<Patch>): Promise<void> {
-    try {
-      const base = this.base$.getValue();
-      const baseVersion = base.v$.getValue();
-      const batch = [...this.patches];
-      this.merging = batch.length;
-      const res = await opts.merge(baseVersion, batch);
-
-    } catch (error) {
-      this.merging = 0;
-    }
+  public cutBatch(): void {
+    this.batches.push(this.patches);
+    this.patches = [];
   }
 
   /** Apply a patch locally to the head. */

src/json-block/types.ts

@@ -1,4 +1,4 @@
-import type {Observable} from "rxjs";
+import type {Observable} from 'rxjs';
 
 export interface BlockServerApi {
   create: () => Promise<void>;
@@ -11,14 +11,14 @@ export interface BlockClientApiMergeRequest {
   /** Last known batch ID by the client. */
   v: number;
   /** List of patches serialized in block-specific codec. */
-  batch: unknown[];
+  b: unknown[];
 }
 
 /**
  * There are a number of scenarios that can happen
  * when merging changes. The possible scenarios also depend
  * on the collaborative editing algorithm used for the block.
- * 
+ *
  * 1. The batch is accepted without any conflicts (changes).
  * 2. The batch is accepted with conflicts, hence the batch may be
  *    be modified to resolve the conflicts. This is relevant for

src/json-crdt/codec/binary/Encoder.ts

@@ -46,7 +46,7 @@ export class Encoder extends CrdtEncoder {
     delete this.literals;
     return this.flush();
   }
-  
+
   protected encodeLiteralsTable(model: Model) {
     const literalFrequencies = new Map<string | number, number>();
     for (const node of model.nodes.iterate()) {
@@ -75,11 +75,9 @@ export class Encoder extends CrdtEncoder {
       }
     }
     const literals: unknown[] = [];
-    for (const [literal, frequency] of literalFrequencies.entries())
-      if (frequency > 1) literals.push(literal);
+    for (const [literal, frequency] of literalFrequencies.entries()) if (frequency > 1) literals.push(literal);
     this.encodeArray(literals);
-    for (let i = 0; i < literals.length; i++)
-      this.literals!.set(literals[i], i);
+    for (let i = 0; i < literals.length; i++) this.literals!.set(literals[i], i);
   }
 
   protected encodeClockTable(data: Uint8Array) {

src/json-crdt/codec/binary/__tests__/ViewDecoder.spec.ts

@@ -9,7 +9,10 @@ describe('logical', () => {
     doc1.api.root([1, 'asdf', false, {}, {foo: 'bar'}]).commit();
     doc1.api.str([1]).ins(4, '!').commit();
     doc1.api.str([4, 'foo']).del(1, 1).commit();
-    doc1.api.arr([]).ins(1, [new Uint8Array([1, 2, 3])]).commit();
+    doc1.api
+      .arr([])
+      .ins(1, [new Uint8Array([1, 2, 3])])
+      .commit();
     doc1.api.bin([1]).del(2, 1).commit();
     doc1.api.arr([]).ins(6, ['a', 'b', 'c']).commit();
     doc1.api.arr([]).del(7, 1).commit();

src/json-crdt/codec/binary/__tests__/literals.spec.ts

@@ -4,17 +4,21 @@ import {Encoder} from '../Encoder';
 test('encodes repeating object keys into literals table', () => {
   const encoder = new Encoder();
   const model1 = Model.withLogicalClock();
-  model1.api.root({
-    foooo: {
-      baaar: 0,
-    }
-  }).commit();
+  model1.api
+    .root({
+      foooo: {
+        baaar: 0,
+      },
+    })
+    .commit();
   const model2 = Model.withLogicalClock();
-  model2.api.root({
-    foooo: {
-      foooo: 0,
-    }
-  }).commit();
+  model2.api
+    .root({
+      foooo: {
+        foooo: 0,
+      },
+    })
+    .commit();
   const encoded1 = encoder.encode(model1);
   const encoded2 = encoder.encode(model2);
   expect(encoded1.byteLength > encoded2.byteLength).toBe(true);

src/json-crdt/json-patch/JsonPatchDraft.ts

@@ -6,7 +6,17 @@ import {ObjectType} from '../types/lww-object/ObjectType';
 import {UNDEFINED_ID} from '../../json-crdt-patch/constants';
 import {toPath} from '../../json-pointer/util';
 import type {Model} from '../model';
-import type {Operation, OperationAdd, OperationRemove, OperationReplace, OperationMove, OperationCopy, OperationTest, OperationStrIns, OperationStrDel} from '../../json-patch';
+import type {
+  Operation,
+  OperationAdd,
+  OperationRemove,
+  OperationReplace,
+  OperationMove,
+  OperationCopy,
+  OperationTest,
+  OperationStrIns,
+  OperationStrDel,
+} from '../../json-patch';
 
 export class JsonPatchDraft {
   public readonly draft = new Draft();
@@ -18,16 +28,33 @@ export class JsonPatchDraft {
   }
 
   public applyOp(op: Operation): void {
-    switch(op.op) {
-      case 'add': this.applyOpAdd(op); break;
-      case 'remove': this.applyRemove(op); break;
-      case 'replace': this.applyReplace(op); break;
-      case 'move': this.applyMove(op); break;
-      case 'copy': this.applyCopy(op); break;
-      case 'test': this.applyTest(op); break;
-      case 'str_ins': this.applyStrIns(op); break;
-      case 'str_del': this.applyStrDel(op); break;
-      default: throw new Error('UNKNOWN_OP');
+    switch (op.op) {
+      case 'add':
+        this.applyOpAdd(op);
+        break;
+      case 'remove':
+        this.applyRemove(op);
+        break;
+      case 'replace':
+        this.applyReplace(op);
+        break;
+      case 'move':
+        this.applyMove(op);
+        break;
+      case 'copy':
+        this.applyCopy(op);
+        break;
+      case 'test':
+        this.applyTest(op);
+        break;
+      case 'str_ins':
+        this.applyStrIns(op);
+        break;
+      case 'str_del':
+        this.applyStrDel(op);
+        break;
+      default:
+        throw new Error('UNKNOWN_OP');
     }
   }
 

src/json-crdt/json-patch/__tests__/JsonPatch.str.spec.ts

@@ -53,7 +53,7 @@ const testCases: TestCase[] = [
     doc1: null,
     patches: [
       [{op: 'add', path: '', value: {foo: [{bar: 'baz'}]}}],
-      [{op: 'str_ins', path: '/foo/0/bar', pos: 3, str: '!'}]
+      [{op: 'str_ins', path: '/foo/0/bar', pos: 3, str: '!'}],
     ],
     doc2: {foo: [{bar: 'baz!'}]},
   },
@@ -62,73 +62,56 @@ const testCases: TestCase[] = [
     doc1: null,
     patches: [
       [{op: 'add', path: '', value: {foo: [{bar: 'baz'}]}}],
-      [{op: 'str_ins', path: ['foo', 0, 'bar'], pos: 3, str: '!'}]
+      [{op: 'str_ins', path: ['foo', 0, 'bar'], pos: 3, str: '!'}],
     ],
     doc2: {foo: [{bar: 'baz!'}]},
   },
   {
     name: 'can delete a single char',
     doc1: 'a',
-    patches: [
-      [{op: 'str_del', path: [], pos: 0, len: 1}]
-    ],
+    patches: [[{op: 'str_del', path: [], pos: 0, len: 1}]],
     doc2: '',
   },
   {
     name: 'can delete from already empty string',
     doc1: '',
-    patches: [
-      [{op: 'str_del', path: [], pos: 0, len: 1}]
-    ],
+    patches: [[{op: 'str_del', path: [], pos: 0, len: 1}]],
     doc2: '',
   },
   {
     name: 'can delete at the end of string',
     doc1: 'ab',
-    patches: [
-      [{op: 'str_del', path: [], pos: 1, len: 1}]
-    ],
+    patches: [[{op: 'str_del', path: [], pos: 1, len: 1}]],
     doc2: 'a',
   },
   {
     name: 'can delete at the beginning of string',
     doc1: 'ab',
-    patches: [
-      [{op: 'str_del', path: [], pos: 0, len: 1}]
-    ],
+    patches: [[{op: 'str_del', path: [], pos: 0, len: 1}]],
     doc2: 'b',
   },
   {
     name: 'can delete in the middle of string',
     doc1: 'abc',
-    patches: [
-      [{op: 'str_del', path: [], pos: 1, len: 1}]
-    ],
+    patches: [[{op: 'str_del', path: [], pos: 1, len: 1}]],
     doc2: 'ac',
   },
   {
     name: 'can delete multiple chars',
     doc1: '1234',
-    patches: [
-      [{op: 'str_del', path: [], pos: 1, len: 2}],
-      [{op: 'str_del', path: [], pos: 1, len: 5}],
-    ],
+    patches: [[{op: 'str_del', path: [], pos: 1, len: 2}], [{op: 'str_del', path: [], pos: 1, len: 5}]],
     doc2: '1',
   },
   {
     name: 'handles deletion beyond end of string',
     doc1: '1234',
-    patches: [
-      [{op: 'str_del', path: [], pos: 1111, len: 2}],
-    ],
+    patches: [[{op: 'str_del', path: [], pos: 1111, len: 2}]],
     doc2: '1234',
   },
   {
     name: 'can delete a string in object',
     doc1: {foo: '123'},
-    patches: [
-      [{op: 'str_del', path: '/foo', pos: 1, len: 2}],
-    ],
+    patches: [[{op: 'str_del', path: '/foo', pos: 1, len: 2}]],
     doc2: {foo: '1'},
   },
 ];