@liveblocks/react 1.4.5 → 1.4.6-test1

package/dist/index.mjs

@@ -5,7 +5,7 @@ import { detectDupes } from "@liveblocks/core";
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/react";
-var PKG_VERSION = "1.4.5";
+var PKG_VERSION = "1.4.6-test1";
 var PKG_FORMAT = "esm";
 
 // src/ClientSideSuspense.tsx
@@ -25,7 +25,8 @@ import {
   deprecateIf,
   errorIf,
   isLiveNode,
-  makeEventSource as makeEventSource2
+  makeEventSource as makeEventSource2,
+  stringify
 } from "@liveblocks/core";
 import * as React2 from "react";
 import { useSyncExternalStoreWithSelector } from "use-sync-external-store/shim/with-selector.js";
@@ -626,18 +627,6 @@ function useDebounce(value, delay = DEFAULT_DELAY) {
   return debouncedValue;
 }
 
-// src/lib/stable-stringify.ts
-function stableStringify(object, ...args) {
-  const sortedObject = Object.keys(object).sort().reduce(
-    (sortedObject2, key) => {
-      sortedObject2[key] = object[key];
-      return sortedObject2;
-    },
-    {}
-  );
-  return JSON.stringify(sortedObject, ...args);
-}
-
 // src/lib/use-async-cache.ts
 import { useCallback, useEffect as useEffect4, useMemo, useRef as useRef3 } from "react";
 import { useSyncExternalStore as useSyncExternalStore2 } from "use-sync-external-store/shim/index.js";
