@poolse/react 0.1.0

package/dist/index.cjs

@@ -0,0 +1,695 @@
+'use client';
+'use strict';
+
+var sdk = require('@poolse/sdk');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/provider.tsx
+var PoolseContext = react.createContext(null);
+function PoolseProvider({ config, children }) {
+  const configRef = react.useRef(config);
+  configRef.current = config;
+  const initialConnectionRef = react.useRef(null);
+  const chat = react.useMemo(() => {
+    const initial = configRef.current;
+    initialConnectionRef.current = {
+      apiUrl: initial.apiUrl,
+      wsUrl: initial.wsUrl,
+      socketPath: initial.socketPath
+    };
+    return new sdk.Poolse({
+      apiUrl: initial.apiUrl,
+      // Always read the latest callbacks from the ref — they're free
+      // to change between renders.
+      getToken: () => configRef.current.getToken(),
+      ...initial.fetch ? { fetch: ((...args) => configRef.current.fetch(...args)) } : {},
+      ...initial.maxRetries !== void 0 ? { maxRetries: initial.maxRetries } : {},
+      ...initial.baseBackoffMs !== void 0 ? { baseBackoffMs: initial.baseBackoffMs } : {},
+      ...initial.maxBackoffMs !== void 0 ? { maxBackoffMs: initial.maxBackoffMs } : {},
+      ...initial.generateIdempotencyKey ? { generateIdempotencyKey: () => configRef.current.generateIdempotencyKey() } : {},
+      ...initial.wsUrl !== void 0 ? { wsUrl: initial.wsUrl } : {},
+      ...initial.socketPath !== void 0 ? { socketPath: initial.socketPath } : {},
+      ...initial.onSocketError ? { onSocketError: (err) => configRef.current.onSocketError(err) } : {}
+    });
+  }, []);
+  if (process.env.NODE_ENV !== "production") {
+    react.useEffect(() => {
+      const initial = initialConnectionRef.current;
+      if (!initial) return;
+      if (initial.apiUrl !== config.apiUrl || initial.wsUrl !== config.wsUrl || initial.socketPath !== config.socketPath) {
+        console.warn(
+          "[poolse] connection-shaped config (apiUrl / wsUrl / socketPath) changed after <PoolseProvider> mounted. These are captured at construction time \u2014 remount the provider with a new `key` to switch environments."
+        );
+      }
+    }, [config.apiUrl, config.wsUrl, config.socketPath]);
+  }
+  react.useEffect(() => {
+    return () => {
+      chat.destroy();
+    };
+  }, [chat]);
+  const value = react.useMemo(() => ({ chat }), [chat]);
+  return /* @__PURE__ */ jsxRuntime.jsx(PoolseContext.Provider, { value, children });
+}
+function usePoolse() {
+  const value = react.useContext(PoolseContext);
+  if (!value) {
+    throw new Error(
+      "usePoolse(): no <PoolseProvider> in the tree. Wrap your component with `<PoolseProvider config={{apiUrl, getToken}}>` first."
+    );
+  }
+  return value.chat;
+}
+function useMe() {
+  const chat = usePoolse();
+  const [state, setState] = react.useState({
+    me: null,
+    loading: true,
+    error: null
+  });
+  react.useEffect(() => {
+    let cancelled = false;
+    const controller = new AbortController();
+    chat.me.show(controller.signal).then((me) => {
+      if (!cancelled) setState({ me, loading: false, error: null });
+    }).catch((err) => {
+      if (!cancelled) {
+        setState({
+          me: null,
+          loading: false,
+          error: err instanceof Error ? err : new Error(String(err))
+        });
+      }
+    });
+    return () => {
+      cancelled = true;
+      controller.abort();
+    };
+  }, [chat]);
+  return state;
+}
+function useConversation(id) {
+  const chat = usePoolse();
+  const [conversation, setConversation] = react.useState(null);
+  const [loading, setLoading] = react.useState(id !== null);
+  const [error, setError] = react.useState(null);
+  const fetcher = react.useCallback(
+    async (signal) => {
+      if (id === null) return;
+      setLoading(true);
+      setError(null);
+      try {
+        const conv = await chat.conversations.one(id).show(signal);
+        setConversation(conv);
+      } catch (err) {
+        if (err?.name === "AbortError") return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [chat, id]
+  );
+  react.useEffect(() => {
+    if (id === null) {
+      setConversation(null);
+      setLoading(false);
+      setError(null);
+      return;
+    }
+    const controller = new AbortController();
+    void fetcher(controller.signal);
+    return () => controller.abort();
+  }, [fetcher, id]);
+  const refetch = react.useCallback(() => fetcher(), [fetcher]);
+  return { conversation, loading, error, refetch };
+}
+function useConversations() {
+  const chat = usePoolse();
+  const { me } = useMe();
+  const [conversations, setConversations] = react.useState([]);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const refetch = react.useCallback(async () => {
+    setLoading(true);
+    try {
+      const list = await chat.conversations.list();
+      setConversations(list.data);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [chat]);
+  const create = react.useCallback(
+    async (attrs) => {
+      const conv = await chat.conversations.create(attrs);
+      setConversations((prev) => prepend(prev, conv));
+      return conv;
+    },
+    [chat]
+  );
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  react.useEffect(() => {
+    if (!me) return;
+    const userChan = chat.realtime.user(me.id);
+    const off = userChan.onConversationCreated((conv) => {
+      setConversations((prev) => prepend(prev, conv));
+    });
+    return off;
+  }, [chat, me]);
+  return { conversations, loading, error, refetch, create };
+}
+function prepend(prev, conv) {
+  const idx = prev.findIndex((c) => c.id === conv.id);
+  if (idx === -1) return [conv, ...prev];
+  const next = prev.slice();
+  next[idx] = conv;
+  return next;
+}
+function useMembers(conversationId) {
+  const chat = usePoolse();
+  const [members, setMembers] = react.useState([]);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const membersRef = react.useRef([]);
+  membersRef.current = members;
+  const fetcher = react.useCallback(
+    async (signal) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const { data } = await chat.conversations.one(conversationId).listMembers(signal);
+        setMembers(data);
+      } catch (err) {
+        if (err?.name === "AbortError") return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [chat, conversationId]
+  );
+  react.useEffect(() => {
+    const controller = new AbortController();
+    void fetcher(controller.signal);
+    return () => controller.abort();
+  }, [fetcher]);
+  const refetch = react.useCallback(() => fetcher(), [fetcher]);
+  const addMembers = react.useCallback(
+    async (externalIds, opts = {}) => {
+      const addOpts = opts.role !== void 0 ? { role: opts.role } : {};
+      const { data } = await chat.conversations.one(conversationId).addMembers(externalIds, addOpts);
+      setMembers((prev) => {
+        const byId = new Map(prev.map((m) => [m.id, m]));
+        for (const m of data) byId.set(m.id, m);
+        return Array.from(byId.values());
+      });
+      return data;
+    },
+    [chat, conversationId]
+  );
+  const removeMember = react.useCallback(
+    async (userId) => {
+      const snapshot = membersRef.current;
+      setMembers((prev) => prev.filter((m) => m.user_id !== userId));
+      try {
+        await chat.conversations.one(conversationId).removeMember(userId);
+      } catch (err) {
+        setMembers(snapshot);
+        throw err;
+      }
+    },
+    [chat, conversationId]
+  );
+  return { members, loading, error, refetch, addMembers, removeMember };
+}
+var PAGE_SIZE = 50;
+function useMessages(conversationId) {
+  const chat = usePoolse();
+  const [messages, setMessages] = react.useState([]);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const [hasMore, setHasMore] = react.useState(true);
+  const oldestSequenceRef = react.useRef(null);
+  react.useEffect(() => {
+    let cancelled = false;
+    setLoading(true);
+    setMessages([]);
+    setError(null);
+    setHasMore(true);
+    oldestSequenceRef.current = null;
+    const handle = chat.conversations.one(conversationId).messages;
+    handle.list({ limit: PAGE_SIZE }).then((page) => {
+      if (cancelled) return;
+      const ordered = [...page.data].reverse();
+      setMessages(ordered);
+      setHasMore(page.data.length === PAGE_SIZE);
+      oldestSequenceRef.current = ordered[0]?.sequence ?? null;
+      setLoading(false);
+    }).catch((err) => {
+      if (cancelled) return;
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setLoading(false);
+    });
+    const conv = chat.realtime.conversation(conversationId);
+    const offNew = conv.onMessage((msg) => {
+      setMessages((prev) => upsertById(prev, msg));
+    });
+    const offUpdated = conv.onMessageUpdated((msg) => {
+      setMessages((prev) => prev.map((m) => m.id === msg.id ? msg : m));
+    });
+    const offDeleted = conv.onMessageDeleted((evt) => {
+      setMessages(
+        (prev) => prev.map((m) => m.id === evt.id ? { ...m, deleted_at: evt.deleted_at, body: null } : m)
+      );
+    });
+    return () => {
+      cancelled = true;
+      offNew();
+      offUpdated();
+      offDeleted();
+    };
+  }, [chat, conversationId]);
+  const loadMore = react.useCallback(async () => {
+    if (!hasMore || loading) return;
+    const before = oldestSequenceRef.current;
+    if (!before) return;
+    const opts = { limit: PAGE_SIZE };
+    if (before !== null) opts.before = before;
+    const page = await chat.conversations.one(conversationId).messages.list(opts);
+    if (page.data.length === 0) {
+      setHasMore(false);
+      return;
+    }
+    const older = [...page.data].reverse();
+    setMessages((prev) => [...older, ...prev]);
+    setHasMore(page.data.length === PAGE_SIZE);
+    oldestSequenceRef.current = older[0]?.sequence ?? oldestSequenceRef.current;
+  }, [chat, conversationId, hasMore, loading]);
+  const send = react.useCallback(
+    async (attrs) => {
+      const id = attrs.id ?? crypto.randomUUID();
+      const tempMsg = {
+        id,
+        tenant_id: "",
+        conversation_id: conversationId,
+        sender_id: null,
+        type: attrs.type ?? "text",
+        body: attrs.body,
+        reply_to_id: attrs.reply_to_id ?? null,
+        thread_root_id: null,
+        mentions: attrs.mentions ?? [],
+        reactions: {},
+        edited_at: null,
+        deleted_at: null,
+        // MAX_SAFE_INTEGER sorts the temp row to the very end (newest
+        // position) until the server returns the real `sequence`.
+        sequence: Number.MAX_SAFE_INTEGER,
+        inserted_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setMessages((prev) => [...prev, tempMsg]);
+      try {
+        const sent = await chat.conversations.one(conversationId).messages.send({ ...attrs, id });
+        setMessages((prev) => upsertById(prev, sent));
+        return sent;
+      } catch (err) {
+        setMessages((prev) => prev.filter((m) => m.id !== id));
+        throw err;
+      }
+    },
+    [chat, conversationId]
+  );
+  return { messages, loading, error, hasMore, loadMore, send };
+}
+function upsertById(prev, msg) {
+  const idx = prev.findIndex((m) => m.id === msg.id);
+  if (idx === -1) return [...prev, msg];
+  const next = prev.slice();
+  next[idx] = msg;
+  return next;
+}
+function useReactions(messageId, opts) {
+  const chat = usePoolse();
+  const [reactions, setReactions] = react.useState(opts.initialReactions ?? {});
+  const currentUserIdRef = react.useRef(opts.currentUserId ?? null);
+  currentUserIdRef.current = opts.currentUserId ?? null;
+  const reactionsRef = react.useRef(reactions);
+  reactionsRef.current = reactions;
+  react.useEffect(() => {
+    const conv = chat.realtime.conversation(opts.conversationId);
+    const offAdded = conv.onReactionAdded((evt) => {
+      if (evt.message_id !== messageId) return;
+      setReactions((prev) => addUser(prev, evt.emoji, evt.user_id));
+    });
+    const offRemoved = conv.onReactionRemoved((evt) => {
+      if (evt.message_id !== messageId) return;
+      setReactions((prev) => removeUser(prev, evt.emoji, evt.user_id));
+    });
+    return () => {
+      offAdded();
+      offRemoved();
+    };
+  }, [chat, opts.conversationId, messageId]);
+  const addReaction = react.useCallback(
+    async (emoji) => {
+      const uid = currentUserIdRef.current;
+      if (uid) setReactions((prev) => addUser(prev, emoji, uid));
+      try {
+        await chat.messages.one(messageId).addReaction(emoji);
+      } catch (err) {
+        if (uid) setReactions((prev) => removeUser(prev, emoji, uid));
+        throw err;
+      }
+    },
+    [chat, messageId]
+  );
+  const removeReaction = react.useCallback(
+    async (emoji) => {
+      const uid = currentUserIdRef.current;
+      const snapshot = reactionsRef.current;
+      if (uid) setReactions((prev) => removeUser(prev, emoji, uid));
+      try {
+        await chat.messages.one(messageId).removeReaction(emoji);
+      } catch (err) {
+        if (uid) setReactions(snapshot);
+        throw err;
+      }
+    },
+    [chat, messageId]
+  );
+  return { reactions, addReaction, removeReaction };
+}
+function addUser(prev, emoji, userId) {
+  const existing = prev[emoji] ?? [];
+  if (existing.includes(userId)) return prev;
+  return { ...prev, [emoji]: [...existing, userId] };
+}
+function removeUser(prev, emoji, userId) {
+  const existing = prev[emoji];
+  if (!existing || !existing.includes(userId)) return prev;
+  const next = existing.filter((id) => id !== userId);
+  if (next.length === 0) {
+    const { [emoji]: _, ...rest } = prev;
+    return rest;
+  }
+  return { ...prev, [emoji]: next };
+}
+var PAGE_SIZE2 = 50;
+function useThread(conversationId, rootMessageId) {
+  const chat = usePoolse();
+  const [replies, setReplies] = react.useState([]);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const [hasMore, setHasMore] = react.useState(true);
+  const newestSequenceRef = react.useRef(null);
+  react.useEffect(() => {
+    let cancelled = false;
+    setLoading(true);
+    setReplies([]);
+    setError(null);
+    setHasMore(true);
+    newestSequenceRef.current = null;
+    chat.messages.one(rootMessageId).replies({ limit: PAGE_SIZE2 }).then((page) => {
+      if (cancelled) return;
+      setReplies(page.data);
+      setHasMore(page.data.length === PAGE_SIZE2);
+      newestSequenceRef.current = page.data[page.data.length - 1]?.sequence ?? null;
+      setLoading(false);
+    }).catch((err) => {
+      if (cancelled) return;
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setLoading(false);
+    });
+    const conv = chat.realtime.conversation(conversationId);
+    const offNew = conv.onMessage((msg) => {
+      if (msg.thread_root_id !== rootMessageId) return;
+      setReplies((prev) => upsertById2(prev, msg));
+    });
+    const offUpdated = conv.onMessageUpdated((msg) => {
+      if (msg.thread_root_id !== rootMessageId) return;
+      setReplies((prev) => prev.map((m) => m.id === msg.id ? msg : m));
+    });
+    const offDeleted = conv.onMessageDeleted((evt) => {
+      setReplies(
+        (prev) => prev.map((m) => m.id === evt.id ? { ...m, deleted_at: evt.deleted_at, body: null } : m)
+      );
+    });
+    return () => {
+      cancelled = true;
+      offNew();
+      offUpdated();
+      offDeleted();
+    };
+  }, [chat, conversationId, rootMessageId]);
+  const loadMore = react.useCallback(async () => {
+    if (!hasMore || loading) return;
+    const after = newestSequenceRef.current;
+    if (after === null) return;
+    const page = await chat.messages.one(rootMessageId).replies({ limit: PAGE_SIZE2, after });
+    if (page.data.length === 0) {
+      setHasMore(false);
+      return;
+    }
+    setReplies((prev) => [...prev, ...page.data]);
+    setHasMore(page.data.length === PAGE_SIZE2);
+    newestSequenceRef.current = page.data[page.data.length - 1]?.sequence ?? after;
+  }, [chat, rootMessageId, hasMore, loading]);
+  const sendReply = react.useCallback(
+    async (attrs) => {
+      const id = attrs.id ?? crypto.randomUUID();
+      const tempMsg = {
+        id,
+        tenant_id: "",
+        conversation_id: conversationId,
+        sender_id: null,
+        type: attrs.type ?? "text",
+        body: attrs.body,
+        reply_to_id: rootMessageId,
+        thread_root_id: rootMessageId,
+        mentions: attrs.mentions ?? [],
+        reactions: {},
+        edited_at: null,
+        deleted_at: null,
+        sequence: Number.MAX_SAFE_INTEGER,
+        inserted_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setReplies((prev) => [...prev, tempMsg]);
+      try {
+        const sent = await chat.conversations.one(conversationId).messages.send({
+          ...attrs,
+          id,
+          reply_to_id: rootMessageId
+        });
+        setReplies((prev) => upsertById2(prev, sent));
+        return sent;
+      } catch (err) {
+        setReplies((prev) => prev.filter((m) => m.id !== id));
+        throw err;
+      }
+    },
+    [chat, conversationId, rootMessageId]
+  );
+  return { replies, loading, error, hasMore, loadMore, sendReply };
+}
+function upsertById2(prev, msg) {
+  const idx = prev.findIndex((m) => m.id === msg.id);
+  if (idx === -1) return [...prev, msg];
+  const next = prev.slice();
+  next[idx] = msg;
+  return next;
+}
+function useTyping(conversationId) {
+  const chat = usePoolse();
+  const { me } = useMe();
+  const [typing, setTyping] = react.useState(/* @__PURE__ */ new Set());
+  const lastPingRef = react.useRef(0);
+  const meIdRef = react.useRef(me?.id ?? null);
+  meIdRef.current = me?.id ?? null;
+  react.useEffect(() => {
+    setTyping(/* @__PURE__ */ new Set());
+    const conv = chat.realtime.conversation(conversationId);
+    const offStart = conv.onTypingStart((evt) => {
+      if (meIdRef.current && evt.user_id === meIdRef.current) return;
+      setTyping((prev) => {
+        if (prev.has(evt.user_id)) return prev;
+        const next = new Set(prev);
+        next.add(evt.user_id);
+        return next;
+      });
+    });
+    const offStop = conv.onTypingStop((evt) => {
+      if (meIdRef.current && evt.user_id === meIdRef.current) return;
+      setTyping((prev) => {
+        if (!prev.has(evt.user_id)) return prev;
+        const next = new Set(prev);
+        next.delete(evt.user_id);
+        return next;
+      });
+    });
+    return () => {
+      offStart();
+      offStop();
+    };
+  }, [chat, conversationId]);
+  const signalTyping = react.useCallback(() => {
+    const now = Date.now();
+    if (now - lastPingRef.current < 500) return;
+    lastPingRef.current = now;
+    chat.realtime.conversation(conversationId).sendTyping();
+  }, [chat, conversationId]);
+  return { typing, signalTyping };
+}
+function usePresence(conversationId) {
+  const chat = usePoolse();
+  const [online, setOnline] = react.useState(/* @__PURE__ */ new Set());
+  react.useEffect(() => {
+    setOnline(/* @__PURE__ */ new Set());
+    const conv = chat.realtime.conversation(conversationId);
+    const applyState = (state) => {
+      setOnline(new Set(Object.keys(state)));
+    };
+    const applyDiff = (diff) => {
+      setOnline((prev) => {
+        const next = new Set(prev);
+        if (diff.joins) Object.keys(diff.joins).forEach((id) => next.add(id));
+        if (diff.leaves) Object.keys(diff.leaves).forEach((id) => next.delete(id));
+        return next;
+      });
+    };
+    const offState = conv.onPresenceState(applyState);
+    const offDiff = conv.onPresenceDiff(applyDiff);
+    return () => {
+      offState();
+      offDiff();
+    };
+  }, [chat, conversationId]);
+  return { online };
+}
+function useRealtimeStatus() {
+  const chat = usePoolse();
+  const [status, setStatus] = react.useState(chat.realtime.getStatus());
+  react.useEffect(() => {
+    setStatus(chat.realtime.getStatus());
+    return chat.realtime.onStatus(setStatus);
+  }, [chat]);
+  return status;
+}
+function useAttachmentUpload() {
+  const chat = usePoolse();
+  const [attachment, setAttachment] = react.useState(null);
+  const [uploading, setUploading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const inFlightRef = react.useRef(null);
+  const upload = react.useCallback(
+    async (input) => {
+      inFlightRef.current?.abort();
+      const controller = new AbortController();
+      inFlightRef.current = controller;
+      setUploading(true);
+      setError(null);
+      try {
+        const att = await chat.attachments.upload(input, { signal: controller.signal });
+        if (inFlightRef.current === controller) {
+          setAttachment(att);
+        }
+        return att;
+      } catch (err) {
+        if (err?.name === "AbortError") throw err;
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        if (inFlightRef.current === controller) {
+          setUploading(false);
+          inFlightRef.current = null;
+        }
+      }
+    },
+    [chat]
+  );
+  const reset = react.useCallback(() => {
+    inFlightRef.current?.abort();
+    inFlightRef.current = null;
+    setAttachment(null);
+    setError(null);
+    setUploading(false);
+  }, []);
+  return { attachment, uploading, error, upload, reset };
+}
+function useAttachmentUrl(attachmentId) {
+  const chat = usePoolse();
+  const [url, setUrl] = react.useState(null);
+  const [loading, setLoading] = react.useState(attachmentId !== null);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    if (attachmentId === null) {
+      setUrl(null);
+      setLoading(false);
+      setError(null);
+      return;
+    }
+    let cancelled = false;
+    const controller = new AbortController();
+    setLoading(true);
+    setError(null);
+    chat.attachments.one(attachmentId).downloadUrl({ signal: controller.signal }).then((res) => {
+      if (cancelled) return;
+      setUrl(res.url);
+      setLoading(false);
+    }).catch((err) => {
+      if (cancelled) return;
+      if (err?.name === "AbortError") return;
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setLoading(false);
+    });
+    return () => {
+      cancelled = true;
+      controller.abort();
+    };
+  }, [chat, attachmentId]);
+  return { url, loading, error };
+}
+
+Object.defineProperty(exports, "ApiError", {
+  enumerable: true,
+  get: function () { return sdk.ApiError; }
+});
+Object.defineProperty(exports, "AuthError", {
+  enumerable: true,
+  get: function () { return sdk.AuthError; }
+});
+Object.defineProperty(exports, "NetworkError", {
+  enumerable: true,
+  get: function () { return sdk.NetworkError; }
+});
+Object.defineProperty(exports, "PoolseError", {
+  enumerable: true,
+  get: function () { return sdk.PoolseError; }
+});
+Object.defineProperty(exports, "RateLimitedError", {
+  enumerable: true,
+  get: function () { return sdk.RateLimitedError; }
+});
+exports.PoolseProvider = PoolseProvider;
+exports.useAttachmentUpload = useAttachmentUpload;
+exports.useAttachmentUrl = useAttachmentUrl;
+exports.useConversation = useConversation;
+exports.useConversations = useConversations;
+exports.useMe = useMe;
+exports.useMembers = useMembers;
+exports.useMessages = useMessages;
+exports.usePoolse = usePoolse;
+exports.usePresence = usePresence;
+exports.useReactions = useReactions;
+exports.useRealtimeStatus = useRealtimeStatus;
+exports.useThread = useThread;
+exports.useTyping = useTyping;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map