@liveblocks/react 1.3.4 → 1.3.6

package/dist/index.js

@@ -5,7 +5,7 @@ var _core = require('@liveblocks/core');
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/react";
-var PKG_VERSION = "1.3.4";
+var PKG_VERSION = "1.3.6";
 var PKG_FORMAT = "cjs";
 
 // src/ClientSideSuspense.tsx
@@ -32,6 +32,8 @@ var _withselectorjs = require('use-sync-external-store/shim/with-selector.js');
 
 // src/comments/CommentsRoom.ts
 
+
+
 var _nanoid = require('nanoid');
 
 var _indexjs = require('use-sync-external-store/shim/index.js');
@@ -78,158 +80,166 @@ var DeleteCommentError = class extends Error {
   }
 };
 
-// src/comments/lib/store.ts
-
-function createStore(initialState) {
-  let state = initialState;
+// src/comments/CommentsRoom.ts
+var POLLING_INTERVAL_REALTIME = 3e4;
+var POLLING_INTERVAL = 5e3;
+var MAX_ERROR_RETRY_COUNT = 5;
+var ERROR_RETRY_INTERVAL = 5e3;
+var THREAD_ID_PREFIX = "th";
+var COMMENT_ID_PREFIX = "cm";
+var DEDUPING_INTERVAL = 1e3;
+function createOptimisticId(prefix) {
+  return `${prefix}_${_nanoid.nanoid.call(void 0, )}`;
+}
+function createThreadsManager() {
+  let cache;
+  let request;
+  let mutation;
   const eventSource = _core.makeEventSource.call(void 0, );
   return {
-    get() {
-      return state;
+    get cache() {
+      return cache;
     },
-    set(newState) {
-      state = newState;
-      eventSource.notify(state);
+    set cache(value) {
+      cache = value;
+      eventSource.notify(cache);
     },
-    subscribe(callback) {
-      return eventSource.subscribe(callback);
+    get request() {
+      return request;
     },
-    subscribeOnce(callback) {
-      return eventSource.subscribeOnce(callback);
+    set request(value) {
+      request = value;
     },
-    subscribersCount() {
-      return eventSource.count();
+    get mutation() {
+      return mutation;
     },
-    destroy() {
-      return eventSource.clear();
+    set mutation(value) {
+      mutation = value;
+    },
+    subscribe(callback) {
+      return eventSource.subscribe(callback);
     }
   };
 }
-
-// src/comments/CommentsRoom.ts
-var POLLING_INTERVAL_REALTIME = 3e4;
-var POLLING_INTERVAL = 5e3;
-var THREAD_ID_PREFIX = "th";
-var COMMENT_ID_PREFIX = "cm";
-function createOptimisticId(prefix) {
-  return `${prefix}_${_nanoid.nanoid.call(void 0, )}`;
-}
 function createCommentsRoom(room, errorEventSource) {
-  const store = createStore({
-    isLoading: true
-  });
-  let fetchThreadsPromise = null;
-  let numberOfMutations = 0;
-  function endMutation() {
-    numberOfMutations--;
-    if (numberOfMutations === 0) {
-      void revalidateThreads();
-    }
-  }
-  function startMutation() {
-    pollingHub.threads.stop();
-    numberOfMutations++;
-  }
-  const pollingHub = {
-    // TODO: If there's an error, it will currently infinitely retry at the current polling rate → add retry logic
-    threads: _core.makePoller.call(void 0, revalidateThreads)
-  };
-  let unsubscribeRealtimeEvents;
-  let unsubscribeRealtimeConnection;
-  let realtimeClientConnected = false;
-  function getPollingInterval() {
-    return realtimeClientConnected ? POLLING_INTERVAL_REALTIME : POLLING_INTERVAL;
-  }
-  function ensureThreadsAreLoadedForMutations() {
-    const state = store.get();
-    if (state.isLoading || state.error) {
-      throw new Error(
-        "Cannot update threads or comments before they are loaded"
-      );
-    }
-    return state.threads;
-  }
-  async function revalidateThreads() {
-    pollingHub.threads.pause();
-    if (numberOfMutations === 0) {
-      if (fetchThreadsPromise === null) {
-        fetchThreadsPromise = room.getThreads();
+  const manager = createThreadsManager();
+  let timestamp = 0;
+  let commentsEventRefCount = 0;
+  let commentsEventDisposer;
+  async function mutate(data, options) {
+    const beforeMutationTimestamp = ++timestamp;
+    manager.mutation = {
+      startTime: beforeMutationTimestamp,
+      endTime: 0
+    };
+    const currentCache = manager.cache;
+    manager.cache = {
+      isLoading: false,
+      threads: options.optimisticData
+    };
+    try {
+      await data;
+      const activeMutation = manager.mutation;
+      if (activeMutation && beforeMutationTimestamp !== activeMutation.startTime) {
+        return;
       }
-      setThreads(await fetchThreadsPromise);
-      fetchThreadsPromise = null;
+    } catch (err) {
+      manager.cache = currentCache;
+      throw err;
     }
-    pollingHub.threads.resume();
-  }
-  function subscribe() {
-    if (!unsubscribeRealtimeEvents) {
-      unsubscribeRealtimeEvents = room.events.comments.subscribe(() => {
-        pollingHub.threads.restart(getPollingInterval());
-        void revalidateThreads();
-      });
+    manager.mutation = {
+      startTime: beforeMutationTimestamp,
+      endTime: ++timestamp
+    };
+    manager.request = void 0;
+    void revalidateCache(false);
+  }
+  async function revalidateCache(shouldDedupe, retryCount = 0) {
+    let startAt;
+    const shouldStartRequest = !manager.request || !shouldDedupe;
+    function deleteActiveRequest() {
+      const activeRequest = manager.request;
+      if (!activeRequest)
+        return;
+      if (activeRequest.timestamp !== startAt)
+        return;
+      manager.request = void 0;
     }
-    if (!unsubscribeRealtimeConnection) {
-      unsubscribeRealtimeConnection = room.events.status.subscribe((status) => {
-        const nextRealtimeClientConnected = status === "connected";
-        if (nextRealtimeClientConnected !== realtimeClientConnected) {
-          realtimeClientConnected = nextRealtimeClientConnected;
-          pollingHub.threads.restart(getPollingInterval());
-        }
-      });
+    function handleError() {
+      const timeout = ~~((Math.random() + 0.5) * (1 << (retryCount < 8 ? retryCount : 8))) * ERROR_RETRY_INTERVAL;
+      if (retryCount > MAX_ERROR_RETRY_COUNT)
+        return;
+      setTimeout(() => {
+        void revalidateCache(true, retryCount + 1);
+      }, timeout);
     }
-    pollingHub.threads.start(getPollingInterval());
-    return () => {
-      if (store.subscribersCount() > 1) {
+    try {
+      if (shouldStartRequest) {
+        const currentCache = manager.cache;
+        if (!currentCache)
+          manager.cache = { isLoading: true };
+        manager.request = {
+          fetcher: room.getThreads(),
+          timestamp: ++timestamp
+        };
+      }
+      const activeRequest = manager.request;
+      if (!activeRequest)
         return;
+      const newData = await activeRequest.fetcher;
+      startAt = activeRequest.timestamp;
+      if (shouldStartRequest) {
+        setTimeout(deleteActiveRequest, DEDUPING_INTERVAL);
       }
-      pollingHub.threads.stop();
-      _optionalChain([unsubscribeRealtimeEvents, 'optionalCall', _ => _()]);
-      unsubscribeRealtimeEvents = void 0;
-      _optionalChain([unsubscribeRealtimeConnection, 'optionalCall', _2 => _2()]);
-      unsubscribeRealtimeConnection = void 0;
-    };
-  }
-  function setThreads(newThreads) {
-    store.set({
-      threads: newThreads,
-      isLoading: false
-    });
-  }
-  function useThreadsInternal() {
-    _react.useEffect.call(void 0, subscribe, []);
-    return _indexjs.useSyncExternalStore.call(void 0, 
-      store.subscribe,
-      store.get,
-      store.get
-    );
-  }
-  function useThreads() {
-    _react.useEffect.call(void 0, () => {
-      void revalidateThreads();
-    }, []);
-    return useThreadsInternal();
-  }
-  function useThreadsSuspense() {
-    const result = useThreadsInternal();
-    if (result.isLoading) {
-      throw revalidateThreads();
-    }
-    if (result.error) {
-      throw result.error;
+      if (!manager.request || manager.request.timestamp !== startAt)
+        return;
+      const activeMutation = manager.mutation;
+      if (activeMutation && (activeMutation.startTime > startAt || activeMutation.endTime > startAt || activeMutation.endTime === 0)) {
+        return;
+      }
+      manager.cache = {
+        isLoading: false,
+        threads: newData
+      };
+    } catch (err) {
+      if (shouldStartRequest)
+        handleError();
+      deleteActiveRequest();
+      manager.cache = {
+        isLoading: false,
+        error: err
+      };
     }
-    return result.threads;
   }
-  function getCurrentUserId() {
-    const self = room.getSelf();
-    if (self === null || self.id === void 0) {
-      return "anonymous";
-    } else {
-      return self.id;
-    }
+  function editThreadMetadata(options) {
+    const threadId = options.threadId;
+    const metadata = "metadata" in options ? options.metadata : {};
+    const threads = getThreads();
+    const optimisticData = threads.map(
+      (thread) => thread.id === threadId ? {
+        ...thread,
+        metadata: {
+          ...thread.metadata,
+          ...metadata
+        }
+      } : thread
+    );
+    mutate(room.editThreadMetadata({ metadata, threadId }), {
+      optimisticData
+    }).catch((err) => {
+      errorEventSource.notify(
+        new EditThreadMetadataError(err, {
+          roomId: room.id,
+          threadId,
+          metadata
+        })
+      );
+    });
   }
   function createThread(options) {
     const body = options.body;
     const metadata = "metadata" in options ? options.metadata : {};
-    const threads = ensureThreadsAreLoadedForMutations();
+    const threads = getThreads();
     const threadId = createOptimisticId(THREAD_ID_PREFIX);
     const commentId = createOptimisticId(COMMENT_ID_PREFIX);
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -249,9 +259,9 @@ function createCommentsRoom(room, errorEventSource) {
         }
       ]
     };
-    setThreads([...threads, newThread]);
-    startMutation();
-    room.createThread({ threadId, commentId, body, metadata }).catch(
+    mutate(room.createThread({ threadId, commentId, body, metadata }), {
+      optimisticData: [...threads, newThread]
+    }).catch(
       (er) => errorEventSource.notify(
         new CreateThreadError(er, {
           roomId: room.id,
@@ -261,40 +271,14 @@ function createCommentsRoom(room, errorEventSource) {
           metadata
         })
       )
-    ).finally(endMutation);
-    return newThread;
-  }
-  function editThreadMetadata(options) {
-    const threadId = options.threadId;
-    const metadata = "metadata" in options ? options.metadata : {};
-    const threads = ensureThreadsAreLoadedForMutations();
-    setThreads(
-      threads.map(
-        (thread) => thread.id === threadId ? {
-          ...thread,
-          metadata: {
-            ...thread.metadata,
-            ...metadata
-          }
-        } : thread
-      )
     );
-    startMutation();
-    room.editThreadMetadata({ metadata, threadId }).catch(
-      (er) => errorEventSource.notify(
-        new EditThreadMetadataError(er, {
-          roomId: room.id,
-          threadId,
-          metadata
-        })
-      )
-    ).finally(endMutation);
+    return newThread;
   }
   function createComment({
     threadId,
     body
   }) {
-    const threads = ensureThreadsAreLoadedForMutations();
+    const threads = getThreads();
     const commentId = createOptimisticId(COMMENT_ID_PREFIX);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const comment = {
@@ -306,16 +290,15 @@ function createCommentsRoom(room, errorEventSource) {
       userId: getCurrentUserId(),
       body
     };
-    setThreads(
-      threads.map(
-        (thread) => thread.id === threadId ? {
-          ...thread,
-          comments: [...thread.comments, comment]
-        } : thread
-      )
+    const optimisticData = threads.map(
+      (thread) => thread.id === threadId ? {
+        ...thread,
+        comments: [...thread.comments, comment]
+      } : thread
     );
-    startMutation();
-    room.createComment({ threadId, commentId, body }).catch(
+    mutate(room.createComment({ threadId, commentId, body }), {
+      optimisticData
+    }).catch(
       (er) => errorEventSource.notify(
         new CreateCommentError(er, {
           roomId: room.id,
@@ -324,28 +307,27 @@ function createCommentsRoom(room, errorEventSource) {
           body
         })
       )
-    ).finally(endMutation);
+    );
     return comment;
   }
   function editComment({ threadId, commentId, body }) {
-    const threads = ensureThreadsAreLoadedForMutations();
+    const threads = getThreads();
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    setThreads(
-      threads.map(
-        (thread) => thread.id === threadId ? {
-          ...thread,
-          comments: thread.comments.map(
-            (comment) => comment.id === commentId ? {
-              ...comment,
-              editedAt: now,
-              body
-            } : comment
-          )
-        } : thread
-      )
+    const optimisticData = threads.map(
+      (thread) => thread.id === threadId ? {
+        ...thread,
+        comments: thread.comments.map(
+          (comment) => comment.id === commentId ? {
+            ...comment,
+            editedAt: now,
+            body
+          } : comment
+        )
+      } : thread
     );
-    startMutation();
-    room.editComment({ threadId, commentId, body }).catch(
+    mutate(room.editComment({ threadId, commentId, body }), {
+      optimisticData
+    }).catch(
       (er) => errorEventSource.notify(
         new EditCommentError(er, {
           roomId: room.id,
@@ -354,10 +336,10 @@ function createCommentsRoom(room, errorEventSource) {
           body
         })
       )
-    ).finally(endMutation);
+    );
   }
   function deleteComment({ threadId, commentId }) {
-    const threads = ensureThreadsAreLoadedForMutations();
+    const threads = getThreads();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const newThreads = [];
     for (const thread of threads) {
@@ -379,9 +361,9 @@ function createCommentsRoom(room, errorEventSource) {
         newThreads.push(thread);
       }
     }
-    setThreads(newThreads);
-    startMutation();
-    room.deleteComment({ threadId, commentId }).catch(
+    mutate(room.deleteComment({ threadId, commentId }), {
+      optimisticData: newThreads
+    }).catch(
       (er) => errorEventSource.notify(
         new DeleteCommentError(er, {
           roomId: room.id,
@@ -389,13 +371,103 @@ function createCommentsRoom(room, errorEventSource) {
           commentId
         })
       )
-    ).finally(endMutation);
+    );
+  }
+  function getCurrentUserId() {
+    const self = room.getSelf();
+    if (self === null || self.id === void 0) {
+      return "anonymous";
+    } else {
+      return self.id;
+    }
+  }
+  function getThreads() {
+    const threads = manager.cache;
+    if (!threads || threads.isLoading || threads.error) {
+      throw new Error(
+        "Cannot update threads or comments before they are loaded."
+      );
+    }
+    return threads.threads;
+  }
+  function _subscribe() {
+    if (commentsEventRefCount === 0) {
+      commentsEventDisposer = room.events.comments.subscribe(() => {
+        void revalidateCache(true);
+      });
+    }
+    commentsEventRefCount = commentsEventRefCount + 1;
+    return () => {
+      commentsEventRefCount = commentsEventRefCount - 1;
+      if (commentsEventRefCount > 0)
+        return;
+      _optionalChain([commentsEventDisposer, 'optionalCall', _ => _()]);
+      commentsEventDisposer = void 0;
+    };
+  }
+  function usePolling() {
+    const status = _indexjs.useSyncExternalStore.call(void 0, 
+      room.events.status.subscribe,
+      room.getStatus,
+      room.getStatus
+    );
+    _react.useEffect.call(void 0, 
+      () => {
+        const interval = status === "connected" ? POLLING_INTERVAL_REALTIME : POLLING_INTERVAL;
+        let revalidationTimerId;
+        function scheduleRevalidation() {
+          revalidationTimerId = window.setTimeout(
+            executeRevalidation,
+            interval
+          );
+        }
+        function executeRevalidation() {
+          void revalidateCache(true).then(scheduleRevalidation);
+        }
+        scheduleRevalidation();
+        return () => {
+          window.clearTimeout(revalidationTimerId);
+        };
+      },
+      // eslint-disable-next-line react-hooks/exhaustive-deps -- ESLint recommends against adding `revalidateCache` as a dependency, but not doing so causes the code inside `useEffect` to reference an outdated version of `revalidateCache`
+      [status, revalidateCache]
+    );
+  }
+  function useThreadsInternal() {
+    _react.useEffect.call(void 0, _subscribe, [_subscribe]);
+    usePolling();
+    const cache = _indexjs.useSyncExternalStore.call(void 0, 
+      manager.subscribe,
+      () => manager.cache,
+      () => manager.cache
+    );
+    return _nullishCoalesce(cache, () => ( { isLoading: true }));
+  }
+  function useThreads() {
+    _react.useEffect.call(void 0, 
+      () => {
+        void revalidateCache(true);
+      },
+      // eslint-disable-next-line react-hooks/exhaustive-deps -- ESLint recommends against adding `revalidateCache` as a dependency, but not doing so causes the code inside `useEffect` to reference an outdated version of `revalidateCache`
+      [revalidateCache]
+    );
+    return useThreadsInternal();
+  }
+  function useThreadsSuspense() {
+    const cache = useThreadsInternal();
+    if (cache.isLoading) {
+      throw revalidateCache(true);
+    }
+    if (cache.error) {
+      throw cache.error;
+    }
+    return cache.threads;
   }
   return {
     useThreads,
     useThreadsSuspense,
-    createThread,
     editThreadMetadata,
+    createThread,
     createComment,
     editComment,
     deleteComment
@@ -462,31 +534,31 @@ function useAsyncCache(cache, key, options) {
     if (key === null || !cache) {
       return null;
     }
-    const cacheItem2 = cache.create(key, _optionalChain([frozenOptions, 'optionalAccess', _3 => _3.overrideFunction]));
+    const cacheItem2 = cache.create(key, _optionalChain([frozenOptions, 'optionalAccess', _2 => _2.overrideFunction]));
     void cacheItem2.get();
     return cacheItem2;
   }, [cache, frozenOptions, key]);
   const subscribe = _react.useCallback.call(void 0, 
-    (callback) => _nullishCoalesce(_optionalChain([cacheItem, 'optionalAccess', _4 => _4.subscribe, 'call', _5 => _5(callback)]), () => ( noop)),
+    (callback) => _nullishCoalesce(_optionalChain([cacheItem, 'optionalAccess', _3 => _3.subscribe, 'call', _4 => _4(callback)]), () => ( noop)),
     [cacheItem]
   );
   const getState = _react.useCallback.call(void 0, 
-    () => _nullishCoalesce(_optionalChain([cacheItem, 'optionalAccess', _6 => _6.getState, 'call', _7 => _7()]), () => ( INITIAL_ASYNC_STATE)),
+    () => _nullishCoalesce(_optionalChain([cacheItem, 'optionalAccess', _5 => _5.getState, 'call', _6 => _6()]), () => ( INITIAL_ASYNC_STATE)),
     [cacheItem]
   );
-  const revalidate = _react.useCallback.call(void 0, () => _optionalChain([cacheItem, 'optionalAccess', _8 => _8.revalidate, 'call', _9 => _9()]), [cacheItem]);
+  const revalidate = _react.useCallback.call(void 0, () => _optionalChain([cacheItem, 'optionalAccess', _7 => _7.revalidate, 'call', _8 => _8()]), [cacheItem]);
   const state = _indexjs.useSyncExternalStore.call(void 0, subscribe, getState, getState);
   const previousData = _react.useRef.call(void 0, );
   let data = state.data;
   _react.useEffect.call(void 0, () => {
     previousData.current = { key, data: state.data };
   }, [key, state]);
-  if (_optionalChain([frozenOptions, 'optionalAccess', _10 => _10.suspense]) && state.isLoading && cacheItem) {
+  if (_optionalChain([frozenOptions, 'optionalAccess', _9 => _9.suspense]) && state.isLoading && cacheItem) {
     throw new Promise((resolve) => {
       cacheItem.subscribeOnce(() => resolve());
     });
   }
-  if (state.isLoading && _optionalChain([frozenOptions, 'optionalAccess', _11 => _11.keepPreviousDataWhileLoading]) && typeof state.data === "undefined" && _optionalChain([previousData, 'access', _12 => _12.current, 'optionalAccess', _13 => _13.key]) !== key && typeof _optionalChain([previousData, 'access', _14 => _14.current, 'optionalAccess', _15 => _15.data]) !== "undefined") {
+  if (state.isLoading && _optionalChain([frozenOptions, 'optionalAccess', _10 => _10.keepPreviousDataWhileLoading]) && typeof state.data === "undefined" && _optionalChain([previousData, 'access', _11 => _11.current, 'optionalAccess', _12 => _12.key]) !== key && typeof _optionalChain([previousData, 'access', _13 => _13.current, 'optionalAccess', _14 => _14.data]) !== "undefined") {
     data = previousData.current.data;
   }
   return {
@@ -642,9 +714,9 @@ function createRoomContext(client, options) {
       );
       setRoom(room2);
       return () => {
-        const commentsRoom = commentsRooms.get(roomId);
+        const commentsRoom = commentsRooms.get(room2);
         if (commentsRoom) {
-          commentsRooms.delete(roomId);
+          commentsRooms.delete(room2);
         }
         client.leave(roomId);
       };
@@ -863,7 +935,7 @@ function createRoomContext(client, options) {
       function onRootChange() {
         const newValue = root.get(key);
         if (newValue !== curr) {
-          _optionalChain([unsubCurr, 'optionalCall', _16 => _16()]);
+          _optionalChain([unsubCurr, 'optionalCall', _15 => _15()]);
           curr = newValue;
           subscribeToCurr();
           rerender();
@@ -874,7 +946,7 @@ function createRoomContext(client, options) {
       const unsubscribeRoot = room.subscribe(root, onRootChange);
       return () => {
         unsubscribeRoot();
-        _optionalChain([unsubCurr, 'optionalCall', _17 => _17()]);
+        _optionalChain([unsubCurr, 'optionalCall', _16 => _16()]);
       };
     }, [rootOrNull, room, key, rerender]);
     if (rootOrNull === null) {
@@ -1000,10 +1072,10 @@ function createRoomContext(client, options) {
   const commentsErrorEventSource = _core.makeEventSource.call(void 0, );
   const commentsRooms = /* @__PURE__ */ new Map();
   function getCommentsRoom(room) {
-    let commentsRoom = commentsRooms.get(room.id);
+    let commentsRoom = commentsRooms.get(room);
     if (commentsRoom === void 0) {
       commentsRoom = createCommentsRoom(room, commentsErrorEventSource);
-      commentsRooms.set(room.id, commentsRoom);
+      commentsRooms.set(room, commentsRoom);
     }
     return commentsRoom;
   }