@yorkie-js/sdk 0.7.7 → 0.7.8

package/dist/yorkie-js-sdk.js

@@ -362,7 +362,7 @@
     }
   }
   const IMPLICIT$3 = 2;
-  const unsafeLocal = Symbol.for("reflect unsafe local");
+  const unsafeLocal = /* @__PURE__ */ Symbol.for("reflect unsafe local");
   function unsafeOneofCase(target, oneof) {
     const c = target[oneof.localName].case;
     if (c === void 0) {
@@ -588,7 +588,7 @@
     }
     return ret;
   }
-  const tokenZeroMessageField = Symbol();
+  const tokenZeroMessageField = /* @__PURE__ */ Symbol();
   const messagePrototypes = /* @__PURE__ */ new WeakMap();
   function createZeroMessage(desc) {
     let msg;
@@ -690,7 +690,7 @@
   function isFieldError(arg) {
     return arg instanceof Error && errorNames.includes(arg.name) && "field" in arg && typeof arg.field == "function";
   }
-  const symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
+  const symbol = /* @__PURE__ */ Symbol.for("@bufbuild/protobuf/text-encoding");
   function getTextEncoding() {
     if (globalThis[symbol] == void 0) {
       const te = new globalThis.TextEncoder();
@@ -4058,7 +4058,7 @@
       msg.set(field, scalarValue);
     }
   }
-  const tokenIgnoredUnknownEnum = Symbol();
+  const tokenIgnoredUnknownEnum = /* @__PURE__ */ Symbol();
   function readEnum(desc, json, ignoreUnknownFields, nullAsZeroValue) {
     if (json === null) {
       if (desc.typeName == "google.protobuf.NullValue") {
@@ -4084,7 +4084,7 @@
     }
     throw new Error(`cannot decode ${desc} from JSON: ${formatVal(json)}`);
   }
-  const tokenNull = Symbol();
+  const tokenNull = /* @__PURE__ */ Symbol();
   function scalarFromJson(field, json, nullAsZeroValue) {
     if (json === null) {
       if (nullAsZeroValue) {
@@ -5905,6 +5905,8 @@
       this.message = message;
       this.toString = () => `[code=${this.code}]: ${this.message}`;
     }
+    code;
+    message;
     name = "YorkieError";
     stack;
   }
@@ -12534,8 +12536,10 @@
             break;
           }
           if (next.parent && next.parent === toParent) {
-            collectFromLeft = next;
-            collectFromParent = toParent;
+            if (toLeft !== toParent) {
+              collectFromLeft = next;
+              collectFromParent = toParent;
+            }
             break;
           }
           current = next;
@@ -12598,6 +12602,7 @@
         tokensToBeRemoved,
         editedAt
       );
+      const mergeLevel = toBeMergedNodes.length;
       const pairs = [];
       for (const node of nodesToBeRemoved) {
         if (node.remove(editedAt)) {
@@ -12724,7 +12729,15 @@
           }
         }
       }
-      return [changes, pairs, diff, nodesToBeRemoved, fromIdx];
+      return [
+        changes,
+        pairs,
+        diff,
+        nodesToBeRemoved,
+        fromIdx,
+        mergeLevel,
+        preTombstoned
+      ];
     }
     /**
      * `editT` edits the given range with the given value.
@@ -13165,11 +13178,35 @@
       return [prev, prev.isText ? TokenType.Text : TokenType.End];
     }
   }
-  function clearRemovedAt(node) {
-    traverseAll(node, (n) => {
+  function cloneAndDropPreTombstoned(node, preTombstoned) {
+    const clone = node.deepcopy();
+    filterChildren(clone, preTombstoned);
+    traverseAll(clone, (n) => {
       n.removedAt = void 0;
-      n.visibleSize = n.totalSize;
+      if (n.isText) {
+        n.visibleSize = n.value.length;
+        n.totalSize = n.value.length;
+        return;
+      }
+      let size = 0;
+      for (const child of n._children) size += child.paddedSize();
+      n.visibleSize = size;
+      n.totalSize = size;
     });
+    return clone;
+  }
+  function filterChildren(node, preTombstoned) {
+    const all = node._children;
+    if (!all) return;
+    const kept = [];
+    for (const child of all) {
+      if (preTombstoned.has(child.id.toIDString())) {
+        continue;
+      }
+      filterChildren(child, preTombstoned);
+      kept.push(child);
+    }
+    node._children = kept;
   }
   class TreeEditOperation extends Operation {
     fromPos;
@@ -13241,7 +13278,15 @@
           this.toPos = tree.findPos(this.toIdx);
         }
       }
-      const [changes, pairs, diff, removedNodes, preEditFromIdx] = tree.edit(
+      const [
+        changes,
+        pairs,
+        diff,
+        removedNodes,
+        preEditFromIdx,
+        mergeLevel,
+        preTombstoned
+      ] = tree.edit(
         [this.fromPos, this.toPos],
         this.contents?.map((content) => content.deepcopy()),
         this.splitLevel,
@@ -13276,7 +13321,13 @@
       let reverseOp;
       const isPureSplit = this.splitLevel > 0 && !this.contents?.length && removedNodes.length === 0;
       if (this.splitLevel === 0) {
-        reverseOp = this.toReverseOperation(tree, removedNodes, preEditFromIdx);
+        reverseOp = this.toReverseOperation(
+          tree,
+          removedNodes,
+          preEditFromIdx,
+          preTombstoned,
+          mergeLevel
+        );
       } else if (isPureSplit) {
         reverseOp = this.toSplitReverseOperation(tree, preEditFromIdx);
       }
@@ -13314,7 +13365,7 @@
      * @param removedNodes - Nodes that were removed by this edit
      * @param preEditFromIdx - The from index captured BEFORE the edit
      */