@@ -662,10 +651,10 @@ function useAsyncCache(cache, key, options) {
     if (key === null || !cache) {
       return null;
     }
-    const cacheItem2 = cache.create(key, frozenOptions?.overrideFunction);
+    const cacheItem2 = cache.create(key);
     void cacheItem2.get();
     return cacheItem2;
-  }, [cache, frozenOptions, key]);
+  }, [cache, key]);
   const subscribe = useCallback(
     (callback) => cacheItem?.subscribe(callback) ?? noop,
     [cacheItem]
@@ -680,18 +669,33 @@ function useAsyncCache(cache, key, options) {
   let data = state.data;
   useEffect4(() => {
     previousData.current = { key, data: state.data };
-  }, [key, state]);
-  if (frozenOptions?.suspense && state.isLoading && cacheItem) {
-    throw new Promise((resolve) => {
-      cacheItem.subscribeOnce(() => resolve());
-    });
+  }, [key, state.data]);
+  if (!cacheItem) {
+    return {
+      isLoading: false,
+      data: void 0,
+      error: void 0,
+      getState,
+      revalidate
+    };
+  }
+  if (frozenOptions?.suspense) {
+    const error = getState().error;
+    if (error) {
+      throw error;
+    } else if (getState().isLoading) {
+      throw new Promise((resolve) => {
+        cacheItem.subscribeOnce((state2) => {
+          if (!state2.isLoading) {
+            resolve();
+          }
+        });
+      });
+    }
   }
   if (state.isLoading && frozenOptions?.keepPreviousDataWhileLoading && typeof state.data === "undefined" && previousData.current?.key !== key && typeof previousData.current?.data !== "undefined") {
     data = previousData.current.data;
   }
-  if (frozenOptions?.suspense && state.error) {
-    throw state.error;
-  }
   return {
     isLoading: state.isLoading,
     data,
@@ -740,6 +744,9 @@ function alwaysEmptyList() {
 function alwaysNull() {
   return null;
 }
+function alwaysConnecting() {
+  return "connecting";
+}
 function makeMutationContext(room) {
   const errmsg = "This mutation cannot be used until connected to the Liveblocks room";
   return {
@@ -767,13 +774,13 @@ function makeMutationContext(room) {
     setMyPresence: room.updatePresence
   };
 }
-var hasWarnedIfNoResolveUser = false;
-function warnIfNoResolveUser(usersCache) {
-  if (!hasWarnedIfNoResolveUser && !usersCache && process.env.NODE_ENV !== "production") {
+var hasWarnedIfNoResolveUsers = false;
+function warnIfNoResolveUsers(usersCache) {
+  if (!hasWarnedIfNoResolveUsers && !usersCache && process.env.NODE_ENV !== "production") {
     console.warn(
-      "Set the resolveUser option in createRoomContext to specify user info."
+      "Set the resolveUsers option in createRoomContext to specify user info."
     );
-    hasWarnedIfNoResolveUser = true;
+    hasWarnedIfNoResolveUsers = true;
   }
 }
 var hasWarnedAboutCommentsBeta = false;
@@ -878,7 +885,8 @@ function createRoomContext(client, options) {
     const room = useRoom();
     const subscribe = room.events.status.subscribe;
     const getSnapshot = room.getStatus;
-    return useSyncExternalStore3(subscribe, getSnapshot, getSnapshot);
+    const getServerSnapshot = alwaysConnecting;
+    return useSyncExternalStore3(subscribe, getSnapshot, getServerSnapshot);
   }
   function useMyPresence() {
     const room = useRoom();
@@ -1143,6 +1151,7 @@ function createRoomContext(client, options) {
     }
     ensureNotServerSide();
     throw new Promise((res) => {
+      room.events.self.subscribeOnce(() => res());
       room.events.status.subscribeOnce(() => res());
     });
   }
@@ -1298,19 +1307,21 @@ function createRoomContext(client, options) {
       [room]
     );
   }
-  const { resolveUser, resolveMentionSuggestions } = options ?? {};
-  const usersCache = resolveUser ? createAsyncCache((stringifiedOptions) => {
-    return resolveUser(
+  const { resolveUsers, resolveMentionSuggestions } = options ?? {};
+  const usersCache = resolveUsers ? createAsyncCache(async (stringifiedOptions) => {
+    const users = await resolveUsers(
       JSON.parse(stringifiedOptions)
     );
+    return users?.[0];
   }) : void 0;
   function useUser(userId) {
+    const room = useRoom();
     const resolverKey = React2.useMemo(
-      () => stableStringify({ userId }),
-      [userId]
+      () => stringify({ userIds: [userId], roomId: room.id }),
+      [userId, room.id]
     );
     const state = useAsyncCache(usersCache, resolverKey);
-    React2.useEffect(() => warnIfNoResolveUser(usersCache), []);
+    React2.useEffect(() => warnIfNoResolveUsers(usersCache), []);
     if (state.isLoading) {
       return {
         isLoading: true
@@ -1324,14 +1335,15 @@ function createRoomContext(client, options) {
     }
   }
   function useUserSuspense(userId) {
+    const room = useRoom();
     const resolverKey = React2.useMemo(
-      () => stableStringify({ userId }),
-      [userId]
+      () => stringify({ userIds: [userId], roomId: room.id }),
+      [userId, room.id]
     );
     const state = useAsyncCache(usersCache, resolverKey, {
       suspense: true
     });
-    React2.useEffect(() => warnIfNoResolveUser(usersCache), []);
+    React2.useEffect(() => warnIfNoResolveUsers(usersCache), []);
     return {
       user: state.data,
       isLoading: false
@@ -1348,7 +1360,7 @@ function createRoomContext(client, options) {
     const room = useRoom();
     const debouncedSearch = useDebounce(search, 500);
     const resolverKey = React2.useMemo(
-      () => debouncedSearch !== void 0 ? stableStringify({ text: debouncedSearch, roomId: room.id }) : null,
+      () => debouncedSearch !== void 0 ? stringify({ text: debouncedSearch, roomId: room.id }) : null,
       [debouncedSearch, room.id]
     );
     const { data } = useAsyncCache(mentionSuggestionsCache, resolverKey, {