@yorkie-js/react 0.6.21 → 0.6.23

package/dist/yorkie-js-react.js

@@ -7,7 +7,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 
   var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   const name$1 = "@yorkie-js/react";
-  const version$1 = "0.6.21";
+  const version$1 = "0.6.23";
   const pkg$1 = {
     name: name$1,
     version: version$1
@@ -4692,7 +4692,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     { no: 3, name: "move", kind: "message", T: Operation_Move, oneof: "body" },
     { no: 4, name: "remove", kind: "message", T: Operation_Remove, oneof: "body" },
     { no: 5, name: "edit", kind: "message", T: Operation_Edit, oneof: "body" },
-    { no: 6, name: "select", kind: "message", T: Operation_Select, oneof: "body" },
     { no: 7, name: "style", kind: "message", T: Operation_Style, oneof: "body" },
     { no: 8, name: "increase", kind: "message", T: Operation_Increase, oneof: "body" },
     { no: 9, name: "tree_edit", kind: "message", T: Operation_TreeEdit, oneof: "body" },
@@ -4942,49 +4941,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     } }
   ]));
   let Operation_Edit = _Operation_Edit;
-  const _Operation_Select = class _Operation_Select extends Message {
-    constructor(data) {
-      super();
-      /**
-       * @generated from field: yorkie.v1.TimeTicket parent_created_at = 1;
-       */
-      __publicField(this, "parentCreatedAt");
-      /**
-       * @generated from field: yorkie.v1.TextNodePos from = 2;
-       */
-      __publicField(this, "from");
-      /**
-       * @generated from field: yorkie.v1.TextNodePos to = 3;
-       */
-      __publicField(this, "to");
-      /**
-       * @generated from field: yorkie.v1.TimeTicket executed_at = 4;
-       */
-      __publicField(this, "executedAt");
-      proto3.util.initPartial(data, this);
-    }
-    static fromBinary(bytes, options) {
-      return new _Operation_Select().fromBinary(bytes, options);
-    }
-    static fromJson(jsonValue, options) {
-      return new _Operation_Select().fromJson(jsonValue, options);
-    }
-    static fromJsonString(jsonString, options) {
-      return new _Operation_Select().fromJsonString(jsonString, options);
-    }
-    static equals(a, b) {
-      return proto3.util.equals(_Operation_Select, a, b);
-    }
-  };
-  __publicField(_Operation_Select, "runtime", proto3);
-  __publicField(_Operation_Select, "typeName", "yorkie.v1.Operation.Select");
-  __publicField(_Operation_Select, "fields", proto3.util.newFieldList(() => [
-    { no: 1, name: "parent_created_at", kind: "message", T: TimeTicket$1 },
-    { no: 2, name: "from", kind: "message", T: TextNodePos },
-    { no: 3, name: "to", kind: "message", T: TextNodePos },
-    { no: 4, name: "executed_at", kind: "message", T: TimeTicket$1 }
-  ]));
-  let Operation_Select = _Operation_Select;
   const _Operation_Style = class _Operation_Style extends Message {
     constructor(data) {
       super();
@@ -6447,9 +6403,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
        */
       __publicField(this, "key", "");
       /**
-       * @generated from field: string snapshot = 3;
+       * @generated from field: string root = 3;
        */
-      __publicField(this, "snapshot", "");
+      __publicField(this, "root", "");
       /**
        * @generated from field: int32 attached_clients = 7;
        */
@@ -6462,6 +6418,10 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
        * @generated from field: string schema_key = 9;
        */
       __publicField(this, "schemaKey", "");
+      /**
+       * @generated from field: map<string, yorkie.v1.Presence> presences = 10;
+       */
+      __publicField(this, "presences", {});
       /**
        * @generated from field: google.protobuf.Timestamp created_at = 4;
        */
@@ -6508,7 +6468,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     },
     {
       no: 3,
-      name: "snapshot",
+      name: "root",
       kind: "scalar",
       T: 9
       /* ScalarType.STRING */
@@ -6528,6 +6488,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       T: 9
       /* ScalarType.STRING */
     },
+    { no: 10, name: "presences", kind: "map", K: 9, V: { kind: "message", T: Presence$1 } },
     { no: 4, name: "created_at", kind: "message", T: Timestamp },
     { no: 5, name: "accessed_at", kind: "message", T: Timestamp },
     { no: 6, name: "updated_at", kind: "message", T: Timestamp }
@@ -8282,7 +8243,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      * `remove` removes this element.
      */
     remove(removedAt) {
-      if (removedAt && removedAt.after(this.getPositionedAt()) && (!this.removedAt || removedAt.after(this.removedAt))) {
+      if (removedAt && removedAt.after(this.createdAt) && (!this.removedAt || removedAt.after(this.removedAt))) {
         this.removedAt = removedAt;
         return true;
       }
@@ -10316,6 +10277,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       super(value);
       __publicField(this, "prev");
       __publicField(this, "next");
+      __publicField(this, "movedFrom");
       this.value = value;
     }
     /**
@@ -10382,6 +10344,18 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     getNext() {
       return this.next;
     }
+    /**
+     * `getMovedFrom` returns the previous element before the element moved.
+     */
+    getMovedFrom() {
+      return this.movedFrom;
+    }
+    /**
+     * `setMovedFrom` sets the previous element before the element moved.
+     */
+    setMovedFrom(movedFrom) {
+      this.movedFrom = movedFrom;
+    }
     /**
      * `getValue` returns a element value.
      */
@@ -10441,6 +10415,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           `cant find the given node: ${createdAt.toIDString()}`
         );
       }