-    toReverseOperation(tree, removedNodes, preEditFromIdx) {
+    toReverseOperation(tree, removedNodes, preEditFromIdx, preTombstoned, mergeLevel) {
       if (this.redoSplitLevel !== void 0 && this.redoSplitLevel > 0) {
         const splitRedoFromPos = tree.findPos(preEditFromIdx);
         const splitRedoOp = TreeEditOperation.create(
@@ -13333,19 +13384,36 @@
         );
         return splitRedoOp;
       }
+      if (mergeLevel && mergeLevel > 0) {
+        const splitFromPos = tree.findPos(preEditFromIdx);
+        const splitUndoOp = TreeEditOperation.create(
+          this.getParentCreatedAt(),
+          splitFromPos,
+          splitFromPos,
+          void 0,
+          // no inserted content — split creates boundaries
+          mergeLevel,
+          // splitLevel = number of merged boundaries
+          void 0,
+          // executedAt assigned at undo time
+          true,
+          // isUndoOp
+          preEditFromIdx,
+          preEditFromIdx
+        );
+        return splitUndoOp;
+      }
       const insertedContentSize = this.contents ? this.contents.reduce((sum, node) => sum + node.paddedSize(), 0) : 0;
       const maxNeededIdx = preEditFromIdx + insertedContentSize;
       if (maxNeededIdx > tree.getSize()) {
         return void 0;
       }
       const topLevelRemoved = removedNodes.filter(
-        (node) => !node.parent || !removedNodes.includes(node.parent)
+        (node) => !preTombstoned.has(node.id.toIDString()) && (!node.parent || !removedNodes.includes(node.parent))
       );
-      const reverseContents = topLevelRemoved.length > 0 ? topLevelRemoved.map((n) => {
-        const clone = n.deepcopy();
-        clearRemovedAt(clone);
-        return clone;
-      }) : void 0;
+      const reverseContents = topLevelRemoved.length > 0 ? topLevelRemoved.map(
+        (n) => cloneAndDropPreTombstoned(n, preTombstoned)
+      ) : void 0;
       const reverseFromPos = tree.findPos(preEditFromIdx);
       let reverseToPos;
       if (insertedContentSize > 0) {
@@ -20164,6 +20232,11 @@
         }
       ]);
     }
