@poolse/react 1.1.0 → 2.0.0

package/dist/index.d.ts

@@ -125,17 +125,19 @@ interface UseMembersState {
     error: Error | null;
     refetch: () => Promise<void>;
     /**
-     * Add one or more users by external_id. The returned memberships
-     * are appended to local state on success.
+     * Add one or more users by `external_id`. Unknown ids are
+     * auto-provisioned on the server. Returned memberships are
+     * appended to local state on success.
      */
     addMembers: (externalIds: string[], opts?: {
         role?: MemberRole;
     }) => Promise<Membership[]>;
     /**
-     * Remove a member by user_id. Optimistically removes from state;
-     * rolls back on server error.
+     * Remove a member by `external_id`. The SDK translates to the
+     * internal user_id under the hood. Optimistically removes from
+     * state; rolls back on server error.
      */
-    removeMember: (userId: Uuid) => Promise<void>;
+    removeMember: (externalId: string) => Promise<void>;
 }
 /**
  * Live-ish membership list for a conversation. Initial REST fetch on
@@ -286,12 +288,16 @@ interface UseThreadState {
 declare function useThread(conversationId: Uuid, rootMessageId: Uuid): UseThreadState;
 
 interface UseTypingState {
-    /** Set of user_ids currently typing. */
-    typing: Set<Uuid>;
     /**
-     * Send a typing ping to the server. Debounced inside the SDK — the
-     * server squashes `typing:start` to one push per (user, conversation,
-     * window). Call as often as you want from input handlers.
+     * Set of `external_id`s currently typing (your own user identifiers,
+     * the same string you'd pass to `userResolver`). Excludes the
+     * current user — they know they're typing.
+     */
+    typing: Set<string>;
+    /**
+     * Send a typing ping to the server. Debounced inside the hook to
+     * once per 500 ms — the server squashes further with its own
+     * per-(user, conversation) window.
      */
     signalTyping: () => void;
 }
