refactor(json-crdt): 💡 rename method names according to node type names

Author: streamich

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

@@ -47,27 +47,27 @@ export class Decoder {
     if (data instanceof Array) {
       switch (data[0]) {
         case JsonCrdtDataType.con:
-          return this.decodeConst(doc, data);
+          return this.decCon(doc, data);
         case JsonCrdtDataType.con + 10:
-          return this.decodeConstId(doc, data);
+          return this.decConId(doc, data);
         case JsonCrdtDataType.val:
-          return this.decodeVal(doc, data);
+          return this.decVal(doc, data);
         case JsonCrdtDataType.obj:
-          return this.decodeObj(doc, data);
+          return this.decObj(doc, data);
         case JsonCrdtDataType.vec:
-          return this.decodeTup(doc, data);
+          return this.decVec(doc, data);
         case JsonCrdtDataType.str:
-          return this.decodeStr(doc, data);
+          return this.decStr(doc, data);
         case JsonCrdtDataType.bin:
-          return this.decodeBin(doc, data);
+          return this.decBin(doc, data);
         case JsonCrdtDataType.arr:
-          return this.decodeArr(doc, data);
+          return this.decArr(doc, data);
       }
     }
     throw new Error('UNKNOWN_NODE');
   }
 
-  protected decodeObj(doc: Model, data: unknown[]): nodes.ObjNode {
+  protected decObj(doc: Model, data: unknown[]): nodes.ObjNode {
     const [id, index] = this.ts(data, 1);
     const obj = new nodes.ObjNode(doc, id);
     const length = data.length;
@@ -81,7 +81,7 @@ export class Decoder {
     return obj;
   }
 
-  protected decodeTup(doc: Model, data: unknown[]): nodes.VecNode {
+  protected decVec(doc: Model, data: unknown[]): nodes.VecNode {
     const [id, index] = this.ts(data, 1);
     const obj = new nodes.VecNode(doc, id);
     const length = data.length;
@@ -98,7 +98,7 @@ export class Decoder {
     return obj;
   }
 
-  protected decodeArr(doc: Model, data: unknown[]): nodes.ArrNode {
+  protected decArr(doc: Model, data: unknown[]): nodes.ArrNode {
     const size = data[1] as number;
     const [id, index] = this.ts(data, 2);
     const obj = new nodes.ArrNode(doc, id);
@@ -116,7 +116,7 @@ export class Decoder {
     return obj;
   }
 
-  protected decodeStr(doc: Model, data: unknown[]): nodes.StrNode {
+  protected decStr(doc: Model, data: unknown[]): nodes.StrNode {
     const size = data[1] as number;
     const [id, index] = this.ts(data, 2);
     const node = new nodes.StrNode(id);
@@ -133,7 +133,7 @@ export class Decoder {
     return node;
   }
 
-  protected decodeBin(doc: Model, data: unknown[]): nodes.BinNode {
+  protected decBin(doc: Model, data: unknown[]): nodes.BinNode {
     const size = data[1] as number;
     const [id, index] = this.ts(data, 2);
     const node = new nodes.BinNode(id);
@@ -151,23 +151,23 @@ export class Decoder {
     return node;
   }
 
-  protected decodeVal(doc: Model, data: unknown[]): nodes.ValNode {
+  protected decVal(doc: Model, data: unknown[]): nodes.ValNode {
     const [id, index] = this.ts(data, 1);
     const child = this.decodeNode(doc, data[index]);
     const obj = new nodes.ValNode(doc, id, child.id);
     doc.index.set(id, obj);
     return obj;
   }
 
-  protected decodeConst(doc: Model, data: unknown[]): nodes.ConNode {
+  protected decCon(doc: Model, data: unknown[]): nodes.ConNode {
     const [id, index] = this.ts(data, 1);
     const value = data[index];
     const obj = new nodes.ConNode(id, value);
     doc.index.set(id, obj);
     return obj;
   }
 
-  protected decodeConstId(doc: Model, data: unknown[]): nodes.ConNode {
+  protected decConId(doc: Model, data: unknown[]): nodes.ConNode {
     const [id, index] = this.ts(data, 1);
     const val = this.ts(data, index)[0];
     const obj = new nodes.ConNode(id, val);

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

@@ -50,17 +50,17 @@ export class Encoder {
 
   protected cNode(arr: unknown[], node: nodes.JsonNode): void {
     // TODO: PERF: use switch with `node.constructor`.
-    if (node instanceof nodes.ObjNode) return this.encodeObj(arr, node);
-    else if (node instanceof nodes.ArrNode) return this.encodeArr(arr, node);
-    else if (node instanceof nodes.StrNode) return this.encodeStr(arr, node);
+    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.cTup(arr, node);
-    else if (node instanceof nodes.ConNode) return this.cConst(arr, node);
-    else if (node instanceof nodes.BinNode) return this.encodeBin(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);
     throw new Error('UNKNOWN_NODE');
   }
 
-  protected encodeObj(arr: unknown[], obj: nodes.ObjNode): void {
+  protected cObj(arr: unknown[], obj: nodes.ObjNode): void {
     const res: unknown[] = [JsonCrdtDataType.obj];
     arr.push(res);
     this.ts(res, obj.id);
@@ -70,7 +70,7 @@ export class Encoder {
     });
   }
 
-  protected cTup(arr: unknown[], obj: nodes.VecNode): void {
+  protected cVec(arr: unknown[], obj: nodes.VecNode): void {
     const res: unknown[] = [JsonCrdtDataType.vec];
     arr.push(res);
     this.ts(res, obj.id);
@@ -87,16 +87,16 @@ export class Encoder {
     }
   }
 
-  protected encodeArr(arr: unknown[], obj: nodes.ArrNode): void {
+  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.encodeArrChunk(res, chunk);
+    while ((chunk = iterator())) this.cArrChunk(res, chunk);
   }
 
-  protected encodeArrChunk(arr: unknown[], chunk: nodes.ArrChunk): void {
+  protected cArrChunk(arr: unknown[], chunk: nodes.ArrChunk): void {
     this.ts(arr, chunk.id);
     if (chunk.del) arr.push(chunk.span);
     else {
@@ -107,30 +107,30 @@ export class Encoder {
     }
   }
 
-  protected encodeStr(arr: unknown[], obj: nodes.StrNode): void {
+  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.encodeStrChunk(res, chunk as nodes.StrChunk);
+    while ((chunk = iterator())) this.cStrChunk(res, chunk as nodes.StrChunk);
   }
 
-  protected encodeStrChunk(arr: unknown[], chunk: nodes.StrChunk): void {
+  protected cStrChunk(arr: unknown[], chunk: nodes.StrChunk): void {
     this.ts(arr, chunk.id);
     arr.push(chunk.del ? chunk.span : chunk.data!);
   }
 
-  protected encodeBin(arr: unknown[], obj: nodes.BinNode): void {
+  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.encodeBinChunk(res, chunk as nodes.BinChunk);
+    while ((chunk = iterator())) this.cBinChunk(res, chunk as nodes.BinChunk);
   }
 
-  protected encodeBinChunk(arr: unknown[], chunk: nodes.BinChunk): void {
+  protected cBinChunk(arr: unknown[], chunk: nodes.BinChunk): void {
     this.ts(arr, chunk.id);
     arr.push(chunk.del ? chunk.span : chunk.data!);
   }
@@ -142,7 +142,7 @@ export class Encoder {
     this.cNode(res, obj.node());
   }
 
-  protected cConst(arr: unknown[], obj: nodes.ConNode): void {
+  protected cCon(arr: unknown[], obj: nodes.ConNode): void {
     const val = obj.val;
     const res: unknown[] = [];
     if (val instanceof Timestamp) {