+    /**
+     * `clearHistory` flushes both undo and redo stacks. This is used
+     * after applying a snapshot or initialRoot so that setup operations
+     * are not reachable via undo.
+     */
     clearHistory() {
       this.internalHistory.clearRedo();
       this.internalHistory.clearUndo();
@@ -20623,10 +20696,7 @@
       }
       const ops = isUndo ? this.internalHistory.popUndo() : this.internalHistory.popRedo();
       if (!ops) {
-        throw new YorkieError(
-          Code.ErrRefused,
-          `There is no operation to be ${isUndo ? "undone" : "redone"}`
-        );
+        return;
       }
       this.ensureClone();
       const ctx = ChangeContext.create(
@@ -20719,6 +20789,8 @@
     syncMode;
     changeEventReceived;
     lastHeartbeatTime;
+    pollInterval;
+    pollIntervalPinned;
     reconnectStreamDelay;
     cancelled;
     watchStream;
@@ -20726,13 +20798,15 @@
     watchAbortController;
     syncPromise;
     _detaching = false;
-    constructor(reconnectStreamDelay, resource, resourceID, syncMode) {
+    constructor(reconnectStreamDelay, resource, resourceID, syncMode, pollInterval = 0, pollIntervalPinned = false) {
       this.reconnectStreamDelay = reconnectStreamDelay;
       this.resource = resource;
       this.resourceID = resourceID;
       this.syncMode = syncMode;
       this.changeEventReceived = syncMode !== void 0 ? false : void 0;
       this.lastHeartbeatTime = Date.now();
+      this.pollInterval = pollInterval;
+      this.pollIntervalPinned = pollIntervalPinned;
       this.cancelled = false;
     }
     /**
@@ -20752,6 +20826,9 @@
       if (this.syncMode === SyncMode.RealtimePushOnly) {
         return this.resource.hasLocalChanges();
       }
+      if (this.syncMode === SyncMode.Polling) {
+        return Date.now() - this.lastHeartbeatTime >= this.pollInterval;
+      }
       return this.syncMode !== SyncMode.Manual && (this.resource.hasLocalChanges() || (this.changeEventReceived ?? false));
     }
     /**
@@ -20765,7 +20842,8 @@
       if (this.syncMode === SyncMode.Manual) {
         return false;
       }
-      return Date.now() - this.lastHeartbeatTime >= heartbeatInterval;
+      const interval = this.pollInterval > 0 ? this.pollInterval : heartbeatInterval;
+      return Date.now() - this.lastHeartbeatTime >= interval;
     }
     /**
      * `updateHeartbeatTime` updates the last heartbeat time.
@@ -20844,6 +20922,16 @@
         }
       }
     }
+    /**
+     * `resetCancelled` clears the cancelled flag so the watch loop can run again
+     * after a previous cancellation (e.g., after changeSyncMode back to Realtime).
+     * Caller must invoke `runWatchLoop` immediately after to claim the stream slot;
+     * `doLoop`'s `if (this.watchStream)` guard prevents double-stream creation if a
+     * delayed `onDisconnect` callback from the previously-cancelled stream races.
+     */
+    resetCancelled() {
+      this.cancelled = false;
+    }
     /**
      * `cancelWatchStream` cancels the watch stream.
      */
@@ -20878,7 +20966,7 @@
     };
   }
   const name = "@yorkie-js/sdk";
-  const version = "0.7.7";
+  const version = "0.7.8";
   const pkg = {
     name,
     version
@@ -21161,6 +21249,7 @@
     SyncMode2["Realtime"] = "realtime";
     SyncMode2["RealtimePushOnly"] = "realtime-pushonly";
     SyncMode2["RealtimeSyncOff"] = "realtime-syncoff";
+    SyncMode2["Polling"] = "polling";
     return SyncMode2;
   })(SyncMode || {});
   var ClientStatus = /* @__PURE__ */ ((ClientStatus2) => {
@@ -21173,6 +21262,7 @@
     ClientCondition2["WatchLoop"] = "WatchLoop";
     return ClientCondition2;
   })(ClientCondition || {});
+  const DefaultPollingIntervalMs = 3e3;
   const DefaultClientOptions = {
     rpcAddr: "https://api.yorkie.dev",
     syncLoopDuration: 50,
@@ -21368,6 +21458,14 @@
       doc.setActor(this.id);
       doc.update((_, p) => p.set(opts.initialPresence || {}));
       const syncMode = opts.syncMode ?? "realtime";
+      if (opts.documentPollInterval !== void 0 && opts.documentPollInterval <= 0) {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          "documentPollInterval must be greater than 0"
+        );
+      }
+      const pollIntervalPinned = opts.documentPollInterval !== void 0;
+      const pollInterval = pollIntervalPinned ? opts.documentPollInterval : syncMode === "polling" ? DefaultPollingIntervalMs : 0;
       return this.enqueueTask(async () => {
         try {
           const res = await this.rpcClient.attachDocument(
@@ -21397,10 +21495,12 @@
               this.reconnectStreamDelay,
               doc,
               res.documentId,
-              syncMode
+              syncMode,
+              pollInterval,
+              pollIntervalPinned
             )
           );
-          if (syncMode !== "manual") {
+          if (syncMode !== "manual" && syncMode !== "polling") {
             await this.runWatchLoop(doc.getKey());
           }
           logger.info(`[AD] c:"${this.getKey()}" attaches d:"${doc.getKey()}"`);
@@ -21416,6 +21516,7 @@
               }
             });
           }