@@ -299,16 +305,17 @@ interface UseTypingState {
  * Tracks who's typing in `conversationId`. Subscribes to the
  * `typing:start` / `typing:stop` broadcasts; auto-cleans up entries
  * when stop fires.
- *
- * `signalTyping` debounces on the client side to once per 500 ms so a
- * fast-typing user doesn't flood the channel — poolse does its own
- * server-side debounce too, so both layers are safe.
  */
 declare function useTyping(conversationId: string): UseTypingState;
 
 interface UsePresenceState {
-    /** Set of user_ids currently online in this conversation. */
-    online: Set<Uuid>;
+    /**
+     * Set of `external_id`s currently online in this conversation —
+     * the tenant's own user identifiers. Empty set when no one is on
+     * the channel (note: an empty result during reconnect is normal;
+     * pair with `useRealtimeStatus()` if you need to distinguish).
+     */
+    online: Set<string>;
 }
 /**
  * Who's currently joined to `conversationId`'s channel. Backed by
@@ -428,16 +435,17 @@ interface UseUserState {
     loading: boolean;
 }
 /**
- * Resolve a poolse user_id to the customer's display name + avatar
- * URL via the configured `userResolver`. Returns `{ profile: null,
- * loading: false }` when:
- *   * no resolver is configured (customer hasn't wired one up)
+ * Resolve the tenant's `external_id` (your own user id) to
+ * `{ displayName, avatarUrl }` via the configured `userResolver`.
+ *
+ * Returns `{ profile: null, loading: false }` when:
+ *   * no resolver is configured
  *   * resolver returned null (user not found)
  *   * resolver threw (logged once, then cached as null)
  *
  * Pass `null` / empty string to opt out (the hook becomes a no-op).
  * Useful for self bubbles (you already know who you are).
  */
-declare function useUser(userId: Uuid | null | undefined): UseUserState;
+declare function useUser(externalId: string | null | undefined): UseUserState;
 
 export { PoolseProvider, type PoolseProviderProps, type ReactionMap, type UploadItem, type UploadItemStatus, type UseUserState, useAttachmentUpload, useAttachmentUrl, useConversation, useConversations, useMe, useMembers, useMessages, usePoolse, usePresence, useReactions, useRealtimeStatus, useThread, useTyping, useUser };

package/dist/index.js

@@ -268,11 +268,14 @@ function useMembers(conversationId) {
     [chat, conversationId]
   );
   const removeMember = useCallback(
-    async (userId) => {
+    async (externalId) => {
       const snapshot = membersRef.current;
-      setMembers((prev) => prev.filter((m) => m.user_id !== userId));
+      const target = snapshot.find((m) => m.external_id === externalId);
+      if (!target) return;
+      const targetUserId = target.user_id;
+      setMembers((prev) => prev.filter((m) => m.external_id !== externalId));
       try {
-        await chat.conversations.one(conversationId).removeMember(userId);
+        await chat.conversations.one(conversationId).removeMember(targetUserId);
       } catch (err) {
         setMembers(snapshot);
         throw err;
@@ -293,6 +296,8 @@ function useMessages(conversationId) {
   const oldestSequenceRef = useRef(null);
   const meIdRef = useRef(me?.id ?? null);
   meIdRef.current = me?.id ?? null;
+  const meExternalIdRef = useRef(me?.external_id ?? null);
+  meExternalIdRef.current = me?.external_id ?? null;
   useEffect(() => {
     let cancelled = false;
     setLoading(true);
@@ -377,6 +382,7 @@ function useMessages(conversationId) {
         // here would briefly flash the row on the "other" side until
         // the realtime echo replaced it with the canonical row.
         sender_id: meIdRef.current,
+        sender_external_id: meExternalIdRef.current,
         type: attrs.type ?? "text",
         body: attrs.body ?? null,
         reply_to_id: attrs.reply_to_id ?? null,
@@ -614,6 +620,7 @@ function useThread(conversationId, rootMessageId) {
         tenant_id: "",
         conversation_id: conversationId,
         sender_id: null,
+        sender_external_id: null,
         type: attrs.type ?? "text",
         body: attrs.body ?? null,
         reply_to_id: rootMessageId,
@@ -711,26 +718,30 @@ function useTyping(conversationId) {
   const { me } = useMe();
   const [typing, setTyping] = useState(/* @__PURE__ */ new Set());
   const lastPingRef = useRef(0);
-  const meIdRef = useRef(me?.id ?? null);
-  meIdRef.current = me?.id ?? null;
+  const meExtRef = useRef(me?.external_id ?? null);
+  meExtRef.current = me?.external_id ?? null;
   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;
+      const ext = evt.external_id;
+      if (!ext) return;
+      if (meExtRef.current && ext === meExtRef.current) return;
       setTyping((prev) => {
-        if (prev.has(evt.user_id)) return prev;
+        if (prev.has(ext)) return prev;
         const next = new Set(prev);
-        next.add(evt.user_id);
+        next.add(ext);
         return next;
       });
     });
     const offStop = conv.onTypingStop((evt) => {
-      if (meIdRef.current && evt.user_id === meIdRef.current) return;
+      const ext = evt.external_id;
+      if (!ext) return;
+      if (meExtRef.current && ext === meExtRef.current) return;
       setTyping((prev) => {
-        if (!prev.has(evt.user_id)) return prev;
+        if (!prev.has(ext)) return prev;
         const next = new Set(prev);
-        next.delete(evt.user_id);
+        next.delete(ext);
         return next;
       });
     });
@@ -747,6 +758,14 @@ function useTyping(conversationId) {
   }, [chat, conversationId]);
   return { typing, signalTyping };
 }
+function externalIdsFrom(state) {
+  const out = [];
+  for (const presence of Object.values(state)) {
+    const meta = presence?.metas?.[0];
+    if (meta?.external_id) out.push(meta.external_id);
+  }
+  return out;
+}
 function usePresence(conversationId) {
   const chat = usePoolse();
   const [online, setOnline] = useState(/* @__PURE__ */ new Set());
@@ -755,13 +774,13 @@ function usePresence(conversationId) {
     if (!conversationId) return;
     const conv = chat.realtime.conversation(conversationId);
     const applyState = (state) => {
-      setOnline(new Set(Object.keys(state)));
+      setOnline(new Set(externalIdsFrom(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));
+        if (diff.joins) externalIdsFrom(diff.joins).forEach((ext) => next.add(ext));
+        if (diff.leaves) externalIdsFrom(diff.leaves).forEach((ext) => next.delete(ext));
         return next;
       });
     };
@@ -918,32 +937,32 @@ function useAttachmentUrl(attachmentId) {
   return { url, loading, error };
 }
 var EMPTY = { profile: null, loading: false };
-function useUser(userId) {
+function useUser(externalId) {
   const chat = usePoolse();
   const [state, setState] = useState(() => {
-    if (!userId) return EMPTY;
-    const cached = chat.users.peek(userId);
+    if (!externalId) return EMPTY;
+    const cached = chat.users.peek(externalId);
     if (cached === void 0) return { profile: null, loading: true };
     return { profile: cached, loading: false };
   });
   useEffect(() => {
-    if (!userId) {
+    if (!externalId) {
       setState(EMPTY);
       return;
     }
     const apply = () => {
-      const cached = chat.users.peek(userId);
+      const cached = chat.users.peek(externalId);
       if (cached === void 0) {
         setState({ profile: null, loading: true });
-        void chat.users.get(userId);
+        void chat.users.get(externalId);
       } else {
         setState({ profile: cached, loading: false });
       }
     };
-    const off = chat.users.subscribe(userId, apply);
+    const off = chat.users.subscribe(externalId, apply);
     apply();
     return off;
-  }, [chat, userId]);
+  }, [chat, externalId]);
   return state;
 }