@yorkie-js/react 0.7.7 → 0.7.8

package/dist/yorkie-js-react.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) {
@@ -20159,6 +20227,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();
@@ -20618,10 +20691,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(
@@ -20714,6 +20784,8 @@
     syncMode;
     changeEventReceived;
     lastHeartbeatTime;
+    pollInterval;
+    pollIntervalPinned;
     reconnectStreamDelay;
     cancelled;
     watchStream;
@@ -20721,13 +20793,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;
     }
     /**
@@ -20747,6 +20821,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));
     }
     /**
@@ -20760,7 +20837,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.
@@ -20839,6 +20917,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.
      */
@@ -20873,7 +20961,7 @@
     };
   }
   const name$1 = "@yorkie-js/sdk";
-  const version$1 = "0.7.7";
+  const version$1 = "0.7.8";
   const pkg$1 = {
     name: name$1,
     version: version$1
@@ -21156,8 +21244,10 @@
     SyncMode2["Realtime"] = "realtime";
     SyncMode2["RealtimePushOnly"] = "realtime-pushonly";
     SyncMode2["RealtimeSyncOff"] = "realtime-syncoff";
+    SyncMode2["Polling"] = "polling";
     return SyncMode2;
   })(SyncMode || {});
+  const DefaultPollingIntervalMs = 3e3;
   const DefaultClientOptions = {
     rpcAddr: "https://api.yorkie.dev",
     syncLoopDuration: 50,
@@ -21353,6 +21443,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(
@@ -21382,10 +21480,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()}"`);
@@ -21401,6 +21501,7 @@
               }
             });
           }
+          doc.clearHistory();
           return doc;
         } catch (err) {
           logger.error(`[AD] c:"${this.getKey()}" err :`, err);
@@ -21511,12 +21612,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;
@@ -21592,9 +21704,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,
@@ -21612,19 +21732,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.
      */
@@ -22469,6 +22636,7 @@
           return doc;
         }
         doc.applyChangePack(respPack);
+        attachment.updateHeartbeatTime();
         attachment.resource.publish([
           {
             type: DocEventType.SyncStatusChanged,
@@ -22794,7 +22962,7 @@
     };
   }
   const name = "@yorkie-js/react";
-  const version = "0.7.7";
+  const version = "0.7.8";
   const pkg = {
     name,
     version
@@ -23250,7 +23418,7 @@
   const ChannelContext = react.createContext(
     void 0
   );
-  function useYorkieChannel(client, clientLoading, clientError, channelKey, isRealtime, channelStore) {
+  function useYorkieChannel(client, clientLoading, clientError, channelKey, syncMode, channelStore) {
     const channelRef = react.useRef(void 0);
     const [didMount, setDidMount] = react.useState(false);
     react.useEffect(() => {
@@ -23279,7 +23447,7 @@
         }));
         try {
           const newChannel = new Channel(channelKey);
-          await client.attach(newChannel, { isRealtime });
+          await client.attach(newChannel, { syncMode });
           channelRef.current = newChannel;
           unsubscribe = newChannel.subscribe(() => {
             channelStore.setState((state) => ({
@@ -23317,12 +23485,13 @@
         }
         detachChannel();
       };
-    }, [client, clientLoading, clientError, channelKey, isRealtime, didMount]);
+    }, [client, clientLoading, clientError, channelKey, syncMode, didMount]);
   }
   const ChannelProvider = ({
     children,
     channelKey,
-    isRealtime = true
+    syncMode,
+    isRealtime
   }) => {
     const { client, loading: clientLoading, error: clientError } = useYorkie();
     const channelStoreRef = react.useRef(
@@ -23337,12 +23506,13 @@
       });
     }
     const channelStore = channelStoreRef.current;
+    const resolvedSyncMode = syncMode ?? (isRealtime === false ? SyncMode.Manual : SyncMode.Realtime);
     useYorkieChannel(
       client,
       clientLoading,
       clientError,
       channelKey,
-      isRealtime,
+      resolvedSyncMode,
       channelStore
     );
     return /* @__PURE__ */ jsxRuntime.jsx(ChannelContext.Provider, { value: channelStore, children });
@@ -23368,6 +23538,7 @@
   exports2.ChannelProvider = ChannelProvider;
   exports2.Counter = Counter;
   exports2.DocumentProvider = DocumentProvider;
+  exports2.SyncMode = SyncMode;
   exports2.Text = Text;
   exports2.Tree = Tree;
   exports2.YorkieProvider = YorkieProvider;