stream-chat-react-native-core 10.0.0-rc.1 → 10.0.0-rc.3

package/lib/typescript/hooks/useClientNotifications.d.ts

@@ -1,7 +1,7 @@
 /**
- * This hook is used to get the notifications from the client.
- * @returns {Object} - An object containing the notifications.
- * @returns {Notification[]} notifications - The notifications.
+ * Returns the notifications held by the client's notification manager.
+ *
+ * @returns An object with the `notifications`.
  */
 export declare const useClientNotifications: () => {
     notifications: import("stream-chat").Notification[];

package/lib/typescript/hooks/useHorizontalInsets.d.ts

@@ -2,24 +2,18 @@ import { ViewStyle } from 'react-native';
 /**
  * Horizontal safe area padding for a surface that spans the full window width.
  *
- * **Only for surfaces an integrator cannot wrap.** Everything the SDK renders in-tree is left
- * alone: the integrator wraps their screen in a `SafeAreaView` and the whole subtree - including
- * absolutely positioned children, which track their containing block's border box - narrows with
- * it. Applying this to an in-tree surface double-pads it for every integrator who already wraps.
+ * Only for surfaces an integrator cannot wrap, such as React Native's `Modal`, which renders in a
+ * separate native window. In-tree surfaces already narrow with the integrator's `SafeAreaView`, so
+ * this would double-pad them; a bottom sheet or overlay qualifies only if it mounts outside that
+ * tree. Prefer a `SafeAreaView` where one fits (see `ImageGalleryHeader`): it compares the window
+ * inset with its own frame, whereas this hook reads the window-global `useSafeAreaInsets` and has
+ * no such protection when nested.
  *
- * In practice that leaves React Native's own `Modal`, which renders in a separate native window.
- * A bottom sheet or an overlay is *not* automatically out of reach - check where it actually
- * mounts. Prefer a `SafeAreaView` (see `ImageGalleryHeader`/`Footer`) wherever one fits: it
- * compares the window inset against its own measured frame, so a nested instance contributes
- * nothing once an ancestor has narrowed the subtree. This hook reads `useSafeAreaInsets`, which is
- * window-global and has no such protection.
+ * `left` and `right` stay separate because from iOS 27 the system can stack its controls down a
+ * single edge (measured 0 and 84 on iPhone Duo). A side whose inset is 0 is omitted, as a
+ * `paddingLeft: 0` longhand would override a `padding` shorthand set elsewhere.
  *
- * `left` and `right` are never collapsed into one value: from iOS 27 the system stacks its controls
- * down a single edge, so the two differ (measured 0 and 84 on iPhone Duo).
- *
- * A side whose inset is 0 is omitted rather than emitted as `paddingLeft: 0`, because a longhand
- * overrides a `padding` shorthand for that side - emitting a zero would silently drop padding the
- * component or a consumer's theme had already set.
+ * @returns A style with `paddingLeft` and `paddingRight` for the non-zero insets.
  */
 export declare const useHorizontalInsets: () => ViewStyle;
 //# sourceMappingURL=useHorizontalInsets.d.ts.map

package/lib/typescript/hooks/useHorizontalInsets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useHorizontalInsets.d.ts","sourceRoot":"","sources":["../../../src/hooks/useHorizontalInsets.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,mBAAmB,QAAO,SAUtC,CAAC"}
+{"version":3,"file":"useHorizontalInsets.d.ts","sourceRoot":"","sources":["../../../src/hooks/useHorizontalInsets.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,QAAO,SAUtC,CAAC"}

package/lib/typescript/hooks/useIsChannelMember.d.ts

@@ -1,6 +1,10 @@
 import type { Channel } from 'stream-chat';
 /**
- * Determines whether the user with the given id is already a member of the channel.
+ * Whether the user with the given ID is a member of the channel.
+ *
+ * @param channel The channel to check.
+ * @param userId The ID of the user. Without it the result is false.
+ * @returns True when the user is a member.
  */
 export declare const useIsChannelMember: (channel: Channel, userId?: string) => boolean;
 //# sourceMappingURL=useIsChannelMember.d.ts.map

package/lib/typescript/hooks/useIsChannelMember.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIsChannelMember.d.ts","sourceRoot":"","sources":["../../../src/hooks/useIsChannelMember.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAI3C;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,OAAO,EAAE,SAAS,MAAM,YAUnE,CAAC"}
+{"version":3,"file":"useIsChannelMember.d.ts","sourceRoot":"","sources":["../../../src/hooks/useIsChannelMember.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAI3C;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,OAAO,EAAE,SAAS,MAAM,YAUnE,CAAC"}

package/lib/typescript/hooks/useIsMountedRef.d.ts

@@ -1,6 +1,5 @@
 /**
- * Returns mount status of component. This hook can be used for purpose of avoiding any
- * setState calls (within async operation) after component gets unmounted.
+ * Returns a ref that turns false once the component unmounts, to skip state updates in async work.
  *
  * @example
  * ```
@@ -8,13 +7,13 @@
  * const [dummyValue, setDummyValue] = useState(false);
  *
  * useEffect(() => {
- *  someAsyncOperation().then(() => {
- *    if (isMounted.current) setDummyValue(true);
- *  })
- * })
+ *   someAsyncOperation().then(() => {
+ *     if (isMounted.current) setDummyValue(true);
+ *   });
+ * }, []);
  * ```
  *
- * @returns isMounted {Object} Mount status ref for the component.
+ * @returns A ref whose `current` is true until the component unmounts.
  */
 export declare const useIsMountedRef: () => import("react").RefObject<boolean>;
 //# sourceMappingURL=useIsMountedRef.d.ts.map

package/lib/typescript/hooks/useIsMountedRef.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIsMountedRef.d.ts","sourceRoot":"","sources":["../../../src/hooks/useIsMountedRef.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,eAAe,0CAe3B,CAAC"}
+{"version":3,"file":"useIsMountedRef.d.ts","sourceRoot":"","sources":["../../../src/hooks/useIsMountedRef.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,eAAe,0CAY3B,CAAC"}

package/lib/typescript/hooks/useIsSvg.d.ts

@@ -1,15 +1,16 @@
 /**
- * Returns true if `uri` points to an SVG (either by `.svg` extension or by
- * `image/svg+xml` data-URI prefix). Exported as a pure function for non-React
- * callers; React components should prefer `useIsSvg` so the check is memoized
- * per URI.
+ * Whether `uri` points to an SVG, by `.svg` extension (ignoring query and fragment) or by
+ * `image/svg+xml` data URI. The non-hook form of `useIsSvg`.
+ *
+ * @param uri The URI to check.
+ * @returns True when the URI is an SVG.
  */
 export declare const isSvgUri: (uri: string | null | undefined) => boolean;
 /**
- * Memoized variant of `isSvgUri`. Re-runs the string check only when `uri`
- * actually changes — useful in hot render paths like the gallery where the
- * surrounding component re-renders frequently (animated styles, swipe state)
- * but the URI is stable.
+ * Memoized `isSvgUri`, re-evaluated only when `uri` changes.
+ *
+ * @param uri The URI to check.
+ * @returns True when the URI is an SVG.
  */
 export declare const useIsSvg: (uri: string | null | undefined) => boolean;
 //# sourceMappingURL=useIsSvg.d.ts.map

package/lib/typescript/hooks/useIsSvg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIsSvg.d.ts","sourceRoot":"","sources":["../../../src/hooks/useIsSvg.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,KAAG,OAUzD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,KAAG,OACrB,CAAC"}
+{"version":3,"file":"useIsSvg.d.ts","sourceRoot":"","sources":["../../../src/hooks/useIsSvg.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,KAAG,OAUzD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,KAAG,OACrB,CAAC"}

package/lib/typescript/hooks/useIsTargetedMessage.d.ts

@@ -1,12 +1,12 @@
 /**
- * Whether this message is the one the list is currently focused on — the target of a
- * `jumpToMessage` / `jumpToTheFirstUnreadMessage`, for the lifetime of the signal's TTL.
+ * Whether the message is the target of the active paginator's `messageFocusSignal` (set by
+ * `jumpToMessage` and `jumpToTheFirstUnreadMessage`, for the signal's TTL).
  *
- * Read per row, off the active paginator's `messageFocusSignal`, rather than from a
- * `highlightedMessageId` on the channel context. Both cost one subscription per row in practice
- * (every row already consumes that context), but a context value that changes on every jump
- * re-renders every row; a boolean scoped to one id re-renders only the row losing the highlight
- * and the row gaining it.
+ * Each row selects its own boolean, so a jump re-renders only the row losing the highlight and the
+ * row gaining it, not every row as a shared context value would.
+ *
+ * @param messageId The ID of the message.
+ * @returns True when the message is the focus target.
  */
 export declare const useIsTargetedMessage: (messageId: string) => boolean;
 //# sourceMappingURL=useIsTargetedMessage.d.ts.map

package/lib/typescript/hooks/useKeyboardVisibility.d.ts

@@ -1,6 +1,7 @@
 /**
- * A custom hook that provides a boolean value indicating whether the keyboard is visible.
- * @returns A boolean value indicating whether the keyboard is visible.
+ * Tracks whether the keyboard is visible.
+ *
+ * @returns True while the keyboard is visible.
  */
 export declare const useKeyboardVisibility: () => boolean;
 //# sourceMappingURL=useKeyboardVisibility.d.ts.map

package/lib/typescript/hooks/useKeyboardVisibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useKeyboardVisibility.d.ts","sourceRoot":"","sources":["../../../src/hooks/useKeyboardVisibility.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,qBAAqB,eAiBjC,CAAC"}
+{"version":3,"file":"useKeyboardVisibility.d.ts","sourceRoot":"","sources":["../../../src/hooks/useKeyboardVisibility.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,eAiBjC,CAAC"}

package/lib/typescript/hooks/useLazyRef.d.ts

@@ -1,7 +1,9 @@
 import { type RefObject } from 'react';
 /**
- * Creates a stable ref whose initial value is computed only once.
- * Use this when the initial ref value is expensive or allocates an object.
+ * Creates a stable ref whose initial value is computed once, for values that are costly to build.
+ *
+ * @param getInitialValue Computes the initial value on the first render. Must not return `null`.
+ * @returns The ref holding the value.
  */
 export declare const useLazyRef: <T>(getInitialValue: () => T) => RefObject<T>;
 //# sourceMappingURL=useLazyRef.d.ts.map

package/lib/typescript/hooks/useLazyRef.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLazyRef.d.ts","sourceRoot":"","sources":["../../../src/hooks/useLazyRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAU,MAAM,OAAO,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,iBAAiB,MAAM,CAAC,KAOtC,SAAS,CAAC,CAAC,CAC1B,CAAC"}
+{"version":3,"file":"useLazyRef.d.ts","sourceRoot":"","sources":["../../../src/hooks/useLazyRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAU,MAAM,OAAO,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,iBAAiB,MAAM,CAAC,KAOtC,SAAS,CAAC,CAAC,CAC1B,CAAC"}

package/lib/typescript/hooks/useMessagePaginator.d.ts

@@ -1,6 +1,8 @@
 /**
- * The message paginator this subtree is rendering: the thread's reply list inside a `<Thread>`, the
- * channel's main list otherwise.
+ * The message paginator this subtree renders: the thread's inside a `<Thread>`, otherwise the
+ * channel's.
+ *
+ * @returns The active message paginator.
  */
 export declare const useMessagePaginator: () => import("stream-chat").MessagePaginator;
 //# sourceMappingURL=useMessagePaginator.d.ts.map

package/lib/typescript/hooks/useMessagePaginator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMessagePaginator.d.ts","sourceRoot":"","sources":["../../../src/hooks/useMessagePaginator.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,mBAAmB,8CAK/B,CAAC"}
+{"version":3,"file":"useMessagePaginator.d.ts","sourceRoot":"","sources":["../../../src/hooks/useMessagePaginator.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,8CAK/B,CAAC"}

package/lib/typescript/hooks/usePendingAttachmentUpload.d.ts

@@ -1,14 +1,18 @@
 export type PendingAttachmentUpload = {
-    /** True when `client.uploadManager` has an in-flight upload for this attachment local id. */
+    /** Whether `client.uploadManager` has an in-flight upload for this attachment local ID. */
     isUploading: boolean;
     /**
-     * Upload percent **0–100** from `client.uploadManager` (same scale as `attachmentManager`
-     * `onProgress` / `localMetadata.uploadProgress`). `undefined` when not computable or not uploading.
+     * Upload progress from `client.uploadManager` as a percentage from 0 to 100, the same scale as
+     * `localMetadata.uploadProgress`. `undefined` when not uploading or not computable.
      */
     uploadProgress: number | undefined;
 };
 /**
- * Subscribes to `client.uploadManager` for the pending attachment identified by `localId`.
+ * Subscribes to `client.uploadManager` for the pending attachment identified by `localId`. An
+ * upload that finished after reaching 90% keeps reporting `isUploading` at 100% for 350 ms.
+ *
+ * @param localId The local ID of the attachment. Without it the upload is reported as idle.
+ * @returns The upload state of the attachment.
  */
 export declare function usePendingAttachmentUpload(localId: string | undefined): PendingAttachmentUpload;
 //# sourceMappingURL=usePendingAttachmentUpload.d.ts.map

package/lib/typescript/hooks/usePendingAttachmentUpload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePendingAttachmentUpload.d.ts","sourceRoot":"","sources":["../../../src/hooks/usePendingAttachmentUpload.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,uBAAuB,GAAG;IACpC,6FAA6F;IAC7F,WAAW,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC,CAAC;AAiBF;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,uBAAuB,CA8F/F"}
+{"version":3,"file":"usePendingAttachmentUpload.d.ts","sourceRoot":"","sources":["../../../src/hooks/usePendingAttachmentUpload.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,uBAAuB,GAAG;IACpC,2FAA2F;IAC3F,WAAW,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC,CAAC;AAiBF;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,uBAAuB,CA8F/F"}

package/lib/typescript/hooks/usePortalSettledCallback.d.ts

@@ -1,32 +1,16 @@
 /**
- * Returns a stable callback that is safe to run after a `PortalWhileClosingView`
- * has settled back into its original tree.
+ * Returns a stable callback that runs once a `PortalWhileClosingView` has settled back into its
+ * original tree.
  *
- * Some followup actions are sensitive to that handoff window. If they run
- * while a view is still being returned from a portal host to its in place host,
- * they can target a node that is about to be reattached. On Android, that is
- * especially noticeable with focus sensitive work, where the target can lose
- * focus again mid keyboard animation.
+ * While a view returns from a portal host to its in-place host, follow-up work can target a node
+ * that is about to be reattached. On Android, focus work loses focus again mid keyboard animation
+ * (focusing the input right after the message overlay closes dismisses the keyboard at once), and
+ * a pressed button that morphs can render into the wrong part of the hierarchy. The callback waits
+ * two frames on Android, the first for the portal to retarget and React to commit, the second for
+ * the native hierarchy to settle. On iOS it runs immediately.
  *
- * Two frames are intentional here:
- * - frame 1 lets the portal retarget and React commit the component tree
- * - frame 2 lets the native view hierarchy settle in its final host
- *
- * iOS does not currently need this settle window for this flow.
- *
- * A good example is the message composer edit action: after closing the message
- * overlay, we wait for the portal handoff to settle before focusing the input
- * and opening the keyboard. Doing this prematurely will result in the keyboard
- * being immediately closed.
- *
- * Another good example would be having a button wrapped in a `PortalWhileClosingView`,
- * that possibly renders (or morphs into) something when pressed. Handling `onPress`
- * prematurely here may lead to the morphed button rendering into a completely different
- * part of the UI hierarchy, causing unknown behaviour. This hook prevents that from
- * happening.
- *
- * @param callback - callback we want to invoke once the portal handoff has settled
- * @returns A stable callback gated behind the portal settle window.
+ * @param callback Runs once the portal handoff has settled.
+ * @returns A stable callback gated behind the settle window.
  */
 export declare const usePortalSettledCallback: <T extends unknown[]>(callback: (...args: T) => void) => import("./useStableCallback").StableCallback<T, void>;
 //# sourceMappingURL=usePortalSettledCallback.d.ts.map

package/lib/typescript/hooks/usePortalSettledCallback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePortalSettledCallback.d.ts","sourceRoot":"","sources":["../../../src/hooks/usePortalSettledCallback.ts"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,OAAO,EAAE,EAAE,UAAU,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,0DAgB3F,CAAC"}
+{"version":3,"file":"usePortalSettledCallback.d.ts","sourceRoot":"","sources":["../../../src/hooks/usePortalSettledCallback.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,OAAO,EAAE,EAAE,UAAU,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,0DAgB3F,CAAC"}

package/lib/typescript/hooks/usePrunableMessageList.d.ts

@@ -10,17 +10,17 @@ export type ViewabilityChangedCallbackInput = {
     inverted: boolean;
 };
 /**
- * Drives the message list's window cap.
+ * Tells the paginator when the message list may prune its oldest messages.
  *
- * The cap itself lives in `stream-chat` — configure it with
- * `channel.messagePaginator.updateConfig({ maxLoadedItems })`, or declaratively via
- * `client.config.set({ channel: { messagePaginator: { maxLoadedItems } } })`. The paginator drops the
- * oldest messages as new ones arrive and re-opens its "load older" edge, so scrolling back re-fetches.
+ * The cap (`maxLoadedItems`) lives in `stream-chat`: set it with
+ * `channel.messagePaginator.updateConfig({ maxLoadedItems })` or
+ * `client.config.set({ channel: { messagePaginator: { maxLoadedItems } } })`. This hook owns
+ * whether pruning is safe: it tracks the visible range and suspends pruning while the user is near
+ * the pruned edge. The paginator reads that boolean on ingest and nothing subscribes to it, so
+ * scrolling costs no render.
  *
- * What this hook owns is the one part the state layer cannot know: **whether pruning is safe right
- * now**. Dropping the oldest messages while the user is reading near them would pull content out from
- * under them, so viewability is tracked here and pushed down as a single boolean. The paginator reads
- * it on ingest; nothing subscribes to it, so scrolling can never cost a render.
+ * @param params.paginator The message paginator of the list.
+ * @returns The `maxLoadedItems` cap and the `viewabilityChangedCallback` to wire to the list.
  */
 export declare function usePrunableMessageList({ paginator }: {
     paginator?: MessagePaginator;

package/lib/typescript/hooks/usePrunableMessageList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePrunableMessageList.d.ts","sourceRoot":"","sources":["../../../src/hooks/usePrunableMessageList.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAKpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAE9D,MAAM,MAAM,kBAAkB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC;AACpF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,aAAa,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAyBF;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,SAAS,EAAE,EAAE;IAAE,SAAS,CAAC,EAAE,gBAAgB,CAAA;CAAE;;;EAgCrF"}
+{"version":3,"file":"usePrunableMessageList.d.ts","sourceRoot":"","sources":["../../../src/hooks/usePrunableMessageList.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAKpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAE9D,MAAM,MAAM,kBAAkB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC;AACpF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,aAAa,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAyBF;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,SAAS,EAAE,EAAE;IAAE,SAAS,CAAC,EAAE,gBAAgB,CAAA;CAAE;;;EA6BrF"}

package/lib/typescript/hooks/useQueryReminders.d.ts

@@ -1,10 +1,8 @@
 import { ReminderResponseData } from 'stream-chat';
 /**
- * Custom hook to query reminders from the Stream Chat client.
- * It handles fetching, updating, and deleting reminders, and provides
- * a way to refresh the list and load more reminders.
+ * Queries reminders from the client and keeps the list in sync with reminder events.
  *
- * @returns {Object} - Contains data, isLoading, onEndReached, onRefresh, and setData.
+ * @returns The reminders as `data`, `isLoading`, `loadNext` to fetch the next page and `setData`.
  */
 export declare const useQueryReminders: () => {
     data: ReminderResponseData[];

package/lib/typescript/hooks/useQueryReminders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useQueryReminders.d.ts","sourceRoot":"","sources":["../../../src/hooks/useQueryReminders.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiD,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAuClG;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;CAkG7B,CAAC"}
+{"version":3,"file":"useQueryReminders.d.ts","sourceRoot":"","sources":["../../../src/hooks/useQueryReminders.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiD,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAmClG;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;CAkG7B,CAAC"}

package/lib/typescript/hooks/useRAFCoalescedValue.d.ts

@@ -1,43 +1,17 @@
 /**
- * A utility hook that coalesces a fast changing value to the display’s frame rate.
- * It accepts any “noisy” input (arrays, objects, numbers, etc.) and exposes a value
- * that React consumers will see at most once per animation frame (via
- * `requestAnimationFrame`). This is useful when upstream sources (selectors, sockets,
- * DB listeners) can fire multiple times within a single paint and you want to avoid
- * extra renders and layout churn.
+ * Coalesces a fast-changing value to at most one update per animation frame, so sources that fire
+ * several times within a paint (selectors, sockets, DB listeners) cause one render, not many.
  *
- * How it works:
- * - Keeps track of the latest incoming value
- * - Ensures there is **at most one** pending RAF at a time
- * - When the RAF fires, commits the **latest** value to state (`emitted`)
- * - If additional changes arrive before the RAF runs, they are merged (the last write
- *   operation wins) and no new RAF is scheduled
+ * Intermediate values within a frame are skipped, so it suits visual coalescing, not logic that
+ * must observe every transition. Equality is referential: a producer that recreates arrays or
+ * objects still publishes once per frame, so stabilize them upstream. It follows the frame cadence
+ * and is not a throttle or debounce. A pending frame is cancelled only on unmount, not on value
+ * changes.
  *
- * With this hook you can:
- * - Feed a `FlatList`/`SectionList` from fast changing sources without spamming re-renders
- * - Align React updates to the paint cadence (one publish per frame)
- * - Help preserve item anchoring logic (e.g., MVCP) by reducing in-frame updates
- *
- * **Caveats:**
- * - This hook intentionally skips intermediate states that occur within the same
- *   frame. If you must observe every transition (e.g., for analytics/reducers), do that
- *   upstream; this hook is for visual coalescing
- * - Equality checks are simple referential equalities. If your producer recreates arrays
- *   or objects each time, you’ll still publish once per frame. To avoid even those
- *   emissions, stabilize upstream
- * - This is not a silver bullet for throttle/debounce; it uses the screen’s refresh cycle;
- *   If you need “no more than once per X ms”, layer that upstream
- *
- * Usage tips:
- * - Prefer passing already-memoized values when possible (e.g., stable arrays by ID).
- * - Pair with a stable `keyExtractor` in lists so coalesced updates map cleanly to rows.
- * - Do not cancel/reschedule on prop changes; cancellation is handled on unmount only.
- *
- * @param value The upstream value that may change multiple times within a single frame.
- * @param isEnabled Determines whether the hook should be run or not (useful for cases where
- * we want to conditionally use RAF when certain feature feature flags are enabled). If `false`,
- * it will simply pass the data through (maintaining the reference as well).
- * @returns A value that updates **at most once per frame** with the latest input.
+ * @param value The upstream value that may change several times within a frame.
+ * @param isEnabled When false, `value` is returned as is with the same reference, to gate the RAF
+ * behind a feature flag.
+ * @returns The latest value, updated at most once per frame.
  */
 export declare const useRAFCoalescedValue: <S>(value: S, isEnabled: boolean | undefined) => S;
 //# sourceMappingURL=useRAFCoalescedValue.d.ts.map

package/lib/typescript/hooks/useRAFCoalescedValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRAFCoalescedValue.d.ts","sourceRoot":"","sources":["../../../src/hooks/useRAFCoalescedValue.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,WAAW,OAAO,GAAG,SAAS,KAAG,CAgClF,CAAC"}
+{"version":3,"file":"useRAFCoalescedValue.d.ts","sourceRoot":"","sources":["../../../src/hooks/useRAFCoalescedValue.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,WAAW,OAAO,GAAG,SAAS,KAAG,CAkClF,CAAC"}

package/lib/typescript/hooks/useScreenDimensions.d.ts

@@ -1,7 +1,8 @@
 /**
- * A custom hook that provides functions to calculate dimensions based on
- * a percentage of the screen height (vh) and viewport width (vw). It
- * dynamically updates dimensions on changes in device orientation.
+ * Returns `vh` and `vw` helpers that convert a percentage of the screen height or width to points,
+ * updating when the screen dimensions change.
+ *
+ * @param rounded Rounds the results to whole points. Defaults to false.
  *
  * @deprecated These are percentages of the *screen*, not of the window the app is laid out in. The
  * two diverge once the window is resizable (Split View, fold/unfold, Android multi-window): we
@@ -10,7 +11,7 @@
  * Use {@link useViewport}, the same API measured against the window, or `onLayout` on your own view
  * inside a component that does not fill the window.
  *
- * @returns {Object} An object containing functions vh and vw.
+ * @returns An object with the `vh` and `vw` functions.
  */
 export declare const useScreenDimensions: (rounded?: boolean) => {
     vh: (percentageHeight: number) => number;

package/lib/typescript/hooks/useScreenDimensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useScreenDimensions.d.ts","sourceRoot":"","sources":["../../../src/hooks/useScreenDimensions.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,GAAI,UAAU,OAAO;2BAmC9B,MAAM;0BARP,MAAM;CAgB3B,CAAC"}
+{"version":3,"file":"useScreenDimensions.d.ts","sourceRoot":"","sources":["../../../src/hooks/useScreenDimensions.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAAI,UAAU,OAAO;2BAiC9B,MAAM;0BARP,MAAM;CAgB3B,CAAC"}

package/lib/typescript/hooks/useScreenOrientation.d.ts

@@ -1,10 +1,8 @@
 export type ScreenOrientation = 'landscape' | 'portrait';
 /**
- * A custom hook that derives the current screen orientation from the window
- * dimensions. It updates automatically on device rotation via
- * `useWindowDimensions`.
+ * Derives the orientation from the window dimensions, updating on rotation.
  *
- * @returns {ScreenOrientation} Either `'landscape'` or `'portrait'`.
+ * @returns `'landscape'` when the window is wider than tall, otherwise `'portrait'`.
  */
 export declare const useScreenOrientation: () => ScreenOrientation;
 //# sourceMappingURL=useScreenOrientation.d.ts.map

package/lib/typescript/hooks/useScreenOrientation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useScreenOrientation.d.ts","sourceRoot":"","sources":["../../../src/hooks/useScreenOrientation.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,UAAU,CAAC;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,QAAO,iBAGvC,CAAC"}
+{"version":3,"file":"useScreenOrientation.d.ts","sourceRoot":"","sources":["../../../src/hooks/useScreenOrientation.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,UAAU,CAAC;AAEzD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAO,iBAGvC,CAAC"}

package/lib/typescript/hooks/useStableCallback.d.ts

@@ -1,26 +1,16 @@
 export type StableCallback<A extends unknown[], R> = (...args: A) => R;
 /**
- * A utility hook implementing a stable callback. It takes in an unstable method that
- * is supposed to be invoked somewhere deeper in the DOM tree without making it
- * change its reference every time the parent component rerenders. It will also return
- * the value of the callback if it does return one.
- * A common use-case would be having a function whose invocation depends on state
- * somewhere high up in the DOM tree and wanting to use the same function deeper
- * down, for example in a leaf node and simply using useCallback results in
- * cascading dependency hell. If we wrap it in useStableCallback, we would be able
- * to:
- * - Use the same function as a dependency of another hook (since it is stable)
- * - Still invoke it and get the latest state
+ * Returns a function with a stable reference that always calls the latest `callback` and returns
+ * its result. It can be a dependency of other hooks without invalidating them on every parent
+ * render.
  *
- * **Caveats:**
- * - Never wrap a function that is supposed to return a React.ReactElement in
- *   useStableCallback, since React will not know that the DOM needs to be updated
- *   whenever the callback value changes (for example, renderItem from FlatList must
- *   never be wrapped in this hook)
- * - Always prefer using a standard useCallback/stable function wherever possible
- *   (the purpose of useStableCallback is to bridge the gap between top level contexts
- *   and cascading rereders in downstream components - **not** as an escape hatch)
- * @param callback - the callback we want to stabilize
+ * Do not wrap a function that returns elements (such as FlatList's `renderItem`): React would not
+ * see an update when the callback changes. Prefer a plain `useCallback` where it works; this
+ * bridges top-level contexts and cascading re-renders in downstream components and is not an
+ * escape hatch.
+ *
+ * @param callback The callback to stabilize.
+ * @returns The stable callback.
  */
 export declare const useStableCallback: <A extends unknown[], R>(callback: StableCallback<A, R>) => StableCallback<A, R>;
 //# sourceMappingURL=useStableCallback.d.ts.map

package/lib/typescript/hooks/useStableCallback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useStableCallback.d.ts","sourceRoot":"","sources":["../../../src/hooks/useStableCallback.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EACtD,UAAU,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,KAC7B,cAAc,CAAC,CAAC,EAAE,CAAC,CAOrB,CAAC"}
+{"version":3,"file":"useStableCallback.d.ts","sourceRoot":"","sources":["../../../src/hooks/useStableCallback.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;AAEvE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EACtD,UAAU,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,KAC7B,cAAc,CAAC,CAAC,EAAE,CAAC,CAOrB,CAAC"}

package/lib/typescript/hooks/useStreami18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useStreami18n.d.ts","sourceRoot":"","sources":["../../../src/hooks/useStreami18n.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAGhF,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AActD,eAAO,MAAM,aAAa,GAAI,eAAe,UAAU,KAAG,mBASzD,CAAC"}
+{"version":3,"file":"useStreami18n.d.ts","sourceRoot":"","sources":["../../../src/hooks/useStreami18n.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAGhF,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAYtD,eAAO,MAAM,aAAa,GAAI,eAAe,UAAU,KAAG,mBASzD,CAAC"}

package/lib/typescript/hooks/useTranslatedMessage.d.ts

@@ -1,6 +1,11 @@
 import type { LocalMessage, MessageResponse } from 'stream-chat';
 /**
- * `message` with its text swapped for the auto-translation into `userLanguage`, when there is one.
+ * Returns a copy of `message` with its text swapped for the auto-translation into `userLanguage`,
+ * when there is one. Deleted messages keep their text.
+ *
+ * @param message The message to translate.
+ * @param userLanguage The language to translate into.
+ * @returns The message copy, or `undefined` without a message.
  */
 export declare const getTranslatedMessage: (message: LocalMessage | MessageResponse | undefined, userLanguage: string) => {
     text: string;

package/lib/typescript/hooks/useTranslatedMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTranslatedMessage.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTranslatedMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAcjE;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAS,YAAY,GAAG,eAAe,GAAG,SAAS,EACnD,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAgBrB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,UAAU,YAAY,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAI5E,CAAC"}
+{"version":3,"file":"useTranslatedMessage.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTranslatedMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAWjE;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAS,YAAY,GAAG,eAAe,GAAG,SAAS,EACnD,cAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAgBrB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,UAAU,YAAY,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAI5E,CAAC"}

package/lib/typescript/hooks/useViewport.d.ts

@@ -1,9 +1,9 @@
 /**
- * A custom hook that provides functions to calculate dimensions based on
- * a percentage of the viewport height (vh) and viewport width (vw). It
- * dynamically updates dimensions on changes in device orientation.
+ * Returns `vh` and `vw` helpers that convert a percentage of the window height or width to points,
+ * updating when the window dimensions change.
  *
- * @returns {Object} An object containing functions vh and vw.
+ * @param rounded Rounds the results to whole points. Defaults to false.
+ * @returns An object with the `vh` and `vw` functions.
  */
 export declare const useViewport: (rounded?: boolean) => {
     vh: (percentageHeight: number) => number;

package/lib/typescript/hooks/useWindowContentWidth.d.ts

@@ -1,21 +1,19 @@
 /**
  * Width available to a surface that spans the window, minus the horizontal safe area.
  *
- * Deliberately *not* measured. `onLayout` reports a frame after the window has already resized, so
- * anything sized from it - tile sizes in a grid, for instance - visibly resizes a frame late on a
- * rotation or a fold.
+ * The width is computed rather than measured: `onLayout` reports a frame after the window resizes,
+ * so anything sized from it (such as grid tiles) resizes a frame late on rotation or fold.
  *
- * The frame comes from `useSafeAreaFrame`, not `useWindowDimensions`: the frame and the insets are
- * delivered by the *same* native event and set in the same handler, so they update together in one
- * render. Mixing `Dimensions` with the insets desyncs them - the window width lands first and the
- * insets a render later, producing an extra intermediate size (and, for anything deriving an image
- * URL from it, an extra fetch).
+ * The frame comes from `useSafeAreaFrame`, not `useWindowDimensions`: the frame and the insets
+ * arrive in the same native event and update in one render. Mixing `Dimensions` with the insets
+ * lands the width a render before the insets, giving an extra intermediate size (and an extra fetch
+ * for anything that derives an image URL from it).
  *
- * Assumes the caller fills the window. A component rendered inside a narrower container must pass
- * that container's width via `containerWidth`, or measure it itself and accept the frame of lag
- * that comes with measuring.
+ * Assumes the caller fills the window. A component inside a narrower container passes that
+ * container's width via `containerWidth`.
  *
  * @param containerWidth Width of the surface, when it is known and narrower than the window.
+ * @returns The available width.
  *
  * @example
  * const contentWidth = useWindowContentWidth();

package/lib/typescript/hooks/useWindowContentWidth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useWindowContentWidth.d.ts","sourceRoot":"","sources":["../../../src/hooks/useWindowContentWidth.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,qBAAqB,GAAI,iBAAiB,MAAM,WAK5D,CAAC"}
+{"version":3,"file":"useWindowContentWidth.d.ts","sourceRoot":"","sources":["../../../src/hooks/useWindowContentWidth.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,qBAAqB,GAAI,iBAAiB,MAAM,WAK5D,CAAC"}