@amityco/react-native-social-uikit 4.2.1-f052efd.0 → 4.3.0

package/src/chat/hooks/collections/useChannelMembersCollection.ts

@@ -0,0 +1,117 @@
+// useChannelMembersCollection — ported from AmityUiKitWeb
+// v4/chat/hooks/collections/useChannelMembersCollection.
+//
+// Web wraps a shared `useLiveCollectionV4` around
+// `ChannelRepository.Membership.getMembers`; RN subscribes to that live
+// collection directly, following the sibling `useChannelsCollection` pattern:
+// mirror the callback into React state, keep the latest `onNextPage` in a ref so
+// `loadMore()` stays stable, and gate on `useAuth().isConnected` (the SDK needs a
+// connected client). The effect keys on stable joined strings of the array
+// params (`memberships`, `roles`) so it does not resubscribe every render.
+
+import { useEffect, useRef, useState } from 'react';
+import { ChannelRepository } from '@amityco/ts-sdk-react-native';
+import useAuth from '../../../core/hooks/useAuth';
+
+type Membership = Amity.Membership<'channel'>;
+
+export type UseChannelMembersCollectionParams = {
+  channelId: string;
+  memberships?: Amity.ChannelMembersLiveCollection['memberships'];
+  roles?: string[];
+  search?: string;
+  limit?: number;
+};
+
+export type UseChannelMembersCollectionResult = {
+  members: Membership[];
+  isLoadingFirstPage: boolean;
+  isLoading: boolean;
+  hasMore: boolean;
+  loadMore: () => void;
+};
+
+const DEFAULT_LIMIT = 20;
+
+export function useChannelMembersCollection({
+  channelId,
+  memberships,
+  roles,
+  search,
+  limit = DEFAULT_LIMIT,
+}: UseChannelMembersCollectionParams): UseChannelMembersCollectionResult {
+  const [members, setMembers] = useState<Membership[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [isLoadingFirstPage, setIsLoadingFirstPage] = useState(true);
+  const [hasMore, setHasMore] = useState(false);
+  const onNextPageRef = useRef<(() => void) | undefined>(undefined);
+
+  const { isConnected } = useAuth();
+
+  // Arrays are keyed on a stable string rather than identity to avoid a
+  // resubscribe on every render (mirrors useChannelsCollection's `typesKey`).
+  const membershipsKey = memberships?.join(',') ?? '';
+  const rolesKey = roles?.join(',') ?? '';
+
+  useEffect(() => {
+    if (!isConnected || !channelId) {
+      setIsLoading(true);
+      setIsLoadingFirstPage(true);
+      return undefined;
+    }
+    setIsLoading(true);
+    setIsLoadingFirstPage(true);
+
+    // `getMembers` takes a `search` filter, but it does not match from
+    // the first character — a one-letter query came back empty even with members
+    // whose display name starts with it. The SDK's dedicated
+    // `Membership.searchMembers` collection is the one built for keyword search
+    // (it is what useMention already uses). Route a non-empty query through it
+    // and keep `getMembers` for the unfiltered list.
+    const keyword = search?.trim() ?? '';
+    const handleSnapshot = ({
+      data,
+      loading,
+      hasNextPage,
+      onNextPage,
+    }: Amity.LiveCollection<Membership>) => {
+      setMembers(data);
+      setIsLoading(loading);
+      if (!loading) setIsLoadingFirstPage(false);
+      setHasMore(Boolean(hasNextPage));
+      onNextPageRef.current = onNextPage;
+    };
+
+    const unsub = keyword
+      ? ChannelRepository.Membership.searchMembers(
+          {
+            channelId,
+            search: keyword,
+            limit,
+            includeDeleted: false,
+            ...(memberships ? { memberships } : {}),
+            ...(roles ? { roles } : {}),
+          },
+          handleSnapshot
+        )
+      : ChannelRepository.Membership.getMembers(
+          {
+            channelId,
+            limit,
+            ...(memberships ? { memberships } : {}),
+            ...(roles ? { roles } : {}),
+          },
+          handleSnapshot
+        );
+
+    return () => {
+      unsub();
+    };
+  }, [isConnected, channelId, membershipsKey, rolesKey, search, limit]);
+
+  function loadMore() {
+    onNextPageRef.current?.();
+  }
+
+  return { members, isLoadingFirstPage, isLoading, hasMore, loadMore };
+}

package/src/chat/hooks/collections/useChannelsByIdsCollection.ts

@@ -0,0 +1,66 @@
+// useChannelsByIdsCollection — ported from AmityUiKitWeb
+// v4/chat/hooks/collections/useChannelCollection (the `{ channelIds }` variant).
+//
+// The message-search results list resolves each matched message's channel by id.
+// Web calls `useChannelCollection({ channelIds }, { shouldCall })` over
+// `ChannelRepository.getChannels`; the RN `useChannelsCollection` doesn't expose
+// `channelIds`, so this dedicated hook calls `ChannelRepository.getChannels`
+// directly with a channelIds filter. Gated on `useAuth().isConnected` and on a
+// non-empty id list. Callback: `{ data, loading, hasNextPage, onNextPage }`.
+
+import { useEffect, useRef, useState } from 'react';
+import { ChannelRepository } from '@amityco/ts-sdk-react-native';
+import useAuth from '../../../core/hooks/useAuth';
+
+export type UseChannelsByIdsCollectionResult = {
+  channels: Amity.Channel[];
+  loading: boolean;
+  hasNextPage: boolean;
+  loadMore: () => void;
+};
+
+export function useChannelsByIdsCollection(
+  channelIds: string[]
+): UseChannelsByIdsCollectionResult {
+  const [channels, setChannels] = useState<Amity.Channel[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [hasNextPage, setHasNextPage] = useState(false);
+  const onNextPageRef = useRef<(() => void) | undefined>(undefined);
+
+  const { isConnected } = useAuth();
+  const shouldCall = channelIds.length > 0;
+  const idsKey = channelIds.join(',');
+
+  useEffect(() => {
+    if (!isConnected || !shouldCall) {
+      setChannels([]);
+      setLoading(true);
+      setHasNextPage(false);
+      onNextPageRef.current = undefined;
+      return undefined;
+    }
+    setLoading(true);
+
+    const params: Amity.ChannelLiveCollection = { channelIds };
+
+    const unsub = ChannelRepository.getChannels(
+      params,
+      ({ data, loading: isLoading, hasNextPage: nextPage, onNextPage }) => {
+        setChannels(data);
+        setLoading(isLoading);
+        setHasNextPage(Boolean(nextPage));
+        onNextPageRef.current = onNextPage;
+      }
+    );
+
+    return () => {
+      unsub();
+    };
+  }, [isConnected, shouldCall, idsKey]);
+
+  function loadMore() {
+    onNextPageRef.current?.();
+  }
+
+  return { channels, loading, hasNextPage, loadMore };
+}

package/src/chat/hooks/collections/useChannelsCollection.ts

@@ -0,0 +1,98 @@
+// useChannelsCollection — ported from AmityUiKitWeb v4/chat/hooks/collections.
+// Subscribes to the SDK's live channel collection and exposes it as React state.
+//
+// Web wraps a shared `useChannelCollection` (react-query backed); here we call
+// `ChannelRepository.getChannels` directly — it's a live collection whose
+// callback delivers `{ data, loading, hasNextPage, onNextPage }`. We keep the
+// latest `onNextPage` in a ref so `loadMore()` stays stable, and re-subscribe
+// whenever the query params change, returning the unsubscriber for cleanup.
+
+import { useEffect, useRef, useState } from 'react';
+import { ChannelRepository } from '@amityco/ts-sdk-react-native';
+import useAuth from '../../../core/hooks/useAuth';
+
+export type UseChannelsCollectionParams = {
+  types?: Amity.ChannelType[];
+  membership?: 'all' | 'member' | 'notMember';
+  sortBy?: 'displayName' | 'firstCreated' | 'lastCreated' | 'lastActivity';
+  isDeleted?: boolean;
+  limit?: number;
+  /** Drop archived channels from the collection (web home list passes true). */
+  excludeArchives?: boolean;
+};
+
+export type UseChannelsCollectionResult = {
+  channels: Amity.Channel[];
+  loading: boolean;
+  hasNextPage: boolean;
+  loadMore: () => void;
+};
+
+const DEFAULT_LIMIT = 20;
+
+export function useChannelsCollection({
+  types,
+  membership = 'member',
+  sortBy = 'lastActivity',
+  isDeleted = false,
+  limit = DEFAULT_LIMIT,
+  excludeArchives,
+}: UseChannelsCollectionParams = {}): UseChannelsCollectionResult {
+  const [channels, setChannels] = useState<Amity.Channel[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [hasNextPage, setHasNextPage] = useState(false);
+  const onNextPageRef = useRef<(() => void) | undefined>(undefined);
+
+  // The SDK's ChannelRepository needs a connected client — calling getChannels
+  // before the session is 'established' throws. Gate the subscription on it.
+  const { isConnected } = useAuth();
+
+  // Re-subscribe on any query-param change. `types` is an array, so key on a
+  // stable string rather than its identity to avoid a resubscribe every render.
+  const typesKey = types?.join(',') ?? '';
+
+  useEffect(() => {
+    if (!isConnected) {
+      setLoading(true);
+      return undefined;
+    }
+    setLoading(true);
+
+    const params: Amity.ChannelLiveCollection = {
+      membership,
+      sortBy,
+      isDeleted,
+      limit,
+      ...(types ? { types } : {}),
+      ...(excludeArchives ? { excludeArchives: true } : {}),
+    };
+
+    const unsub = ChannelRepository.getChannels(
+      params,
+      ({ data, loading: isLoading, hasNextPage: nextPage, onNextPage }) => {
+        setChannels(data);
+        setLoading(isLoading);
+        setHasNextPage(Boolean(nextPage));
+        onNextPageRef.current = onNextPage;
+      }
+    );
+
+    return () => {
+      unsub();
+    };
+  }, [
+    isConnected,
+    typesKey,
+    membership,
+    sortBy,
+    isDeleted,
+    limit,
+    excludeArchives,
+  ]);
+
+  function loadMore() {
+    onNextPageRef.current?.();
+  }
+
+  return { channels, loading, hasNextPage, loadMore };
+}

package/src/chat/hooks/collections/useMessageSearchCollection.ts

@@ -0,0 +1,79 @@
+// useMessageSearchCollection — ported from AmityUiKitWeb
+// v4/chat/hooks/collections/useMessageSearchCollection.
+//
+// Web wraps `useLiveCollectionV4` over `MessageRepository.searchMessage` with
+// `{ query, limit: LIST_PAGE_LIMIT }`, gating on a trimmed query length. The RN
+// SDK exposes the same `MessageRepository.searchMessage(params, callback)` live
+// collection (callback: `{ data, loading, hasNextPage, onNextPage }`). We gate on
+// `useAuth().isConnected` and on the trimmed query reaching SEARCH_MIN_QUERY_LENGTH,
+// keep the latest `onNextPage` in a ref, and re-subscribe when the query changes.
+
+import { useEffect, useRef, useState } from 'react';
+import { MessageRepository } from '@amityco/ts-sdk-react-native';
+import useAuth from '../../../core/hooks/useAuth';
+import { LIST_PAGE_LIMIT, SEARCH_MIN_QUERY_LENGTH } from '../../constants';
+
+export type UseMessageSearchCollectionParams = {
+  query: string;
+};
+
+export type UseMessageSearchCollectionResult = {
+  messages: Amity.Message[];
+  loading: boolean;
+  hasNextPage: boolean;
+  loadMore: () => void;
+};
+
+export function useMessageSearchCollection({
+  query,
+}: UseMessageSearchCollectionParams): UseMessageSearchCollectionResult {
+  const [messages, setMessages] = useState<Amity.Message[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [hasNextPage, setHasNextPage] = useState(false);
+  const onNextPageRef = useRef<(() => void) | undefined>(undefined);
+
+  const { isConnected } = useAuth();
+
+  const trimmed = query.trim();
+  const shouldCall = trimmed.length >= SEARCH_MIN_QUERY_LENGTH;
+
+  useEffect(() => {
+    if (!isConnected || !shouldCall) {
+      setMessages([]);
+      setLoading(true);
+      setHasNextPage(false);
+      onNextPageRef.current = undefined;
+      return undefined;
+    }
+    setLoading(true);
+
+    const params: Amity.SearchMessageLiveCollection = {
+      query: trimmed,
+      limit: LIST_PAGE_LIMIT,
+      // Results are ordered by latest activity. Without these the SDK falls
+      // back to relevance ordering.
+      sortBy: 'createdAt',
+      orderBy: 'desc',
+    };
+
+    const unsub = MessageRepository.searchMessage(
+      params,
+      ({ data, loading: isLoading, hasNextPage: nextPage, onNextPage }) => {
+        setMessages(data);
+        setLoading(isLoading);
+        setHasNextPage(Boolean(nextPage));
+        onNextPageRef.current = onNextPage;
+      }
+    );
+
+    return () => {
+      unsub();
+    };
+  }, [isConnected, shouldCall, trimmed]);
+
+  function loadMore() {
+    onNextPageRef.current?.();
+  }
+
+  return { messages, loading, hasNextPage, loadMore };
+}

package/src/chat/hooks/collections/useMessagesCollection.ts

@@ -0,0 +1,123 @@
+// useMessagesCollection — ported from AmityUiKitWeb v4/chat/hooks/collections/useMessagesCollection.
+//
+// Web wraps MessageRepository.getMessages (a live collection) and gates on
+// `params.subChannelId && shouldFetch`. The RN SDK exposes the same
+// `MessageRepository.getMessages(params, callback)` live collection, whose
+// callback delivers `{ data, loading, error, hasNextPage, onNextPage }`.
+//
+// As with useChannelsCollection, the SDK needs a connected client before the
+// collection can run, so we additionally gate on useAuth().isConnected. We keep
+// the latest `onNextPage` in a ref so `loadMore()` stays stable, and re-subscribe
+// whenever the query params change, returning the unsubscriber for cleanup.
+
+import { useEffect, useRef, useState } from 'react';
+import { MessageRepository } from '@amityco/ts-sdk-react-native';
+import useAuth from '../../../core/hooks/useAuth';
+
+export type UseMessagesCollectionParams = Amity.MessagesLiveCollection;
+
+export type UseMessagesCollectionResult = {
+  messages: Amity.Message[];
+  loading: boolean;
+  hasNextPage: boolean;
+  loadMore: () => void;
+  /**
+   * Only ever true for a collection opened with `aroundMessageId`: the anchored
+   * page has NEWER messages below it. A collection opened at the newest page has
+   * nothing after it.
+   */
+  hasPrevPage: boolean;
+  loadPrev: () => void;
+  error: unknown;
+};
+
+export function useMessagesCollection(
+  params: UseMessagesCollectionParams,
+  shouldFetch = true
+): UseMessagesCollectionResult {
+  const [messages, setMessages] = useState<Amity.Message[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [hasNextPage, setHasNextPage] = useState(false);
+  const [hasPrevPage, setHasPrevPage] = useState(false);
+  const [error, setError] = useState<unknown>(undefined);
+  const onNextPageRef = useRef<(() => void) | undefined>(undefined);
+  const onPrevPageRef = useRef<(() => void) | undefined>(undefined);
+
+  // The SDK's MessageRepository needs a connected client — calling getMessages
+  // before the session is 'established' throws. Gate the subscription on it.
+  const { isConnected } = useAuth();
+
+  const {
+    subChannelId,
+    limit,
+    sortBy,
+    includingTags,
+    excludingTags,
+    includeDeleted,
+    aroundMessageId,
+  } = params;
+
+  useEffect(() => {
+    if (!isConnected || !subChannelId || !shouldFetch) {
+      setLoading(true);
+      return undefined;
+    }
+    setLoading(true);
+
+    const unsub = MessageRepository.getMessages(
+      params,
+      ({
+        data,
+        loading: isLoading,
+        error: err,
+        hasNextPage: nextPage,
+        onNextPage,
+        hasPrevPage: prevPage,
+        onPrevPage,
+      }) => {
+        setLoading(isLoading);
+        if (!isLoading && data) {
+          setMessages([...data]);
+          setHasNextPage(Boolean(nextPage));
+          onNextPageRef.current = nextPage ? onNextPage : undefined;
+          setHasPrevPage(Boolean(prevPage));
+          onPrevPageRef.current = prevPage ? onPrevPage : undefined;
+        }
+        if (err) setError(err);
+      }
+    );
+
+    return () => {
+      unsub();
+    };
+    // `params` is rebuilt each render; key on its stable primitive fields.
+  }, [
+    isConnected,
+    shouldFetch,
+    subChannelId,
+    limit,
+    sortBy,
+    includingTags?.join(','),
+    excludingTags?.join(','),
+    includeDeleted,
+    aroundMessageId,
+  ]);
+
+  function loadMore() {
+    onNextPageRef.current?.();
+  }
+
+  function loadPrev() {
+    onPrevPageRef.current?.();
+  }
+
+  return {
+    messages,
+    loading,
+    hasNextPage,
+    loadMore,
+    hasPrevPage,
+    loadPrev,
+    error,
+  };
+}

package/src/chat/hooks/collections/useSearchChannelsCollection.ts

@@ -0,0 +1,97 @@
+// useSearchChannelsCollection — ported from AmityUiKitWeb
+// v4/chat/hooks/collections/useSearchChannelsCollection.
+//
+// Web wraps a shared `useLiveCollectionV4` over `ChannelRepository.searchChannels`;
+// here we call `ChannelRepository.searchChannels(params, callback)` directly — a
+// live collection whose callback delivers `{ data, loading, hasNextPage, onNextPage }`
+// — mirroring the existing `useChannelsCollection`. We gate on `useAuth().isConnected`
+// (the repository throws before the session is established) and on the caller's
+// `shouldCall`, keep the latest `onNextPage` in a ref so `loadMore()` stays stable,
+// and re-subscribe whenever the query params change.
+
+import { useEffect, useRef, useState } from 'react';
+import { ChannelRepository } from '@amityco/ts-sdk-react-native';
+import useAuth from '../../../core/hooks/useAuth';
+
+export type UseSearchChannelsCollectionParams =
+  Amity.SearchChannelLiveCollection;
+
+export type UseSearchChannelsCollectionResult = {
+  channels: Amity.Channel[];
+  loading: boolean;
+  hasNextPage: boolean;
+  loadMore: () => void;
+};
+
+type UseSearchChannelsCollectionOptions = {
+  shouldCall?: boolean;
+};
+
+export function useSearchChannelsCollection(
+  params: UseSearchChannelsCollectionParams,
+  { shouldCall = true }: UseSearchChannelsCollectionOptions = {}
+): UseSearchChannelsCollectionResult {
+  const [channels, setChannels] = useState<Amity.Channel[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [hasNextPage, setHasNextPage] = useState(false);
+  const onNextPageRef = useRef<(() => void) | undefined>(undefined);
+
+  const { isConnected } = useAuth();
+
+  const {
+    query,
+    exactMatch,
+    isMemberOnly,
+    types,
+    tags,
+    sortBy,
+    orderBy,
+    limit,
+  } = params;
+
+  // `types`/`tags` are arrays rebuilt each render — key on a stable string.
+  const typesKey = types?.join(',') ?? '';
+  const tagsKey = tags?.join(',') ?? '';
+
+  useEffect(() => {
+    if (!isConnected || !shouldCall) {
+      setChannels([]);
+      setLoading(true);
+      setHasNextPage(false);
+      onNextPageRef.current = undefined;
+      return undefined;
+    }
+    setLoading(true);
+
+    const unsub = ChannelRepository.searchChannels(
+      params,
+      ({ data, loading: isLoading, hasNextPage: nextPage, onNextPage }) => {
+        setChannels(data);
+        setLoading(isLoading);
+        setHasNextPage(Boolean(nextPage));
+        onNextPageRef.current = onNextPage;
+      }
+    );
+
+    return () => {
+      unsub();
+    };
+  }, [
+    isConnected,
+    shouldCall,
+    query,
+    exactMatch,
+    isMemberOnly,
+    typesKey,
+    tagsKey,
+    sortBy,
+    orderBy,
+    limit,
+  ]);
+
+  function loadMore() {
+    onNextPageRef.current?.();
+  }
+
+  return { channels, loading, hasNextPage, loadMore };
+}

package/src/chat/hooks/index.ts

@@ -0,0 +1,13 @@
+export * from './collections';
+export * from './useMention';
+export * from './useCreateMessage';
+export * from './useEditMessage';
+export * from './useDeleteMessage';
+export * from './useChatNotifications';
+export * from './useChatNavigation';
+export * from './useNetworkOnline';
+export * from './useCurrentUserId';
+export * from './useChannelMyMembership';
+export * from './useChatSurfaceHeight';
+export * from './useFollowInfo';
+export * from '../features/shared/hooks';

package/src/chat/hooks/objects/index.ts

@@ -0,0 +1 @@
+export * from './useMessageObject';

package/src/chat/hooks/objects/useMessageObject.ts

@@ -0,0 +1,47 @@
+// useMessageObject — one message, resolved by id through a
+// `MessageRepository.getMessage` live object.
+//
+// The RN counterpart of web's `chat/hooks/objects/useMessageObject`, which wraps
+// `useLiveObjectV4` around the same repository call. iOS does the same thing in
+// `ChatMessageBubbleViewModel.updateParentMessageForReply`:
+// `chatManager.getMessage(messageId: parentId).observe { ... }`, with its
+// MessageCache entry used only as a first paint.
+//
+// The point of all three is that a reply's parent is fetched from its
+// `parentId`, never looked up in whatever page the list happens to have loaded.
+// Looking it up in the loaded page leaves the quote spinning forever whenever
+// the parent sits on a page that has not been fetched.
+
+import { MessageRepository } from '@amityco/ts-sdk-react-native';
+
+import useAuth from '../../../core/hooks/useAuth';
+import useLiveObject from '../../../core/hooks/objects/useLiveObject';
+
+export type UseMessageObjectResult = {
+  message?: Amity.Message;
+  isLoading: boolean;
+  error?: unknown;
+};
+
+export function useMessageObject(
+  messageId?: string | null
+): UseMessageObjectResult {
+  // The SDK needs a connected client before getMessage can run.
+  const { isConnected } = useAuth();
+
+  const { item, isLoading, error } = useLiveObject<
+    string,
+    Amity.Message,
+    never
+  >({
+    fetcher: MessageRepository.getMessage,
+    params: messageId ?? '',
+    enabled: !!isConnected && !!messageId,
+  });
+
+  return {
+    message: item ?? undefined,
+    isLoading,
+    error: error ?? undefined,
+  };
+}

package/src/chat/hooks/queries/index.ts

@@ -0,0 +1,4 @@
+export * from './useChannelArchiveQuery';
+export * from './useDeleteMessageQuery';
+export * from './useFlagMessageQuery';
+export * from './useSaveMediaMessageQuery';