@liveblocks/react 1.2.2-comments1 → 1.2.2-comments3

package/dist/index.mjs

@@ -1,11 +1,9 @@
-"use client";
-
 // src/index.ts
 import { detectDupes } from "@liveblocks/core";
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/react";
-var PKG_VERSION = "1.2.2-comments1";
+var PKG_VERSION = "1.2.2-comments3";
 var PKG_FORMAT = "esm";
 
 // src/ClientSideSuspense.tsx
@@ -22,491 +20,14 @@ function ClientSideSuspense(props) {
 import { shallow } from "@liveblocks/client";
 import {
   asArrayWithLegacyMethods,
-  createAsyncCache,
   deprecateIf,
-  errorIf,
-  makeEventSource as makeEventSource2
+  errorIf
 } from "@liveblocks/core";
 import * as React2 from "react";
 import { useSyncExternalStoreWithSelector } from "use-sync-external-store/shim/with-selector.js";
 
-// src/comments/CommentsRoom.ts
-import { makePoller } from "@liveblocks/core";
-
-// ../../node_modules/nanoid/index.js
-import crypto from "crypto";
-
-// ../../node_modules/nanoid/url-alphabet/index.js
-var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-
-// ../../node_modules/nanoid/index.js
-var POOL_SIZE_MULTIPLIER = 128;
-var pool;
-var poolOffset;
-var fillPool = (bytes) => {
-  if (!pool || pool.length < bytes) {
-    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
-    crypto.randomFillSync(pool);
-    poolOffset = 0;
-  } else if (poolOffset + bytes > pool.length) {
-    crypto.randomFillSync(pool);
-    poolOffset = 0;
-  }
-  poolOffset += bytes;
-};
-var nanoid = (size = 21) => {
-  fillPool(size -= 0);
-  let id = "";
-  for (let i = poolOffset - size; i < poolOffset; i++) {
-    id += urlAlphabet[pool[i] & 63];
-  }
-  return id;
-};
-
-// src/comments/CommentsRoom.ts
-import { useSyncExternalStore } from "use-sync-external-store/shim/index.js";
-
-// src/comments/errors.ts
-var CreateThreadError = class extends Error {
-  constructor(cause, context) {
-    super("Create thread failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "CreateThreadError";
-  }
-};
-var EditThreadMetadataError = class extends Error {
-  constructor(cause, context) {
-    super("Edit thread metadata failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "EditThreadMetadataError";
-  }
-};
-var CreateCommentError = class extends Error {
-  constructor(cause, context) {
-    super("Create comment failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "CreateCommentError";
-  }
-};
-var EditCommentError = class extends Error {
-  constructor(cause, context) {
-    super("Edit comment failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "EditCommentError";
-  }
-};
-var DeleteCommentError = class extends Error {
-  constructor(cause, context) {
-    super("Delete comment failed.");
-    this.cause = cause;
-    this.context = context;
-    this.name = "DeleteCommentError";
-  }
-};
-
-// src/comments/lib/store.ts
-import { makeEventSource } from "@liveblocks/core";
-function createStore(initialState) {
-  let state = initialState;
-  const eventSource = makeEventSource();
-  return {
-    get() {
-      return state;
-    },
-    set(newState) {
-      state = newState;
-      eventSource.notify(state);
-    },
-    subscribe(callback) {
-      return eventSource.subscribe(callback);
-    },
-    subscribeOnce(callback) {
-      return eventSource.subscribeOnce(callback);
-    },
-    subscribersCount() {
-      return eventSource.count();
-    },
-    destroy() {
-      return eventSource.clear();
-    }
-  };
-}
-
-// 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()}`;
-}
-function createCommentsRoom(room, errorEventSource) {
-  const store = createStore({
-    isLoading: true
-  });
-  let numberOfMutations = 0;
-  function endMutation() {
-    numberOfMutations--;
-    if (numberOfMutations === 0) {
-      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: makePoller(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) {
-      setThreads(await room.getThreads());
-    }
-    pollingHub.threads.resume();
-  }
-  function subscribe() {
-    if (!unsubscribeRealtimeEvents) {
-      unsubscribeRealtimeEvents = room.events.comments.subscribe(() => {
-        pollingHub.threads.restart(getPollingInterval());
-        revalidateThreads();
-      });
-    }
-    if (!unsubscribeRealtimeConnection) {
-      unsubscribeRealtimeConnection = room.events.status.subscribe((status) => {
-        const nextRealtimeClientConnected = status === "connected";
-        if (nextRealtimeClientConnected !== realtimeClientConnected) {
-          realtimeClientConnected = nextRealtimeClientConnected;
-          pollingHub.threads.restart(getPollingInterval());
-        }
-      });
-    }
-    pollingHub.threads.start(getPollingInterval());
-    revalidateThreads();
-    return () => {
-      pollingHub.threads.stop();
-      unsubscribeRealtimeEvents?.();
-      unsubscribeRealtimeEvents = void 0;
-      unsubscribeRealtimeConnection?.();
-      unsubscribeRealtimeConnection = void 0;
-    };
-  }
-  function setThreads(newThreads) {
-    store.set({
-      threads: newThreads,
-      isLoading: false
-    });
-  }
-  function getCurrentUserId() {
-    const self = room.getSelf();
-    if (self === null || self.id === void 0) {
-      return "anonymous";
-    } else {
-      return self.id;
-    }
-  }
-  function createThread(options) {
-    const body = options.body;
-    const metadata = "metadata" in options ? options.metadata : {};
-    const threads = ensureThreadsAreLoadedForMutations();
-    const threadId = createOptimisticId(THREAD_ID_PREFIX);
-    const commentId = createOptimisticId(COMMENT_ID_PREFIX);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const newThread = {
-      id: threadId,
-      type: "thread",
-      createdAt: now,
-      roomId: room.id,
-      metadata,
-      comments: [
-        {
-          id: commentId,
-          createdAt: now,
-          type: "comment",
-          userId: getCurrentUserId(),
-          body
-        }
-      ]
-    };
-    setThreads([...threads, newThread]);
-    startMutation();
-    room.createThread({ threadId, commentId, body, metadata }).catch(
-      (er) => errorEventSource.notify(
-        new CreateThreadError(er, {
-          roomId: room.id,
-          threadId,
-          commentId,
-          body,
-          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);
-  }
-  function createComment({
-    threadId,
-    body
-  }) {
-    const threads = ensureThreadsAreLoadedForMutations();
-    const commentId = createOptimisticId(COMMENT_ID_PREFIX);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const comment = {
-      id: commentId,
-      threadId,
-      roomId: room.id,
-      type: "comment",
-      createdAt: now,
-      userId: getCurrentUserId(),
-      mentionedIds: [],
-      body
-    };
-    setThreads(
-      threads.map(
-        (thread) => thread.id === threadId ? {
-          ...thread,
-          comments: [...thread.comments, comment]
-        } : thread
-      )
-    );
-    startMutation();
-    room.createComment({ threadId, commentId, body }).catch(
-      (er) => errorEventSource.notify(
-        new CreateCommentError(er, {
-          roomId: room.id,
-          threadId,
-          commentId,
-          body
-        })
-      )
-    ).finally(endMutation);
-    return comment;
-  }
-  function editComment({ threadId, commentId, body }) {
-    const threads = ensureThreadsAreLoadedForMutations();
-    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
-      )
-    );
-    startMutation();
-    room.editComment({ threadId, commentId, body }).catch(
-      (er) => errorEventSource.notify(
-        new EditCommentError(er, {
-          roomId: room.id,
-          threadId,
-          commentId,
-          body
-        })
-      )
-    ).finally(endMutation);
-  }
-  function deleteComment({ threadId, commentId }) {
-    const threads = ensureThreadsAreLoadedForMutations();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const newThreads = [];
-    for (const thread of threads) {
-      if (thread.id === threadId) {
-        const newThread = {
-          ...thread,
-          comments: thread.comments.map(
-            (comment) => comment.id === commentId ? {
-              ...comment,
-              deletedAt: now,
-              body: void 0,
-              mentionedIds: []
-            } : comment
-          )
-        };
-        if (newThread.comments.some((comment) => comment.deletedAt === void 0)) {
-          newThreads.push(newThread);
-        }
-      } else {
-        newThreads.push(thread);
-      }
-    }
-    setThreads(newThreads);
-    startMutation();
-    room.deleteComment({ threadId, commentId }).catch(
-      (er) => errorEventSource.notify(
-        new DeleteCommentError(er, {
-          roomId: room.id,
-          threadId,
-          commentId
-        })
-      )
-    ).finally(endMutation);
-  }
-  function useThreads() {
-    return useSyncExternalStore(
-      store.subscribe,
-      store.get,
-      store.get
-    );
-  }
-  function useThreadsSuspense() {
-    const result = useThreads();
-    if (result.isLoading) {
-      throw new Promise(store.subscribeOnce);
-    }
-    if (result.error) {
-      throw result.error;
-    }
-    return result.threads;
-  }
-  return {
-    useThreads,
-    useThreadsSuspense,
-    createThread,
-    editThreadMetadata,
-    createComment,
-    editComment,
-    deleteComment,
-    subscribe
-  };
-}
-
-// src/comments/lib/use-async-cache.ts
-import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2 } from "react";
-import { useSyncExternalStore as useSyncExternalStore2 } from "use-sync-external-store/shim/index.js";
-
-// src/comments/lib/use-initial.ts
-import { useRef } from "react";
-function useInitial(value) {
-  return useRef(value instanceof Function ? value() : value).current;
-}
-
-// src/comments/lib/use-async-cache.ts
-var INITIAL_ASYNC_STATE = {
-  isLoading: false,
-  data: void 0,
-  error: void 0
-};
-var noop = () => {
-};
-function useAsyncCache(cache, key, options) {
-  const frozenOptions = useInitial(options);
-  const cacheItem = useMemo(() => {
-    if (key === null || !cache) {
-      return null;
-    }
-    const cacheItem2 = cache.create(key, frozenOptions?.overrideFunction);
-    void cacheItem2.get();
-    return cacheItem2;
-  }, [cache, frozenOptions, key]);
-  const subscribe = useCallback(
-    (callback) => cacheItem?.subscribe(callback) ?? noop,
-    [cacheItem]
-  );
-  const getState = useCallback(
-    () => cacheItem?.getState() ?? INITIAL_ASYNC_STATE,
-    [cacheItem]
-  );
-  const revalidate = useCallback(() => cacheItem?.revalidate(), [cacheItem]);
-  const state = useSyncExternalStore2(subscribe, getState, getState);
-  const previousData = useRef2();
-  let data = state.data;
-  useEffect2(() => {
-    previousData.current = { key, data: state.data };
-  }, [key, state]);
-  if (frozenOptions?.suspense && state.isLoading && cacheItem) {
-    throw new Promise((resolve) => {
-      cacheItem.subscribeOnce(() => resolve());
-    });
-  }
-  if (state.isLoading && frozenOptions?.keepPreviousDataWhileLoading && typeof state.data === "undefined" && previousData.current?.key !== key && typeof previousData.current?.data !== "undefined") {
-    data = previousData.current.data;
-  }
-  return {
-    isLoading: state.isLoading,
-    data,
-    error: state.error,
-    getState,
-    revalidate
-  };
-}
-
-// src/comments/lib/use-debounce.ts
-import { useEffect as useEffect3, useRef as useRef3, useState as useState2 } from "react";
-var DEFAULT_DELAY = 500;
-function useDebounce(value, delay = DEFAULT_DELAY) {
-  const timeout = useRef3();
-  const [debouncedValue, setDebouncedValue] = useState2(value);
-  useEffect3(() => {
-    if (delay === false) {
-      return;
-    }
-    if (timeout.current === void 0) {
-      setDebouncedValue(value);
-    }
-    timeout.current = window.setTimeout(() => {
-      setDebouncedValue(value);
-      timeout.current = void 0;
-    }, delay);
-    return () => {
-      window.clearTimeout(timeout.current);
-    };
-  }, [value, delay]);
-  return debouncedValue;
-}
-
 // src/hooks.ts
-import { useReducer, useRef as useRef4 } from "react";
+import { useReducer, useRef } from "react";
 function useRerender() {
   const [, update] = useReducer(
     // This implementation works by incrementing a hidden counter value that is
@@ -517,12 +38,12 @@ function useRerender() {
   );
   return update;
 }
-function useInitial2(value) {
-  return useRef4(value).current;
+function useInitial(value) {
+  return useRef(value).current;
 }
 
 // src/factory.tsx
-var noop2 = () => {
+var noop = () => {
 };
 var identity = (x) => x;
 var missing_unstable_batchedUpdates = (reactVersion, roomId) => `We noticed you\u2019re using React ${reactVersion}. Please pass unstable_batchedUpdates at the RoomProvider level until you\u2019re ready to upgrade to React 18:
@@ -537,7 +58,7 @@ var missing_unstable_batchedUpdates = (reactVersion, roomId) => `We noticed you\
 
 Why? Please see https://liveblocks.io/docs/guides/troubleshooting#stale-props-zombie-child for more information`;
 var superfluous_unstable_batchedUpdates = "You don\u2019t need to pass unstable_batchedUpdates to RoomProvider anymore, since you\u2019re on React 18+ already.";
-function useSyncExternalStore3(s, gs, gss) {
+function useSyncExternalStore(s, gs, gss) {
   return useSyncExternalStoreWithSelector(s, gs, gss, identity);
 }
 var EMPTY_OTHERS = (
@@ -574,27 +95,7 @@ function makeMutationContext(room) {
     setMyPresence: room.updatePresence
   };
 }
-var hasWarnedIfNoResolveUser = false;
-var hasWarnedIfNoResolveMentionSuggestions = false;
-function warnIfNoResolveUser(usersCache) {
-  if (!hasWarnedIfNoResolveUser && !usersCache && process.env.NODE_ENV !== "production") {
-    console.warn("The resolveUser option wasn't set in createRoomContext.");
-    hasWarnedIfNoResolveUser = true;
-  }
-}
-function warnIfNoResolveMentionSuggestions(mentionSuggestionsCache) {
-  if (!hasWarnedIfNoResolveMentionSuggestions && !mentionSuggestionsCache && process.env.NODE_ENV !== "production") {
-    console.warn(
-      "The resolveMentionSuggestions option wasn't set in createRoomContext."
-    );
-    hasWarnedIfNoResolveMentionSuggestions = true;
-  }
-}
-var ContextBundle = React2.createContext(null);
-function useRoomContextBundle() {
-  return React2.useContext(ContextBundle);
-}
-function createRoomContext(client, options) {
+function createRoomContext(client) {
   const RoomContext = React2.createContext(null);
   function RoomProvider(props) {
     const {
@@ -624,7 +125,7 @@ function createRoomContext(client, options) {
         superfluous_unstable_batchedUpdates
       );
     }
-    const frozen = useInitial2({
+    const frozen = useInitial({
       initialPresence,
       initialStorage,
       unstable_batchedUpdates,
@@ -639,24 +140,19 @@ function createRoomContext(client, options) {
       })
     );
     React2.useEffect(() => {
-      const room2 = client.enter(
-        roomId,
-        {
+      setRoom(
+        client.enter(roomId, {
           initialPresence: frozen.initialPresence,
           initialStorage: frozen.initialStorage,
           shouldInitiallyConnect: frozen.shouldInitiallyConnect,
           unstable_batchedUpdates: frozen.unstable_batchedUpdates
-        }
+        })
       );
-      setRoom(room2);
-      const unsubscribe = getCommentsRoom(room2).subscribe();
       return () => {
-        unsubscribe();
-        commentsRooms.delete(room2.id);
         client.leave(roomId);
       };
     }, [roomId, frozen]);
-    return /* @__PURE__ */ React2.createElement(RoomContext.Provider, { value: room }, /* @__PURE__ */ React2.createElement(ContextBundle.Provider, { value: bundle }, props.children));
+    return /* @__PURE__ */ React2.createElement(RoomContext.Provider, { value: room }, props.children);
   }
   function connectionIdSelector(others) {
     return others.map((user) => user.connectionId);
@@ -664,7 +160,7 @@ function createRoomContext(client, options) {
   function useRoom() {
     const room = React2.useContext(RoomContext);
     if (room === null) {
-      throw new Error("RoomProvider is missing from the React tree.");
+      throw new Error("RoomProvider is missing from the react tree");
     }
     return room;
   }
@@ -672,13 +168,13 @@ function createRoomContext(client, options) {
     const room = useRoom();
     const subscribe = room.events.status.subscribe;
     const getSnapshot = room.getStatus;
-    return useSyncExternalStore3(subscribe, getSnapshot, getSnapshot);
+    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
   }
   function useMyPresence() {
     const room = useRoom();
     const subscribe = room.events.myPresence.subscribe;
     const getSnapshot = room.getPresence;
-    const presence = useSyncExternalStore3(subscribe, getSnapshot, getSnapshot);
+    const presence = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
     const setPresence = room.updatePresence;
     return [presence, setPresence];
   }
@@ -752,8 +248,8 @@ function createRoomContext(client, options) {
   function useBroadcastEvent() {
     const room = useRoom();
     return React2.useCallback(
-      (event, options2 = { shouldQueueEventIfNotReady: false }) => {
-        room.broadcastEvent(event, options2);
+      (event, options = { shouldQueueEventIfNotReady: false }) => {
+        room.broadcastEvent(event, options);
       },
       [room]
     );
@@ -818,7 +314,7 @@ function createRoomContext(client, options) {
     const subscribe = room.events.storageDidLoad.subscribeOnce;
     const getSnapshot = room.getStorageSnapshot;
     const getServerSnapshot = React2.useCallback(() => null, []);
-    return useSyncExternalStore3(subscribe, getSnapshot, getServerSnapshot);
+    return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
   }
   function useStorageRoot() {
     return [useMutableStorageRoot()];
@@ -836,13 +332,13 @@ function createRoomContext(client, options) {
     const room = useRoom();
     const subscribe = room.events.history.subscribe;
     const canUndo = room.history.canUndo;
-    return useSyncExternalStore3(subscribe, canUndo, canUndo);
+    return useSyncExternalStore(subscribe, canUndo, canUndo);
   }
   function useCanRedo() {
     const room = useRoom();
     const subscribe = room.events.history.subscribe;
     const canRedo = room.history.canRedo;
-    return useSyncExternalStore3(subscribe, canRedo, canRedo);
+    return useSyncExternalStore(subscribe, canRedo, canRedo);
   }
   function useBatch() {
     return useRoom().batch;
@@ -899,7 +395,7 @@ function createRoomContext(client, options) {
       [selector]
     );
     const subscribe = React2.useCallback(
-      (onStoreChange) => rootOrNull !== null ? room.subscribe(rootOrNull, onStoreChange, { isDeep: true }) : noop2,
+      (onStoreChange) => rootOrNull !== null ? room.subscribe(rootOrNull, onStoreChange, { isDeep: true }) : noop,
       [room, rootOrNull]
     );
     const getSnapshot = React2.useCallback(() => {
@@ -1005,106 +501,7 @@ function createRoomContext(client, options) {
     useSuspendUntilStorageLoaded();
     return useLegacyKey(key);
   }
-  const errorEventSource = makeEventSource2();
-  const commentsRooms = /* @__PURE__ */ new Map();
-  function getCommentsRoom(room) {
-    let commentsRoom = commentsRooms.get(room.id);
-    if (commentsRoom === void 0) {
-      commentsRoom = createCommentsRoom(room, errorEventSource);
-      commentsRooms.set(room.id, commentsRoom);
-    }
-    return commentsRoom;
-  }
-  function useThreads() {
-    const room = useRoom();
-    return getCommentsRoom(room).useThreads();
-  }
-  function useThreadsSuspense() {
-    const room = useRoom();
-    return getCommentsRoom(room).useThreadsSuspense();
-  }
-  function useCreateThread() {
-    const room = useRoom();
-    return React2.useCallback(
-      (options2) => getCommentsRoom(room).createThread(options2),
-      [room]
-    );
-  }
-  function useEditThreadMetadata() {
-    const room = useRoom();
-    return React2.useCallback(
-      (options2) => getCommentsRoom(room).editThreadMetadata(options2),
-      [room]
-    );
-  }
-  function useCreateComment() {
-    const room = useRoom();
-    return React2.useCallback(
-      (options2) => getCommentsRoom(room).createComment(options2),
-      [room]
-    );
-  }
-  function useEditComment() {
-    const room = useRoom();
-    return React2.useCallback(
-      (options2) => getCommentsRoom(room).editComment(options2),
-      [room]
-    );
-  }
-  function useDeleteComment() {
-    const room = useRoom();
-    return React2.useCallback(
-      (options2) => getCommentsRoom(room).deleteComment(options2),
-      [room]
-    );
-  }
-  const { resolveUser, resolveMentionSuggestions } = options ?? {};
-  const usersCache = resolveUser ? createAsyncCache(resolveUser) : void 0;
-  function useUser(userId) {
-    const state = useAsyncCache(usersCache, userId);
-    React2.useEffect(() => warnIfNoResolveUser(usersCache), []);
-    if (state.isLoading) {
-      return {
-        isLoading: true
-      };
-    } else {
-      return {
-        user: state.data,
-        error: state.error,
-        isLoading: false
-      };
-    }
-  }
-  function useUserSuspense(userId) {
-    const state = useAsyncCache(usersCache, userId, {
-      suspense: true
-    });
-    React2.useEffect(() => warnIfNoResolveUser(usersCache), []);
-    return {
-      user: state.data,
-      error: state.error,
-      isLoading: false
-    };
-  }
-  const mentionSuggestionsCache = createAsyncCache(
-    resolveMentionSuggestions ?? (() => Promise.resolve([]))
-  );
-  function useMentionSuggestions(search) {
-    const debouncedSearch = useDebounce(search, 500);
-    const { data } = useAsyncCache(
-      mentionSuggestionsCache,
-      debouncedSearch ?? null,
-      {
-        keepPreviousDataWhileLoading: true
-      }
-    );
-    React2.useEffect(
-      () => warnIfNoResolveMentionSuggestions(mentionSuggestionsCache),
-      []
-    );
-    return data;
-  }
-  const bundle = {
+  return {
     RoomContext,
     RoomProvider,
     useRoom,
@@ -1133,14 +530,6 @@ function createRoomContext(client, options) {
     useOthersConnectionIds,
     useOther,
     useMutation,
-    useThreads,
-    useUser,
-    useCreateThread,
-    useEditThreadMetadata,
-    useCreateComment,
-    useEditComment,
-    useDeleteComment,
-    useMentionSuggestions,
     suspense: {
       RoomContext,
       RoomProvider,
@@ -1169,17 +558,9 @@ function createRoomContext(client, options) {
       useOthersMapped: useOthersMappedSuspense,
       useOthersConnectionIds: useOthersConnectionIdsSuspense,
       useOther: useOtherSuspense,
-      useMutation,
-      useThreads: useThreadsSuspense,
-      useUser: useUserSuspense,
-      useCreateThread,
-      useEditThreadMetadata,
-      useCreateComment,
-      useEditComment,
-      useDeleteComment
+      useMutation
     }
   };
-  return bundle;
 }
 
 // src/index.ts
@@ -1188,7 +569,6 @@ detectDupes(PKG_NAME, PKG_VERSION, PKG_FORMAT);
 export {
   ClientSideSuspense,
   createRoomContext,
-  shallow2 as shallow,
-  useRoomContextBundle
+  shallow2 as shallow
 };
 //# sourceMappingURL=index.mjs.map