@yorkie-js/react 0.6.21 → 0.6.23

package/dist/yorkie-js-react.es.js

@@ -5,7 +5,7 @@ var _a, _b, _c, _d, _e, _f, _g, _h, _i;
 import { jsx } from "react/jsx-runtime";
 import { createContext, useMemo, useState, useEffect, useContext, useCallback } from "react";
 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
@@ -4690,7 +4690,6 @@ let Operation$1 = (_e = class extends Message {
   { 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" },
@@ -4940,49 +4939,6 @@ __publicField(_Operation_Edit, "fields", proto3.util.newFieldList(() => [
   } }
 ]));
 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();
@@ -6445,9 +6401,9 @@ const _DocumentSummary = class _DocumentSummary extends Message {
      */
     __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;
      */
@@ -6460,6 +6416,10 @@ const _DocumentSummary = class _DocumentSummary extends Message {
      * @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;
      */
@@ -6506,7 +6466,7 @@ __publicField(_DocumentSummary, "fields", proto3.util.newFieldList(() => [
   },
   {
     no: 3,
-    name: "snapshot",
+    name: "root",
     kind: "scalar",
     T: 9
     /* ScalarType.STRING */
@@ -6526,6 +6486,7 @@ __publicField(_DocumentSummary, "fields", proto3.util.newFieldList(() => [
     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 }
@@ -8280,7 +8241,7 @@ class CRDTElement {
    * `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;
     }
@@ -10314,6 +10275,7 @@ class RGATreeListNode extends SplayNode {
     super(value);
     __publicField(this, "prev");
     __publicField(this, "next");
+    __publicField(this, "movedFrom");
     this.value = value;
   }
   /**
@@ -10380,6 +10342,18 @@ class RGATreeListNode extends SplayNode {
   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.
    */
@@ -10439,6 +10413,9 @@ class RGATreeList {
         `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();
     }
@@ -10463,30 +10440,51 @@ class RGATreeList {
     }
     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);
+      }
     }
   }
   /**
@@ -10565,6 +10563,20 @@ class RGATreeList {
     }
     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.
    */
@@ -10708,6 +10720,12 @@ class CRDTArray extends CRDTContainer {
   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.
    */
@@ -16124,6 +16142,77 @@ class TreeStyleOperation extends Operation {
     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;
@@ -16176,7 +16265,8 @@ function toVersionVector(vector) {
   }
   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;
 }
@@ -16420,6 +16510,21 @@ function toOperation(operation) {
     );
     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");
   }
@@ -16674,7 +16779,8 @@ function fromVersionVector(pbVersionVector) {
   }
   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;
 }
@@ -16958,8 +17064,6 @@ function fromOperation(pbOperation) {
       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(
@@ -17003,6 +17107,14 @@ function fromOperation(pbOperation) {
         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`);
   }
@@ -17202,9 +17314,39 @@ function hexToBytes(hex) {
     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);
@@ -18275,6 +18417,15 @@ class ArrayProxy {
           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(
@@ -18294,6 +18445,16 @@ class ArrayProxy {
             );
             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(
@@ -18304,6 +18465,16 @@ class ArrayProxy {
             );
             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);
@@ -18312,6 +18483,15 @@ class ArrayProxy {
           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);
@@ -18445,7 +18625,6 @@ class ArrayProxy {
    */
   static moveAfterInternal(context, target, prevCreatedAt, createdAt) {
     const ticket = context.issueTimeTicket();
-    target.moveAfter(prevCreatedAt, createdAt, ticket);
     context.push(
       MoveOperation.create(
         target.getCreatedAt(),
@@ -18454,6 +18633,33 @@ class ArrayProxy {
         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
@@ -18502,6 +18708,25 @@ class ArrayProxy {
     );
     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.
    */
@@ -18513,6 +18738,39 @@ class ArrayProxy {
       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.
    */
@@ -21264,7 +21522,7 @@ function createAuthInterceptor(apiKey, token) {
   };
 }
 const name = "@yorkie-js/sdk";
-const version = "0.6.21";
+const version = "0.6.23";
 const pkg = {
   name,
   version