+      while (node.getValue().getMovedAt() && node.getValue().getMovedAt().after(executedAt) && node.getMovedFrom()) {
+        node = node.getMovedFrom();
+      }
       while (node.getNext() && node.getNext().getPositionedAt().after(executedAt)) {
         node = node.getNext();
       }
@@ -10465,30 +10442,51 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       }
       this.nodeMapByIndex.insertAfter(prevNode, newNode);
       this.nodeMapByCreatedAt.set(newNode.getCreatedAt().toIDString(), newNode);
+      return newNode;
     }
     /**
      * `moveAfter` moves the given `createdAt` element
      * after the `prevCreatedAt` element.
      */
     moveAfter(prevCreatedAt, createdAt, executedAt) {
-      const prevNode = this.nodeMapByCreatedAt.get(prevCreatedAt.toIDString());
+      let prevNode = this.nodeMapByCreatedAt.get(prevCreatedAt.toIDString());
       if (!prevNode) {
         throw new YorkieError(
           Code.ErrInvalidArgument,
           `cant find the given node: ${prevCreatedAt.toIDString()}`
         );
       }
-      const node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
+      let node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
       if (!node) {
         throw new YorkieError(
           Code.ErrInvalidArgument,
           `cant find the given node: ${createdAt.toIDString()}`
         );
       }
-      if (prevNode !== node && (!node.getValue().getMovedAt() || executedAt.after(node.getValue().getMovedAt()))) {
+      if (prevNode !== node && executedAt.after(node.getPositionedAt())) {
+        const movedFrom = node.getPrev();
+        let nextNode = node.getNext();
         this.release(node);
-        this.insertAfter(prevNode.getCreatedAt(), node.getValue(), executedAt);
+        node = this.insertAfter(
+          prevNode.getCreatedAt(),
+          node.getValue(),
+          executedAt
+        );
         node.getValue().setMovedAt(executedAt);
+        node.setMovedFrom(movedFrom);
+        while (nextNode && nextNode.getPositionedAt().after(executedAt)) {
+          prevNode = node;
+          node = nextNode;
+          nextNode = node.getNext();
+          this.release(node);
+          node = this.insertAfter(
+            prevNode.getCreatedAt(),
+            node.getValue(),
+            executedAt
+          );
+          node.getValue().setMovedAt(executedAt);
+          node.setMovedFrom(movedFrom);
+        }
       }
     }
     /**
@@ -10567,6 +10565,20 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       }
       return node.getValue();
     }
+    /**
+     * `set` sets the given element at the given creation time.
+     */
+    set(createdAt, element, executedAt) {
+      const node = this.nodeMapByCreatedAt.get(createdAt.toIDString());
+      if (!node) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `cant find the given node: ${createdAt.toIDString()}`
+        );
+      }
+      this.insertAfter(node.getCreatedAt(), element, executedAt);
+      return this.delete(createdAt, executedAt);
+    }
     /**
      * `deleteByIndex` deletes the node of the given index.
      */