+          doc.clearHistory();
           return doc;
         } catch (err) {
           logger.error(`[AD] c:"${this.getKey()}" err :`, err);
@@ -21526,12 +21627,23 @@
           channel.setSessionID(res.sessionId);
           channel.updateSessionCount(Number(res.sessionCount), 0);
           channel.applyStatus(ChannelStatus.Attached);
-          const syncMode = opts.isRealtime !== false ? "realtime" : "manual";
+          const syncMode = opts.syncMode ?? "realtime";
+          this.assertValidChannelSyncMode(syncMode);
+          if (opts.channelHeartbeatInterval !== void 0 && opts.channelHeartbeatInterval <= 0) {
+            throw new YorkieError(
+              Code.ErrInvalidArgument,
+              "channelHeartbeatInterval must be greater than 0"
+            );
+          }
+          const pollIntervalPinned = opts.channelHeartbeatInterval !== void 0;
+          const pollInterval = pollIntervalPinned ? opts.channelHeartbeatInterval : syncMode === "polling" ? DefaultPollingIntervalMs : this.channelHeartbeatInterval;
           const attachment = new Attachment(
             this.reconnectStreamDelay,
             channel,
             res.sessionId,
-            syncMode
+            syncMode,
+            pollInterval,
+            pollIntervalPinned
           );
           channel.subscribe("local-broadcast", (event) => {
             const { topic, payload, options } = event;
@@ -21607,9 +21719,17 @@
       return this.enqueueTask(task);
     }
     /**
-     * `changeSyncMode` changes the synchronization mode of the given document.
+     * `changeSyncMode` changes the synchronization mode of the given resource.
      */
-    async changeSyncMode(doc, syncMode) {
+    async changeSyncMode(resource, syncMode) {
+      return this.enqueueTask(async () => {
+        if (resource instanceof Channel) {
+          return this.changeChannelSyncMode(resource, syncMode);
+        }
+        return this.changeDocumentSyncMode(resource, syncMode);
+      });
+    }
+    async changeDocumentSyncMode(doc, syncMode) {
       if (!this.isActive()) {
         throw new YorkieError(
           Code.ErrClientNotActivated,
@@ -21627,19 +21747,66 @@
       if (prevSyncMode === syncMode) {
         return doc;
       }
-      attachment.changeSyncMode(syncMode);
-      if (syncMode === "manual") {
+      if (syncMode === "manual" || syncMode === "polling") {
         attachment.cancelWatchStream();
-        return doc;
       }
+      attachment.changeSyncMode(syncMode);
       if (syncMode === "realtime") {
         attachment.changeEventReceived = true;
       }
-      if (prevSyncMode === "manual") {
+      if (!attachment.pollIntervalPinned) {
+        attachment.pollInterval = syncMode === "polling" ? DefaultPollingIntervalMs : 0;
+      }
+      if ((prevSyncMode === "manual" || prevSyncMode === "polling") && syncMode !== "manual" && syncMode !== "polling") {
+        attachment.resetCancelled();
         await this.runWatchLoop(doc.getKey());
       }
       return doc;
     }
+    /**
+     * `assertValidChannelSyncMode` rejects sync modes that are not valid for
+     * channels. `RealtimePushOnly` and `RealtimeSyncOff` are document-only.
+     */
+    assertValidChannelSyncMode(syncMode) {
+      if (syncMode !== "manual" && syncMode !== "realtime" && syncMode !== "polling") {
+        throw new YorkieError(
+          Code.ErrInvalidArgument,
+          `invalid channel sync mode: ${syncMode}`
+        );
+      }
+    }
+    async changeChannelSyncMode(channel, syncMode) {
+      if (!this.isActive()) {
+        throw new YorkieError(
+          Code.ErrClientNotActivated,
+          `${this.key} is not active`
+        );
+      }
+      const attachment = this.attachmentMap.get(channel.getKey());
+      if (!attachment) {
+        throw new YorkieError(
+          Code.ErrNotAttached,
+          `${channel.getKey()} is not attached`
+        );
+      }
+      const prevSyncMode = attachment.syncMode;
+      if (prevSyncMode === syncMode) {
+        return channel;
+      }
+      this.assertValidChannelSyncMode(syncMode);
+      if (prevSyncMode === "realtime") {
+        attachment.cancelWatchStream();
+      }
+      attachment.changeSyncMode(syncMode);
+      if (!attachment.pollIntervalPinned) {
+        attachment.pollInterval = syncMode === "polling" ? DefaultPollingIntervalMs : syncMode === "realtime" ? this.channelHeartbeatInterval : 0;
+      }
+      if (syncMode === "realtime") {
+        attachment.resetCancelled();
+        await this.runWatchLoop(channel.getKey());
+      }
+      return channel;
+    }
     /**
      * `sync` implementation that handles both Document and Channel.
      */
@@ -22484,6 +22651,7 @@
           return doc;
         }
         doc.applyChangePack(respPack);
+        attachment.updateHeartbeatTime();
         attachment.resource.publish([
           {
             type: DocEventType.SyncStatusChanged,