@liveblocks/react 2.1.1-test2 → 2.2.1

package/dist/{chunk-PAHCU5NM.mjs → chunk-BIKCNKTX.mjs}

@@ -1,6 +1,6 @@
 // src/version.ts
 var PKG_NAME = "@liveblocks/react";
-var PKG_VERSION = "2.1.1-test2";
+var PKG_VERSION = "2.2.1";
 var PKG_FORMAT = "esm";
 
 // src/ClientSideSuspense.tsx
@@ -14,7 +14,13 @@ function ClientSideSuspense(props) {
 }
 
 // src/liveblocks.tsx
-import { createClient, kInternal, makePoller, raise } from "@liveblocks/core";
+import {
+  createClient,
+  kInternal,
+  makePoller,
+  raise,
+  shallow
+} from "@liveblocks/core";
 import { nanoid } from "nanoid";
 import React2, {
   createContext,
@@ -287,7 +293,8 @@ function useInboxNotifications_withClient(client) {
     store.subscribe,
     store.get,
     store.get,
-    selectorFor_useInboxNotifications
+    selectorFor_useInboxNotifications,
+    shallow
   );
 }
 function useInboxNotificationsSuspense_withClient(client) {
@@ -308,7 +315,8 @@ function useInboxNotificationsSuspense_withClient(client) {
     store.subscribe,
     store.get,
     store.get,
-    selectorFor_useInboxNotificationsSuspense
+    selectorFor_useInboxNotificationsSuspense,
+    shallow
   );
 }
 function useUnreadInboxNotificationsCount_withClient(client) {
@@ -318,7 +326,8 @@ function useUnreadInboxNotificationsCount_withClient(client) {
     store.subscribe,
     store.get,
     store.get,
-    selectorFor_useUnreadInboxNotificationsCount
+    selectorFor_useUnreadInboxNotificationsCount,
+    shallow
   );
 }
 function useUnreadInboxNotificationsCountSuspense_withClient(client) {
@@ -336,7 +345,8 @@ function useUnreadInboxNotificationsCountSuspense_withClient(client) {
     store.subscribe,
     store.get,
     store.get,
-    selectorFor_useUnreadInboxNotificationsCountSuspense
+    selectorFor_useUnreadInboxNotificationsCountSuspense,
+    shallow
   );
 }
 function useMarkInboxNotificationAsRead_withClient(client) {
@@ -550,12 +560,15 @@ function useRoomInfoSuspense_withClient(client, roomId) {
   };
 }
 function createSharedContext(client) {
+  const useClient2 = () => client;
   return {
     classic: {
+      useClient: useClient2,
       useUser: (userId) => useUser_withClient(client, userId),
       useRoomInfo: (roomId) => useRoomInfo_withClient(client, roomId)
     },
     suspense: {
+      useClient: useClient2,
       useUser: (userId) => useUserSuspense_withClient(client, userId),
       useRoomInfo: (roomId) => useRoomInfoSuspense_withClient(client, roomId)
     }
@@ -677,6 +690,22 @@ var EditThreadMetadataError = class extends Error {
     this.name = "EditThreadMetadataError";
   }
 };
+var MarkThreadAsResolvedError = class extends Error {
+  constructor(cause, context) {
+    super("Mark thread as resolved failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "MarkThreadAsResolvedError";
+  }
+};
+var MarkThreadAsUnresolvedError = class extends Error {
+  constructor(cause, context) {
+    super("Mark thread as unresolved failed.");
+    this.cause = cause;
+    this.context = context;
+    this.name = "MarkThreadAsUnresolvedError";
+  }
+};
 var CreateCommentError = class extends Error {
   constructor(cause, context) {
     super("Create comment failed.");
@@ -777,7 +806,7 @@ var assertMetadataValueIsString = (value) => {
 };
 
 // src/room.tsx
-import { shallow } from "@liveblocks/client";
+import { shallow as shallow2 } from "@liveblocks/client";
 import {
   addReaction,
   CommentsApiError,
@@ -879,6 +908,7 @@ function useScrollToCommentOnLoadEffect(shouldScrollOnLoad, state) {
 }
 
 // src/room.tsx
+var SMOOTH_DELAY = 1e3;
 var noop2 = () => {
 };
 var identity = (x) => x;
@@ -1167,6 +1197,8 @@ function makeRoomContextBundle(client) {
     useCreateThread,
     useDeleteThread,
     useEditThreadMetadata,
+    useMarkThreadAsResolved,
+    useMarkThreadAsUnresolved,
     useCreateComment,
     useEditComment,
     useDeleteComment,
@@ -1208,6 +1240,8 @@ function makeRoomContextBundle(client) {
       useCreateThread,
       useDeleteThread,
       useEditThreadMetadata,
+      useMarkThreadAsResolved,
+      useMarkThreadAsUnresolved,
       useCreateComment,
       useEditComment,
       useDeleteComment,
@@ -1308,6 +1342,7 @@ function RoomProviderInner(props) {
       switch (message.type) {
         case ServerMsgCode.COMMENT_EDITED:
         case ServerMsgCode.THREAD_METADATA_UPDATED:
+        case ServerMsgCode.THREAD_UPDATED:
         case ServerMsgCode.COMMENT_REACTION_ADDED:
         case ServerMsgCode.COMMENT_REACTION_REMOVED:
         case ServerMsgCode.COMMENT_DELETED:
@@ -1366,13 +1401,42 @@ function useStatus() {
   const getServerSnapshot = room.getStatus;
   return useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot);
 }
-function useStorageStatus() {
+function useStorageStatus(options) {
+  const smooth = useInitial(options?.smooth ?? false);
+  if (smooth) {
+    return useStorageStatusSmooth();
+  } else {
+    return useStorageStatusImmediate();
+  }
+}
+function useStorageStatusImmediate() {
   const room = useRoom();
   const subscribe = room.events.storageStatus.subscribe;
   const getSnapshot = room.getStorageStatus;
   const getServerSnapshot = room.getStorageStatus;
   return useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot);
 }
+function useStorageStatusSmooth() {
+  const room = useRoom();
+  const [status, setStatus] = React4.useState(room.getStorageStatus);
+  const oldStatus = useLatest(room.getStorageStatus());
+  React4.useEffect(() => {
+    let timeoutId;
+    const unsub = room.events.storageStatus.subscribe((newStatus) => {
+      if (oldStatus.current === "synchronizing" && newStatus === "synchronized") {
+        timeoutId = setTimeout(() => setStatus(newStatus), SMOOTH_DELAY);
+      } else {
+        clearTimeout(timeoutId);
+        setStatus(newStatus);
+      }
+    });
+    return () => {
+      clearTimeout(timeoutId);
+      unsub();
+    };
+  }, [room, oldStatus]);
+  return status;
+}
 function useBatch() {
   return useRoom().batch;
 }
@@ -1502,7 +1566,7 @@ function useOthersMapped(itemSelector, itemIsEqual) {
   return useOthers(wrappedSelector, wrappedIsEqual);
 }
 function useOthersConnectionIds() {
-  return useOthers(selectorFor_useOthersConnectionIds, shallow);
+  return useOthers(selectorFor_useOthersConnectionIds, shallow2);
 }
 var NOT_FOUND = Symbol();
 function useOther(connectionId, selector, isEqual) {
@@ -1667,7 +1731,8 @@ function useCreateThread() {
         updatedAt: createdAt,
         roomId: room.id,
         metadata,
-        comments: [newComment]
+        comments: [newComment],
+        resolved: false
       };
       const optimisticUpdateId = nanoid3();
       const { store, onMutationFailure } = getExtrasForClient2(client);
@@ -2212,6 +2277,138 @@ function useMarkThreadAsRead() {
     [client, room]
   );
 }
+function useMarkThreadAsResolved() {
+  const client = useClient();
+  const room = useRoom();
+  return React4.useCallback(
+    (threadId) => {
+      const optimisticUpdateId = nanoid3();
+      const updatedAt = /* @__PURE__ */ new Date();
+      const { store, onMutationFailure } = getExtrasForClient2(client);
+      store.pushOptimisticUpdate({
+        type: "mark-thread-as-resolved",
+        id: optimisticUpdateId,
+        threadId,
+        updatedAt
+      });
+      const commentsAPI = room[kInternal2].comments;
+      commentsAPI.markThreadAsResolved({ threadId }).then(
+        () => {
+          store.set((state) => {
+            const existingThread = state.threads[threadId];
+            const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+              (update) => update.id !== optimisticUpdateId
+            );
+            if (existingThread === void 0) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            if (existingThread.deletedAt !== void 0) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            if (existingThread.updatedAt && existingThread.updatedAt > updatedAt) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            return {
+              ...state,
+              threads: {
+                ...state.threads,
+                [threadId]: {
+                  ...existingThread,
+                  resolved: true
+                }
+              },
+              optimisticUpdates: updatedOptimisticUpdates
+            };
+          });
+        },
+        (err) => onMutationFailure(
+          err,
+          optimisticUpdateId,
+          (error) => new MarkThreadAsResolvedError(error, {
+            roomId: room.id,
+            threadId
+          })
+        )
+      );
+    },
+    [client, room]
+  );
+}
+function useMarkThreadAsUnresolved() {
+  const client = useClient();
+  const room = useRoom();
+  return React4.useCallback(
+    (threadId) => {
+      const optimisticUpdateId = nanoid3();
+      const updatedAt = /* @__PURE__ */ new Date();
+      const { store, onMutationFailure } = getExtrasForClient2(client);
+      store.pushOptimisticUpdate({
+        type: "mark-thread-as-unresolved",
+        id: optimisticUpdateId,
+        threadId,
+        updatedAt
+      });
+      const commentsAPI = room[kInternal2].comments;
+      commentsAPI.markThreadAsUnresolved({ threadId }).then(
+        () => {
+          store.set((state) => {
+            const existingThread = state.threads[threadId];
+            const updatedOptimisticUpdates = state.optimisticUpdates.filter(
+              (update) => update.id !== optimisticUpdateId
+            );
+            if (existingThread === void 0) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            if (existingThread.deletedAt !== void 0) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            if (existingThread.updatedAt && existingThread.updatedAt > updatedAt) {
+              return {
+                ...state,
+                optimisticUpdates: updatedOptimisticUpdates
+              };
+            }
+            return {
+              ...state,
+              threads: {
+                ...state.threads,
+                [threadId]: {
+                  ...existingThread,
+                  resolved: false
+                }
+              },
+              optimisticUpdates: updatedOptimisticUpdates
+            };
+          });
+        },
+        (err) => onMutationFailure(
+          err,
+          optimisticUpdateId,
+          (error) => new MarkThreadAsUnresolvedError(error, {
+            roomId: room.id,
+            threadId
+          })
+        )
+      );
+    },
+    [client, room]
+  );
+}
 function useThreadSubscription(threadId) {
   const client = useClient();
   const { store } = getExtrasForClient2(client);
@@ -2363,13 +2560,9 @@ function useStorageSuspense(selector, isEqual) {
     isEqual
   );
 }
-function useStorageStatusSuspense() {
+function useStorageStatusSuspense(options) {
   useSuspendUntilStorageReady();
-  const room = useRoom();
-  const subscribe = room.events.storageStatus.subscribe;
-  const getSnapshot = room.getStorageStatus;
-  const getServerSnapshot = room.getStorageStatus;
-  return useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot);
+  return useStorageStatus(options);
 }
 function useThreadsSuspense(options = {
   query: { metadata: {} }
@@ -2527,6 +2720,8 @@ export {
   useDeleteComment,
   useRemoveReaction,
   useMarkThreadAsRead,
+  useMarkThreadAsResolved,
+  useMarkThreadAsUnresolved,
   useThreadSubscription,
   useRoomNotificationSettings,
   useUpdateRoomNotificationSettings,
@@ -2559,4 +2754,4 @@ export {
   _useStorageRoot,
   _useUpdateMyPresence
 };
-//# sourceMappingURL=chunk-PAHCU5NM.mjs.map
+//# sourceMappingURL=chunk-BIKCNKTX.mjs.map