@@ -10710,6 +10722,12 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     deleteByIndex(index, editedAt) {
       return this.elements.deleteByIndex(index, editedAt);
     }
+    /**
+     * `set` sets the given element at the given position of the creation time.
+     */
+    set(createdAt, value, executedAt) {
+      return this.elements.set(createdAt, value, executedAt);
+    }
     /**
      * `getLastCreatedAt` get last created element.
      */
@@ -16126,6 +16144,77 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       return this.attributesToRemove;
     }
   }
+  class ArraySetOperation extends Operation {
+    constructor(parentCreatedAt, createdAt, value, executedAt) {
+      super(parentCreatedAt, executedAt);
+      __publicField(this, "createdAt");
+      __publicField(this, "value");
+      this.createdAt = createdAt;
+      this.value = value;
+    }
+    /**
+     * `create` creates a new instance of ArraySetOperation.
+     */
+    static create(parentCreatedAt, createdAt, value, executedAt) {
+      return new ArraySetOperation(parentCreatedAt, createdAt, value, executedAt);
+    }
+    /**
+     * `execute` executes this operation on the given `CRDTRoot`.
+     */
+    execute(root) {
+      const parentObject = root.findByCreatedAt(this.getParentCreatedAt());
+      if (!parentObject) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `fail to find ${this.getParentCreatedAt()}`
+        );
+      }
+      if (!(parentObject instanceof CRDTArray)) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `fail to execute, only array can execute set`
+        );
+      }
+      const value = this.value.deepcopy();
+      parentObject.insertAfter(this.createdAt, value, this.getExecutedAt());
+      parentObject.delete(this.createdAt, this.getExecutedAt());
+      root.registerElement(value);
+      const reverseOp = void 0;
+      return {
+        opInfos: [
+          {
+            type: "array-set",
+            path: root.createPath(this.getParentCreatedAt())
+          }
+        ],
+        reverseOp
+      };
+    }
+    /**
+     * `getEffectedCreatedAt` returns the creation time of the effected element.
+     */
+    getEffectedCreatedAt() {
+      return this.createdAt;
+    }
+    /**
+     * `toTestString` returns a string containing the meta data.
+     */
+    toTestString() {
+      return `${this.getParentCreatedAt().toTestString()}.ARRAY_SET.${this.createdAt.toTestString()}=${this.value.toSortedJSON()}`;
+    }
+    /**
+     * `getCreatedAt` returns the creation time of the target element.
+     */
+    getCreatedAt() {
+      return this.createdAt;
+    }
+    /**
+     * `getValue` returns the value of this operation.
+     */
+    getValue() {
+      return this.value;
+    }
+  }
   function toPresence(presence) {
     const pbPresence = new Presence$1();
     const pbDataMap = pbPresence.data;
@@ -16178,7 +16267,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     }
     const pbVector = new VersionVector$1();
     for (const [actorID, lamport] of vector) {
-      pbVector.vector[actorID] = BigInt(lamport.toString());
+      const base64ActorID = uint8ArrayToBase64(toUint8Array(actorID));
+      pbVector.vector[base64ActorID] = BigInt(lamport.toString());
     }
     return pbVector;
   }
@@ -16422,6 +16512,21 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       );
       pbOperation.body.case = "treeStyle";
       pbOperation.body.value = pbTreeStyleOperation;
+    } else if (operation instanceof ArraySetOperation) {
+      const arraySetOperation = operation;
+      const pbArraySetOperation = new Operation_ArraySet();
+      pbArraySetOperation.parentCreatedAt = toTimeTicket(
+        arraySetOperation.getParentCreatedAt()
+      );
+      pbArraySetOperation.createdAt = toTimeTicket(
+        arraySetOperation.getCreatedAt()
+      );
+      pbArraySetOperation.value = toElementSimple(arraySetOperation.getValue());
+      pbArraySetOperation.executedAt = toTimeTicket(
+        arraySetOperation.getExecutedAt()
+      );
+      pbOperation.body.case = "arraySet";
+      pbOperation.body.value = pbArraySetOperation;
     } else {
       throw new YorkieError(Code.ErrUnimplemented, "unimplemented operation");
     }
