feat(json-crdt): 🎸 add JSON CRDT compact encoder according to the specification

Author: streamich

src/json-crdt/codec/structural/compact/Encoder.ts

@@ -3,6 +3,7 @@ import {ClockEncoder} from '../../../../json-crdt-patch/codec/clock/ClockEncoder
 import {ITimestampStruct, Timestamp} from '../../../../json-crdt-patch/clock';
 import {JsonCrdtDataType} from '../../../../json-crdt-patch/constants';
 import {SESSION} from '../../../../json-crdt-patch/constants';
+import type * as t from './types';
 import type {Model} from '../../../model';
 
 export class Encoder {
@@ -14,146 +15,120 @@ export class Encoder {
     this.model = model;
     const isServerTime = model.clock.sid === SESSION.SERVER;
     const clock = model.clock;
-    const arr: unknown[] = isServerTime ? [clock.time] : [null];
     if (isServerTime) {
       this.time = clock.time;
     } else {
       this.clock = new ClockEncoder();
       this.clock.reset(model.clock);
     }
-    this.encodeRoot(arr, model.root);
-    if (!isServerTime) arr[0] = this.clock!.toJson();
-    return arr;
+    const root = model.root;
+    const doc: t.JsonCrdtCompactDocument = [
+      0,
+      !root.val.time ? 0 : this.cNode(root.node()),
+    ];
+    if (!isServerTime) doc[0] = this.clock!.toJson();
+    return doc;
   }
 
-  protected ts(arr: unknown[], ts: ITimestampStruct): void {
+  protected ts(ts: ITimestampStruct): t.JsonCrdtCompactTimestamp {
     switch (ts.sid) {
-      case SESSION.SYSTEM: {
-        arr.push([ts.time]);
-        break;
-      }
-      case SESSION.SERVER: {
-        arr.push(this.time! - ts.time);
-        break;
-      }
+      case SESSION.SYSTEM: return [ts.sid, ts.time];
+      case SESSION.SERVER: return this.time! - ts.time;
       default: {
         const relativeId = this.clock!.append(ts);
-        arr.push(-relativeId.sessionIndex, relativeId.timeDiff);
+        return [-relativeId.sessionIndex, relativeId.timeDiff];
       }
     }
   }
 
-  protected encodeRoot(arr: unknown[], root: nodes.RootNode): void {
-    if (!root.val.time) arr.push(0);
-    else this.cNode(arr, root.node());
-  }
-
-  protected cNode(arr: unknown[], node: nodes.JsonNode): void {
+  protected cNode(node: nodes.JsonNode): t.JsonCrdtCompactNode {
     // TODO: PERF: use switch with `node.constructor`.
-    if (node instanceof nodes.ObjNode) return this.cObj(arr, node);
-    else if (node instanceof nodes.ArrNode) return this.cArr(arr, node);
-    else if (node instanceof nodes.StrNode) return this.cStr(arr, node);
-    else if (node instanceof nodes.ValNode) return this.cVal(arr, node);
-    else if (node instanceof nodes.VecNode) return this.cVec(arr, node);
-    else if (node instanceof nodes.ConNode) return this.cCon(arr, node);
-    else if (node instanceof nodes.BinNode) return this.cBin(arr, node);
+    if (node instanceof nodes.ObjNode) return this.cObj(node);
+    else if (node instanceof nodes.ArrNode) return this.cArr(node);
+    else if (node instanceof nodes.StrNode) return this.cStr(node);
+    else if (node instanceof nodes.ValNode) return this.cVal(node);
+    else if (node instanceof nodes.VecNode) return this.cVec(node);
+    else if (node instanceof nodes.ConNode) return this.cCon(node);
+    else if (node instanceof nodes.BinNode) return this.cBin(node);
     throw new Error('UNKNOWN_NODE');
   }
 
-  protected cObj(arr: unknown[], obj: nodes.ObjNode): void {
-    const res: unknown[] = [JsonCrdtDataType.obj];
-    arr.push(res);
-    this.ts(res, obj.id);
-    obj.nodes((node, key) => {
-      res.push(key);
-      this.cNode(res, node);
-    });
+  protected cObj(obj: nodes.ObjNode): t.JsonCrdtCompactObj {
+    const map: t.JsonCrdtCompactObj[2] = {};
+    obj.nodes((child, key) => map[key] = this.cNode(child));
+    const res: t.JsonCrdtCompactObj = [JsonCrdtDataType.obj, this.ts(obj.id), map];
+    return res;
   }
 
-  protected cVec(arr: unknown[], obj: nodes.VecNode): void {
-    const res: unknown[] = [JsonCrdtDataType.vec];
-    arr.push(res);
-    this.ts(res, obj.id);
-    const elements = obj.elements;
+  protected cVec(vec: nodes.VecNode): t.JsonCrdtCompactVec {
+    const elements = vec.elements;
     const length = elements.length;
     const index = this.model.index;
+    const map: t.JsonCrdtCompactVec[2] = [];
     for (let i = 0; i < length; i++) {
       const elementId = elements[i];
-      if (!elementId) res.push(0);
+      if (!elementId) map.push(0);
       else {
         const node = index.get(elementId)!;
-        this.cNode(res, node);
+        map.push(this.cNode(node));
       }
     }
+    const res: t.JsonCrdtCompactVec = [JsonCrdtDataType.vec, this.ts(vec.id), map];
+    return res;
   }
 
-  protected cArr(arr: unknown[], obj: nodes.ArrNode): void {
-    const res: unknown[] = [JsonCrdtDataType.arr, obj.size()];
-    arr.push(res);
-    this.ts(res, obj.id);
-    const iterator = obj.iterator();
-    let chunk;
-    while ((chunk = iterator())) this.cArrChunk(res, chunk);
-  }
-
-  protected cArrChunk(arr: unknown[], chunk: nodes.ArrChunk): void {
-    this.ts(arr, chunk.id);
-    if (chunk.del) arr.push(chunk.span);
-    else {
-      const nodes: unknown[] = [];
-      const index = this.model.index;
-      for (const n of chunk.data!) this.cNode(nodes, index.get(n)!);
-      arr.push(nodes);
+  protected cArr(node: nodes.ArrNode): t.JsonCrdtCompactArr {
+    const chunks: t.JsonCrdtCompactArr[2] = [];
+    const index = this.model.index;
+    for (let chunk = node.first(); chunk; chunk = node.next(chunk)) {
+      const deleted = chunk.del;
+      const span = chunk.span;
+      const chunkIdEncoded = this.ts(chunk.id);
+      if (deleted) {
+        chunks.push([chunkIdEncoded, span]);
+      } else {
+        const nodeIds = chunk.data!;
+        const nodes: t.JsonCrdtCompactArrChunk[1] = [];
+        for (let i = 0; i < span; i++) nodes.push(this.cNode(index.get(nodeIds[i])!));
+        chunks.push([chunkIdEncoded, nodes]);
+      }
     }
+    const res: t.JsonCrdtCompactArr = [JsonCrdtDataType.arr, this.ts(node.id), chunks];
+    return res;
   }
 
-  protected cStr(arr: unknown[], obj: nodes.StrNode): void {
-    const res: unknown[] = [JsonCrdtDataType.str, obj.size()];
-    arr.push(res);
-    this.ts(res, obj.id);
-    const iterator = obj.iterator();
-    let chunk;
-    while ((chunk = iterator())) this.cStrChunk(res, chunk as nodes.StrChunk);
-  }
-
-  protected cStrChunk(arr: unknown[], chunk: nodes.StrChunk): void {
-    this.ts(arr, chunk.id);
-    arr.push(chunk.del ? chunk.span : chunk.data!);
+  protected cStr(node: nodes.StrNode): t.JsonCrdtCompactStr {
+    const chunks: t.JsonCrdtCompactStr[2] = [];
+    for (let chunk = node.first(); chunk; chunk = node.next(chunk))
+      chunks.push([this.ts(chunk.id), chunk.del ? chunk.span : chunk.data!] as t.JsonCrdtCompactStrChunk | t.JsonCrdtCompactTombstone);
+    const res: t.JsonCrdtCompactStr = [JsonCrdtDataType.str, this.ts(node.id), chunks];
+    return res;
   }
 
-  protected cBin(arr: unknown[], obj: nodes.BinNode): void {
-    const res: unknown[] = [JsonCrdtDataType.bin, obj.size()];
-    arr.push(res);
-    this.ts(res, obj.id);
-    const iterator = obj.iterator();
-    let chunk;
-    while ((chunk = iterator())) this.cBinChunk(res, chunk as nodes.BinChunk);
+  protected cBin(node: nodes.BinNode): t.JsonCrdtCompactBin {
+    const chunks: t.JsonCrdtCompactBin[2] = [];
+    for (let chunk = node.first(); chunk; chunk = node.next(chunk))
+      chunks.push([this.ts(chunk.id), chunk.del ? chunk.span : chunk.data!] as t.JsonCrdtCompactBinChunk | t.JsonCrdtCompactTombstone);
+    const res: t.JsonCrdtCompactBin = [JsonCrdtDataType.bin, this.ts(node.id), chunks];
+    return res;
   }
 
-  protected cBinChunk(arr: unknown[], chunk: nodes.BinChunk): void {
-    this.ts(arr, chunk.id);
-    arr.push(chunk.del ? chunk.span : chunk.data!);
+  protected cVal(node: nodes.ValNode): t.JsonCrdtCompactVal {
+    const res: t.JsonCrdtCompactVal = [JsonCrdtDataType.val, this.ts(node.id), this.cNode(node.node())];
+    return res;
   }
 
-  protected cVal(arr: unknown[], obj: nodes.ValNode): void {
-    const res: unknown[] = [JsonCrdtDataType.val];
-    arr.push(res);
-    this.ts(res, obj.id);
-    this.cNode(res, obj.node());
-  }
-
-  protected cCon(arr: unknown[], obj: nodes.ConNode): void {
-    const val = obj.val;
-    const res: unknown[] = [];
+  protected cCon(node: nodes.ConNode): t.JsonCrdtCompactCon {
+    const val = node.val;
+    const res: t.JsonCrdtCompactCon = [JsonCrdtDataType.con, this.ts(node.id), val];
     if (val instanceof Timestamp) {
-      res.push(JsonCrdtDataType.con + 10);
-      this.ts(res, obj.id);
-      this.ts(res, val);
-    } else {
-      res.push(JsonCrdtDataType.con);
-      this.ts(res, obj.id);
-      if (val !== undefined) res.push(val);
+      res[2] = 0;
+      const specialData = this.ts(val);
+      res.push(specialData);
+    } else if (val === undefined) {
+      res[2] = 0;
+      res.push(0);
     }
-    arr.push(res);
+    return res;
   }
 }

src/json-crdt/codec/structural/compact/types.ts

@@ -84,7 +84,7 @@ export type JsonCrdtCompactArr = [
 
 export type JsonCrdtCompactArrChunk = [
   id: JsonCrdtCompactTimestamp,
-  data: JsonCrdtCompactNode,
+  data: JsonCrdtCompactNode[],
 ];
 
 export type JsonCrdtCompactTombstone = [