@@ -16676,7 +16781,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     }
     const vector = new VersionVector();
     Object.entries(pbVersionVector.vector).forEach(([key, value]) => {
-      vector.set(key, BigInt(value.toString()));
+      const hexKey = bytesToHex(base64ToUint8Array(key));
+      vector.set(hexKey, BigInt(value.toString()));
     });
     return vector;
   }
@@ -16960,8 +17066,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         attributes,
         fromTimeTicket(pbStyleOperation.executedAt)
       );
-    } else if (pbOperation.body.case === "select") {
-      return;
     } else if (pbOperation.body.case === "increase") {
       const pbIncreaseOperation = pbOperation.body.value;
       return IncreaseOperation.create(
@@ -17005,6 +17109,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           fromTimeTicket(pbTreeStyleOperation.executedAt)
         );
       }
+    } else if (pbOperation.body.case === "arraySet") {
+      const pbArraySetOperation = pbOperation.body.value;
+      return ArraySetOperation.create(
+        fromTimeTicket(pbArraySetOperation.parentCreatedAt),
+        fromTimeTicket(pbArraySetOperation.createdAt),
+        fromElementSimple(pbArraySetOperation.value),
+        fromTimeTicket(pbArraySetOperation.executedAt)
+      );
     } else {
       throw new YorkieError(Code.ErrUnimplemented, `unimplemented operation`);
     }
@@ -17204,9 +17316,39 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       hex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
     );
   }
+  function base64ToUint8Array(base64) {
+    if (typeof window !== "undefined" && typeof window.atob === "function") {
+      const binary = window.atob(base64);
+      const len = binary.length;
+      const bytes = new Uint8Array(len);
+      for (let i = 0; i < len; i++) {
+        bytes[i] = binary.charCodeAt(i);
+      }
+      return bytes;
+    } else if (typeof globalThis !== "undefined" && typeof globalThis.Buffer !== "undefined") {
+      const Buffer2 = globalThis.Buffer;
+      return new Uint8Array(Buffer2.from(base64, "base64"));
+    } else {
+      throw new Error("No base64 decoder available");
+    }
+  }
   function toUint8Array(hex) {
     return hexToBytes(hex);
   }
+  function uint8ArrayToBase64(bytes) {
+    if (typeof window !== "undefined" && typeof window.btoa === "function") {
+      let binary = "";
+      for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+      }
+      return window.btoa(binary);
+    } else if (typeof globalThis !== "undefined" && typeof globalThis.Buffer !== "undefined") {
+      const Buffer2 = globalThis.Buffer;
+      return Buffer2.from(bytes).toString("base64");
+    } else {
+      throw new Error("No base64 encoder available");
+    }
+  }
   function bytesToChangeID(bytes) {
     const pbChangeID = ChangeID$1.fromBinary(bytes);
     return fromChangeID(pbChangeID);
@@ -18277,6 +18419,15 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
             return () => {
               return toWrappedElement(context, target.getLast());
             };
+          } else if (method === "delete") {
+            return (index) => {
+              const deleted = ArrayProxy.deleteInternalByIndex(
+                context,
+                target,
+                index
+              );
+              return toWrappedElement(context, deleted);
+            };
           } else if (method === "deleteByID") {
             return (createdAt) => {
               const deleted = ArrayProxy.deleteInternalByID(
@@ -18296,6 +18447,16 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
               );
               return toWrappedElement(context, inserted);
             };
+          } else if (method === "insertIntegerAfter") {
+            return (index, value) => {
+              const array2 = ArrayProxy.insertIntegerAfterInternal(
+                context,
+                target,
+                index,
+                value
+              );
+              return toWrappedElement(context, array2);
+            };
           } else if (method === "insertBefore") {
             return (nextID, value) => {
               const inserted = ArrayProxy.insertBeforeInternal(
@@ -18306,6 +18467,16 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
               );
               return toWrappedElement(context, inserted);
             };
+          } else if (method === "setInteger") {
+            return (index, value) => {
+              const array2 = ArrayProxy.setIntegerInternal(
+                context,
+                target,
+                index,
+                value
+              );
+              return toWrappedElement(context, array2);
+            };
           } else if (method === "moveBefore") {
             return (nextID, id) => {
               ArrayProxy.moveBeforeInternal(context, target, nextID, id);
@@ -18314,6 +18485,15 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
             return (prevID, id) => {
               ArrayProxy.moveAfterInternal(context, target, prevID, id);
             };
+          } else if (method === "moveAfterByIndex") {
+            return (prevIndex, targetIndex) => {
+              ArrayProxy.moveAfterByIndexInternal(
+                context,
+                target,
+                prevIndex,
+                targetIndex
+              );
+            };
           } else if (method === "moveFront") {
             return (id) => {
               ArrayProxy.moveFrontInternal(context, target, id);
@@ -18447,7 +18627,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      */
     static moveAfterInternal(context, target, prevCreatedAt, createdAt) {
       const ticket = context.issueTimeTicket();
-      target.moveAfter(prevCreatedAt, createdAt, ticket);
       context.push(
         MoveOperation.create(
           target.getCreatedAt(),
@@ -18456,6 +18635,33 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           ticket
         )
       );
+      target.moveAfter(prevCreatedAt, createdAt, ticket);
+    }
+    /**
+     * `moveAfterByIndexInternal` moves the given element to its new position
+     * after the given previous element.
+     */
+    static moveAfterByIndexInternal(context, target, prevIndex, targetIndex) {
+      const prevElem = target.get(prevIndex);
+      if (!prevElem) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `index out of bounds: ${prevIndex}`
+        );
+      }
+      const targetElem = target.get(targetIndex);
+      if (!targetElem) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `index out of bounds: ${targetIndex}`
+        );
+      }
+      ArrayProxy.moveAfterInternal(
+        context,
+        target,
+        prevElem.getCreatedAt(),
+        targetElem.getCreatedAt()
+      );
     }
     /**
      * `moveFrontInternal` moves the given `createdAt` element
@@ -18504,6 +18710,25 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       );
       return element;
     }
+    /**
+     * `insertIntegerAfterInternal` inserts the given integer after the given previous element.
+     */
+    static insertIntegerAfterInternal(context, target, index, value) {
+      const prevElem = target.get(index);
+      if (!prevElem) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `index out of bounds: ${index}`
+        );
+      }
+      ArrayProxy.insertAfterInternal(
+        context,
+        target,
+        prevElem.getCreatedAt(),
+        value
+      );
+      return target;
+    }
     /**
      * `insertBeforeInternal` inserts the value before the previously created element.
      */
@@ -18515,6 +18740,39 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         value
       );
     }
+    /**
+     * `setIntegerInternal` sets the given integer at the given index.
+     */
+    static setIntegerInternal(context, target, index, value) {
+      const prev = target.get(index);
+      if (!prev) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `index out of bounds: ${index}`
+        );
+      }
+      ArrayProxy.setByIndexInternal(context, target, prev.getCreatedAt(), value);
+      return target;
+    }
+    /**
+     * `setByIndexInternal` sets the element of the given index.
+     */
+    static setByIndexInternal(context, target, createdAt, value) {
+      const ticket = context.issueTimeTicket();
+      const element = buildCRDTElement(context, value, ticket);
+      const copiedValue = element.deepcopy();
+      context.push(
+        ArraySetOperation.create(
+          target.getCreatedAt(),
+          createdAt,
+          copiedValue,
+          ticket
+        )
+      );
+      target.set(createdAt, element, ticket);
+      context.registerElement(element, target);
+      return element;
+    }
     /**
      * `deleteInternalByIndex` deletes target element of given index.
      */
@@ -21266,7 +21524,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     };
   }
   const name = "@yorkie-js/sdk";
-  const version = "0.6.21";
+  const version = "0.6.23";
   const pkg = {
     name,
     version