stream-chat-react 14.7.0 → 14.8.0

package/dist/types/a11y/accessibleLabel.d.ts

@@ -0,0 +1,38 @@
+import type { TranslationContextValue } from '../context/TranslationContext';
+/** Produces one segment of a composed accessible name; return `undefined`/empty to omit it. */
+export type AccessibleLabelPart<TData> = (data: TData) => string | undefined;
+/** Customization for a part-composed accessible name (the channel/thread list-row labels). */
+export type AccessibleLabelConfig<TData> = {
+    /** Full override — return the entire label; ignores `order`/`parts`/`separator`. */
+    build?: (data: TData) => string;
+    /** Which parts to include, in what order. A part not listed here is never rendered. */
+    order?: ReadonlyArray<string>;
+    /** Override or add individual part generators; merged over the defaults. */
+    parts?: Record<string, AccessibleLabelPart<TData>>;
+    /** Joiner between non-empty parts. Defaults to ". ". */
+    separator?: string;
+};
+/**
+ * Composes a single accessible name from named parts: applies `config.build` if present, otherwise
+ * merges `config.parts` over `defaultParts`, walks `config.order ?? defaultOrder`, and joins the
+ * non-empty segments with `config.separator ?? '. '`. Shared by the channel and thread list-row
+ * labels so the assembly logic lives in one place.
+ */
+export declare const composeAccessibleLabel: <TData>(data: TData, defaultParts: Record<string, AccessibleLabelPart<TData>>, defaultOrder: ReadonlyArray<string>, config?: AccessibleLabelConfig<TData>) => string;
+type WithT = {
+    t: TranslationContextValue['t'];
+};
+/**
+ * Announces the active (currently open) row. The active state is announced here (not left to the
+ * row's `aria-selected` alone, which is not reliably spoken across screen readers for an option with
+ * a custom name); `aria-selected` is kept on the active row for listbox semantics.
+ */
+export declare const activeLabelPart: AccessibleLabelPart<WithT & {
+    active?: boolean;
+}>;
+/** Announces the unread count when there is one. */
+export declare const unreadCountLabelPart: AccessibleLabelPart<WithT & {
+    unreadCount?: number;
+}>;
+export {};
+//# sourceMappingURL=accessibleLabel.d.ts.map

package/dist/types/a11y/accessibleLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessibleLabel.d.ts","sourceRoot":"","sources":["../../../src/a11y/accessibleLabel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAE7E,+FAA+F;AAC/F,MAAM,MAAM,mBAAmB,CAAC,KAAK,IAAI,CAAC,IAAI,EAAE,KAAK,KAAK,MAAM,GAAG,SAAS,CAAC;AAE7E,8FAA8F;AAC9F,MAAM,MAAM,qBAAqB,CAAC,KAAK,IAAI;IACzC,oFAAoF;IACpF,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,MAAM,CAAC;IAChC,uFAAuF;IACvF,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9B,4EAA4E;IAC5E,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC;IACnD,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,KAAK,EAC1C,MAAM,KAAK,EACX,cAAc,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,KAAK,CAAC,CAAC,EACxD,cAAc,aAAa,CAAC,MAAM,CAAC,EACnC,SAAQ,qBAAqB,CAAC,KAAK,CAAM,KACxC,MAWF,CAAC;AAIF,KAAK,KAAK,GAAG;IAAE,CAAC,EAAE,uBAAuB,CAAC,GAAG,CAAC,CAAA;CAAE,CAAC;AAEjD;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,mBAAmB,CAAC,KAAK,GAAG;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,CAGjC,CAAC;AAE9C,oDAAoD;AACpD,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,CACpD,KAAK,GAAG;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAInB,CAAC"}

package/dist/types/a11y/hooks/useListboxKeyboardNavigation.d.ts

@@ -0,0 +1,73 @@
+import type { KeyboardEvent as ReactKeyboardEvent, RefObject } from 'react';
+/** State handed to a {@link ListboxKeyHandler} when its key is pressed inside the container. */
+export type ListboxNavigationContext = {
+    /** The focused element — guaranteed to be inside the container. */
+    active: HTMLElement;
+    /** The listbox container element. */
+    container: HTMLElement;
+    /** The current option elements (live). */
+    getOptions: () => HTMLElement[];
+    /** Whether {@link ListboxNavigationContext.active} is itself an option. */
+    onOption: boolean;
+};
+/**
+ * Handler for a non-roving key. Return `true` if it handled the key — the hook then
+ * `preventDefault()`s and `stopPropagation()`s so nothing else acts on it. Return nothing to let the
+ * key fall through (default behaviour preserved).
+ */
+export type ListboxKeyHandler = (context: ListboxNavigationContext) => boolean | void;
+export type ListboxKeyboardNavigationConfig = {
+    /**
+     * Where the roving (vertical) keys are active:
+     * - `'option'` (default): only when focus is already on an option — a plain listbox.
+     * - `'container'`: anywhere inside the container, so focus can enter the list from a preceding
+     *   control (e.g. a filter tag); when not on an option, Down/Home land on the first, Up/End on the
+     *   last.
+     */
+    enterScope?: 'container' | 'option';
+    /**
+     * Extra keys to handle, beyond the built-in roving. Mapped by `event.key` to a handler that
+     * receives the current {@link ListboxNavigationContext} and decides what to do. The hook does not
+     * prescribe any particular keys (e.g. ArrowRight to reach a row's actions) — compose what you need,
+     * optionally with {@link createRowActionKeyHandlers}. Roving keys (Up/Down/Home/End) are reserved.
+     */
+    keyHandlers?: Record<string, ListboxKeyHandler>;
+    /** Selector for the navigable options. Default `[role="option"]`. */
+    optionSelector?: string;
+    /**
+     * Maps the focused element to the option that vertical roving (Up/Down/Home/End) should move
+     * relative to. Use with `enterScope: 'container'` so those keys work while focus is on something
+     * inside an option's row (e.g. its action buttons) and step to the next/previous option from that
+     * row, rather than jumping to the first/last. Return `null` to fall back to that default.
+     */
+    resolveActiveOption?: (active: HTMLElement) => HTMLElement | null;
+};
+/**
+ * Keyboard navigation for a list of options (the channel list, the search results, …). Returns an
+ * `onKeyDown` to spread onto the container plus `getOptions` for callers that need the current
+ * options (e.g. load-more focus management):
+ * - **ArrowUp/ArrowDown/Home/End** rove the options (scope set by `enterScope`).
+ * - any other key listed in `keyHandlers` is delegated to its handler.
+ *
+ * For keys, it handles it `stopPropagation()`s, so it stays authoritative — nothing downstream (a
+ * parent handler, or the browser/AT "jump to first/last focusable" fallback) can move focus to a
+ * non-option. Stateless — safe to call on every render; the handlers read the DOM live.
+ */
+export declare const useListboxKeyboardNavigation: (containerRef: RefObject<HTMLElement | null>, { enterScope, keyHandlers, optionSelector, resolveActiveOption, }?: ListboxKeyboardNavigationConfig) => {
+    getOptions: () => HTMLElement[];
+    onKeyDown: (event: ReactKeyboardEvent<HTMLElement>) => void;
+};
+/**
+ * Composable {@link ListboxKeyHandler}s for the "each option sits in a row alongside one or more
+ * action targets" pattern (e.g. a channel row + its actions/menu buttons). The option and its
+ * actions form one **horizontal cyclic group** in DOM order: from the option **ArrowRight** enters
+ * the actions; **ArrowLeft/ArrowRight** move between the actions; stepping off either end returns to
+ * the option (so the actions need not be in the Tab order). Rows with no actions (a lone option)
+ * leave the keys unhandled. Pass the result as (part of) `keyHandlers`.
+ */
+export declare const createRowActionKeyHandlers: ({ actionSelector, optionSelector, rowSelector, }: {
+    actionSelector: string;
+    optionSelector?: string;
+    rowSelector: string;
+}) => Record<string, ListboxKeyHandler>;
+//# sourceMappingURL=useListboxKeyboardNavigation.d.ts.map

package/dist/types/a11y/hooks/useListboxKeyboardNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useListboxKeyboardNavigation.d.ts","sourceRoot":"","sources":["../../../../src/a11y/hooks/useListboxKeyboardNavigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,kBAAkB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAO5E,gGAAgG;AAChG,MAAM,MAAM,wBAAwB,GAAG;IACrC,mEAAmE;IACnE,MAAM,EAAE,WAAW,CAAC;IACpB,qCAAqC;IACrC,SAAS,EAAE,WAAW,CAAC;IACvB,0CAA0C;IAC1C,UAAU,EAAE,MAAM,WAAW,EAAE,CAAC;IAChC,2EAA2E;IAC3E,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,EAAE,wBAAwB,KAAK,OAAO,GAAG,IAAI,CAAC;AAEtF,MAAM,MAAM,+BAA+B,GAAG;IAC5C;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,WAAW,GAAG,QAAQ,CAAC;IACpC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAChD,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,WAAW,GAAG,IAAI,CAAC;CACnE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GACvC,cAAc,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EAC3C,oEAKG,+BAAoC;;uBAKb,kBAAkB,CAAC,WAAW,CAAC;CAwC1D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,GAAI,kDAIxC;IACD,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;CACrB,KAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAkBnC,CAAC"}

package/dist/types/a11y/hooks/useVirtualizedListboxKeyboardNavigation.d.ts

@@ -0,0 +1,41 @@
+import type { KeyboardEvent as ReactKeyboardEvent, RefObject } from 'react';
+export type VirtualizedListboxKeyboardNavigationParams<T> = {
+    /** Stable id for an item; must equal the value the item's option carries in `itemIdAttribute`. */
+    getItemId: (item: T) => string;
+    /**
+     * The attribute every option carries its id in (e.g. `'data-thread-id'`). Used both to read the id
+     * off the focused element and to locate the target option in the DOM.
+     */
+    itemIdAttribute: string;
+    /** The full, unvirtualized list — NOT just the rendered window. Roving indexes into this. */
+    items: T[];
+    /** Selector for the focusable option elements. Default `[role="option"]`. */
+    optionSelector?: string;
+    /**
+     * Bring the item at `index` into the rendered window, then invoke `onRendered` once it should be in
+     * the DOM. For a virtualized list wrap the list's imperative scroll (e.g. Virtuoso's
+     * `scrollIntoView({ index, done: onRendered })`); for a non-virtualized list just call
+     * `onRendered()`.
+     */
+    scrollIndexIntoView: (index: number, onRendered: () => void) => void;
+    /** Ref to the scrollable listbox container whose subtree holds the rendered options. */
+    scrollerRef: RefObject<HTMLElement | null>;
+};
+/**
+ * Vertical roving-focus keyboard navigation (ArrowUp/Down/Home/End) for a **virtualized** listbox,
+ * where only a window of `role="option"` rows exists in the DOM at a time.
+ *
+ * A DOM-query-and-`.focus()` approach (see {@link useListboxKeyboardNavigation}) can't work here: it
+ * would only ever see the rendered window, so it would cycle within those rows and never scroll the
+ * rest of the list into view. This hook instead indexes into the **full** `items` array, focuses the
+ * target row if it is already rendered, and otherwise asks the list to scroll it into existence
+ * (`scrollIndexIntoView`) and focuses it once painted (retrying across a few frames).
+ *
+ * Returns an `onKeyDown` to spread onto the scroll container (the `role="listbox"` element). The
+ * caller wires `scrollerRef` to that same element and provides `scrollIndexIntoView`. Stateless — the
+ * active row is read live from `document.activeElement` on each key.
+ */
+export declare const useVirtualizedListboxKeyboardNavigation: <T>({ getItemId, itemIdAttribute, items, optionSelector, scrollerRef, scrollIndexIntoView, }: VirtualizedListboxKeyboardNavigationParams<T>) => {
+    onKeyDown: (event: ReactKeyboardEvent<HTMLElement>) => void;
+};
+//# sourceMappingURL=useVirtualizedListboxKeyboardNavigation.d.ts.map

package/dist/types/a11y/hooks/useVirtualizedListboxKeyboardNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVirtualizedListboxKeyboardNavigation.d.ts","sourceRoot":"","sources":["../../../../src/a11y/hooks/useVirtualizedListboxKeyboardNavigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,kBAAkB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAc5E,MAAM,MAAM,0CAA0C,CAAC,CAAC,IAAI;IAC1D,kGAAkG;IAClG,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;IAC/B;;;OAGG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB,6FAA6F;IAC7F,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,6EAA6E;IAC7E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,mBAAmB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACrE,wFAAwF;IACxF,WAAW,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;CAC5C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uCAAuC,GAAI,CAAC,EAAE,0FAOxD,0CAA0C,CAAC,CAAC,CAAC;uBAsCpC,kBAAkB,CAAC,WAAW,CAAC;CAsC1C,CAAC"}

package/dist/types/components/Accessibility/AriaLiveAnnouncerProvider.d.ts

@@ -0,0 +1,13 @@
+import type { PropsWithChildren } from 'react';
+/**
+ * Owns the aria-live announcement state and the announce() API for one logical announcer
+ * (mount ONE per `Chat`). It renders no DOM region itself — the messages are painted by the
+ * single active {@link AriaLiveOutlet} chosen from the registered outlet stack (innermost /
+ * highest-layer wins). This is the L1 sink of the unified announcer model; see
+ * `specs/a11y-react-web/decisions.md` → "Unify the aria-live announcer implementations".
+ *
+ * All state lives here (per provider instance), never in module scope, so multiple `Chat`
+ * instances on one page never share announcements.
+ */
+export declare const AriaLiveAnnouncerProvider: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AriaLiveAnnouncerProvider.d.ts.map

package/dist/types/components/Accessibility/AriaLiveAnnouncerProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AriaLiveAnnouncerProvider.d.ts","sourceRoot":"","sources":["../../../../src/components/Accessibility/AriaLiveAnnouncerProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AA0B/C;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GAAI,cAAc,iBAAiB,4CAgMxE,CAAC"}

package/dist/types/components/Accessibility/AriaLiveOutlet.d.ts

@@ -0,0 +1,24 @@
+export type AriaLiveOutletProps = {
+    /**
+     * Stacking layer. The {@link AriaLiveAnnouncerProvider} renders into the highest-layer
+     * outlet (ties resolve to the most recently registered). Outlets inside an `aria-modal`
+     * subtree must use a layer above the root outlet so announcements land inside the modal
+     * (assistive technologies suppress live regions outside the active modal). Defaults to `0`.
+     */
+    layer?: number;
+    /**
+     * When true, render the live region into a `document.body` portal instead of in place.
+     * Use for the root outlet; modal outlets must render in place (omit) so they stay inside
+     * the `aria-modal` subtree.
+     */
+    portal?: boolean;
+};
+/**
+ * Dumb render target for the unified announcer. Registers itself with the nearest
+ * {@link AriaLiveAnnouncerProvider} and renders the polite/assertive live regions ONLY when
+ * it is the active (innermost) outlet, so exactly one region is live at a time — always in
+ * the active accessibility-tree scope. Mount one at the `Chat` root and one inside each
+ * `aria-modal` dialog (with a higher `layer`).
+ */
+export declare const AriaLiveOutlet: ({ layer, portal }: AriaLiveOutletProps) => import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=AriaLiveOutlet.d.ts.map

package/dist/types/components/Accessibility/AriaLiveOutlet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AriaLiveOutlet.d.ts","sourceRoot":"","sources":["../../../../src/components/Accessibility/AriaLiveOutlet.tsx"],"names":[],"mappings":"AAMA,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,mBAA+B,mBAAmB,mDA2DhF,CAAC"}

package/dist/types/components/Accessibility/AriaLiveOutletContext.d.ts

@@ -0,0 +1,25 @@
+import type { AriaLivePriority } from './useAriaLiveAnnouncer';
+export type LiveAnnouncement = {
+    id: number;
+    message: string;
+};
+export type AnnouncementsByPriority = {
+    [key in AriaLivePriority]: LiveAnnouncement[];
+};
+/**
+ * Internal coordination context between {@link AriaLiveAnnouncerProvider} (which owns the
+ * announcement state and the outlet stack) and the {@link AriaLiveOutlet}s that render the
+ * live regions. Not part of the public API — consumers announce via `useAriaLiveAnnouncer`.
+ */
+export type AriaLiveOutletContextValue = {
+    /** The id of the single outlet that should currently render the live regions. */
+    activeOutletId: symbol | null;
+    /** Current announcements grouped by aria-live priority. */
+    announcementsByPriority: AnnouncementsByPriority;
+    /** Register an outlet. Higher `layer` wins; ties resolve to the most recently registered. */
+    registerOutlet: (id: symbol, layer: number) => void;
+    unregisterOutlet: (id: symbol) => void;
+};
+export declare const AriaLiveOutletContext: import("react").Context<AriaLiveOutletContextValue | undefined>;
+export declare const useAriaLiveOutletContext: () => AriaLiveOutletContextValue | undefined;
+//# sourceMappingURL=AriaLiveOutletContext.d.ts.map

package/dist/types/components/Accessibility/AriaLiveOutletContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AriaLiveOutletContext.d.ts","sourceRoot":"","sources":["../../../../src/components/Accessibility/AriaLiveOutletContext.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;KACnC,GAAG,IAAI,gBAAgB,GAAG,gBAAgB,EAAE;CAC9C,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,iFAAiF;IACjF,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,2DAA2D;IAC3D,uBAAuB,EAAE,uBAAuB,CAAC;IACjD,6FAA6F;IAC7F,cAAc,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACpD,gBAAgB,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC,CAAC;AAEF,eAAO,MAAM,qBAAqB,iEAEtB,CAAC;AAEb,eAAO,MAAM,wBAAwB,8CAA0C,CAAC"}

package/dist/types/components/Accessibility/NotificationAnnouncer.d.ts

@@ -10,5 +10,25 @@ export type NotificationAnnouncerProps = {
     buildNotificationAnnouncement?: NotificationAnnouncementBuilder;
     notificationFilter?: NotificationAnnouncementFilter;
 };
-export declare const NotificationAnnouncer: ({ buildNotificationAnnouncement, notificationFilter, }: NotificationAnnouncerProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Announces app notifications to assistive technology.
+ *
+ * As of the announcer unification this renders **no live region of its own** — it routes new
+ * notifications through the shared {@link useAriaLiveAnnouncer} sink (so they land in the active
+ * {@link AriaLiveOutlet}, including inside an open modal) and paces them with
+ * {@link useAnnouncementQueue}.
+ *
+ * ## Required context (contract)
+ * `NotificationAnnouncer` **must** be rendered inside an `AriaLiveAnnouncerProvider`. `Chat` mounts
+ * that provider (with a root, portalled `AriaLiveOutlet`), so the default component tree already
+ * satisfies this and no extra setup is needed.
+ *
+ * Rendered **without** a provider ancestor it mounts successfully but **announces nothing** —
+ * `useAriaLiveAnnouncer()` returns a no-op and logs a `console.warn` ("… called outside of an
+ * AriaLiveAnnouncerProvider"). This is intentional post-F4: the component no longer carries a
+ * fallback live region, so a single announcer owns all output and there are no duplicate/competing
+ * regions. If you render it outside `Chat`, wrap it in `AriaLiveAnnouncerProvider` + `AriaLiveOutlet`
+ * yourself.
+ */
+export declare const NotificationAnnouncer: ({ buildNotificationAnnouncement, notificationFilter, }: NotificationAnnouncerProps) => null;
 //# sourceMappingURL=NotificationAnnouncer.d.ts.map

package/dist/types/components/Accessibility/NotificationAnnouncer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NotificationAnnouncer.d.ts","sourceRoot":"","sources":["../../../../src/components/Accessibility/NotificationAnnouncer.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAchD,MAAM,MAAM,qCAAqC,GAAG;IAClD,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAC5C,MAAM,EAAE,qCAAqC,KAC1C,MAAM,CAAC;AACZ,MAAM,MAAM,8BAA8B,GAAG,CAAC,YAAY,EAAE,YAAY,KAAK,OAAO,CAAC;AAuBrF,MAAM,MAAM,0BAA0B,GAAG;IACvC,6BAA6B,CAAC,EAAE,+BAA+B,CAAC;IAChE,kBAAkB,CAAC,EAAE,8BAA8B,CAAC;CACrD,CAAC;AAOF,eAAO,MAAM,qBAAqB,GAAI,wDAGnC,0BAA0B,4CA4H5B,CAAC"}
+{"version":3,"file":"NotificationAnnouncer.d.ts","sourceRoot":"","sources":["../../../../src/components/Accessibility/NotificationAnnouncer.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAQhD,MAAM,MAAM,qCAAqC,GAAG;IAClD,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAC5C,MAAM,EAAE,qCAAqC,KAC1C,MAAM,CAAC;AACZ,MAAM,MAAM,8BAA8B,GAAG,CAAC,YAAY,EAAE,YAAY,KAAK,OAAO,CAAC;AAoBrF,MAAM,MAAM,0BAA0B,GAAG;IACvC,6BAA6B,CAAC,EAAE,+BAA+B,CAAC;IAChE,kBAAkB,CAAC,EAAE,8BAA8B,CAAC;CACrD,CAAC;AAOF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,qBAAqB,GAAI,wDAGnC,0BAA0B,SAuD5B,CAAC"}

package/dist/types/components/Accessibility/hooks/useAudioPlaybackChangeAnnouncements.d.ts

@@ -0,0 +1,3 @@
+import type { AudioPlayer } from '../../AudioPlayback';
+export declare const useAudioPlaybackChangeAnnouncements: (audioPlayer: AudioPlayer | undefined) => void;
+//# sourceMappingURL=useAudioPlaybackChangeAnnouncements.d.ts.map

package/dist/types/components/Accessibility/hooks/useAudioPlaybackChangeAnnouncements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAudioPlaybackChangeAnnouncements.d.ts","sourceRoot":"","sources":["../../../../../src/components/Accessibility/hooks/useAudioPlaybackChangeAnnouncements.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAoB,MAAM,qBAAqB,CAAC;AASzE,eAAO,MAAM,mCAAmC,GAC9C,aAAa,WAAW,GAAG,SAAS,SAsBrC,CAAC"}

package/dist/types/components/Accessibility/hooks/useFocusReturn.d.ts

@@ -0,0 +1,44 @@
+export type ReserveFocusReturnOptions = {
+    /**
+     * Explicit element focus should return to. Defaults to the current
+     * `document.activeElement` (the natural "origin" — e.g. the composer when a
+     * transient surface steals focus). Provide this when the desired return target
+     * is NOT where focus currently is. A non-focusable value (or `document.body`)
+     * reserves nothing.
+     */
+    target?: HTMLElement | null;
+};
+export type UseFocusReturnResult = {
+    /**
+     * Capture the element focus should return to. Called with no argument it
+     * captures the current `document.activeElement`; pass `{ target }` to override.
+     * Options is an object for forward-compatibility (future flags add fields here
+     * without changing the call signature).
+     */
+    reserve: (options?: ReserveFocusReturnOptions) => void;
+    /**
+     * Move focus back to the reserved element (if it is still connected) and clear
+     * the reservation. No-op when nothing was reserved or the element is gone.
+     * Focuses synchronously — defer announcements yourself if you need the focus
+     * announcement to be spoken first.
+     */
+    restore: () => void;
+};
+/**
+ * Generic focus-restoration primitive: capture-before-steal, restore-on-finish —
+ * the pattern dialogs/popovers use. A transient surface (e.g. the Giphy preview)
+ * `reserve()`s before it moves focus into itself, then `restore()`s when it
+ * completes, returning focus to wherever it was — WITHOUT the surface knowing or
+ * naming that element (no coupling to "the composer").
+ *
+ * Single-candidate by design: each consumer holds its own reservation in a ref,
+ * so concurrent/nested transient surfaces never clobber each other (each restores
+ * its own origin). There is one `document.activeElement` at a time, and these
+ * flows are mutually exclusive, so no shared slot/stack/key registry is needed.
+ * If a cross-component rendezvous or deep nesting ever appears, a stack (nesting)
+ * or coarse typed keys (rendezvous) can be added without changing this API.
+ *
+ * React 17/18/19 compatible — `useRef`/`useCallback` only.
+ */
+export declare const useFocusReturn: () => UseFocusReturnResult;
+//# sourceMappingURL=useFocusReturn.d.ts.map

package/dist/types/components/Accessibility/hooks/useFocusReturn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFocusReturn.d.ts","sourceRoot":"","sources":["../../../../../src/components/Accessibility/hooks/useFocusReturn.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;;;OAKG;IACH,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,yBAAyB,KAAK,IAAI,CAAC;IACvD;;;;;OAKG;IACH,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAKF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,QAAO,oBAgBjC,CAAC"}

package/dist/types/components/Accessibility/hooks/useInertWhenHidden.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The set of props returned by {@link useInertWhenHidden}, to be spread onto the
+ * element that must remain mounted while visually hidden.
+ *
+ * `inert` is typed as `boolean | undefined` so the object spreads cleanly onto a
+ * JSX host element (React 19 types `inert?: boolean`; React 17/18 don't declare
+ * it at all, so an extra prop via spread is accepted). The RUNTIME value differs
+ * by React major version (string `'true'` on 17/18) — see the implementation
+ * note on {@link useInertWhenHidden} — and is cast to `boolean` at the source so
+ * the public type stays spread-safe. Consumers spread it; they never read it.
+ */
+export type InertWhenHiddenProps = {
+    'aria-hidden': true | undefined;
+    hidden: boolean | undefined;
+    inert: boolean | undefined;
+    tabIndex: number | undefined;
+};
+/**
+ * Options for {@link useInertWhenHidden}.
+ */
+export type UseInertWhenHiddenOptions = {
+    /**
+     * Whether to set the HTML `hidden` attribute (which applies `display: none`)
+     * when `hidden` is `true`. Defaults to `true`.
+     *
+     * Set to `false` for elements whose visual hiding is already handled by CSS
+     * (e.g. an opacity/scale/`max-width` transition) — the `hidden` attribute
+     * would force `display: none` and kill the transition. With `false`, the hook
+     * still applies `aria-hidden`, `inert`, and `tabIndex={-1}` so the element is
+     * removed from the accessibility tree and tab order while staying laid out.
+     */
+    setHiddenAttribute?: boolean;
+};
+/**
+ * Canonical way to fully hide a control from assistive technology AND the tab
+ * order while it must stay mounted.
+ *
+ * @remarks
+ * **Prefer not rendering.** The simplest and most robust fix for a control that
+ * should be unavailable is to *not render it at all* when it is hidden. Reach
+ * for this hook only when the element MUST stay mounted — e.g. to preserve
+ * internal state, layout measurements, or enter/exit transitions.
+ *
+ * @example
+ * ```tsx
+ * const Toolbar = ({ collapsed }: { collapsed: boolean }) => {
+ *   const inertProps = useInertWhenHidden(collapsed);
+ *   return <button {...inertProps}>Add attachment</button>;
+ * };
+ * ```
+ *
+ * When `hidden === true`, the returned props make the element:
+ * - absent from the accessibility tree (`aria-hidden`, `hidden`),
+ * - unreachable via Tab (`tabIndex={-1}`, `inert`),
+ * - non-interactive (`inert`).
+ *
+ * When `hidden === false`, every returned attribute is `undefined`, so spreading
+ * the object is a no-op and the element behaves exactly as normal. In
+ * particular, `aria-hidden` is omitted entirely (never emitted as
+ * `aria-hidden="false"`).
+ *
+ * Exact attribute values rendered to the DOM:
+ * - hidden: `aria-hidden=""(true)`, `hidden`, `tabindex="-1"`, `inert`
+ * - shown:  none of the above attributes present
+ *
+ * **Cross-React-version handling of `inert`:** React 19 supports `inert` as a
+ * native boolean prop (`inert={true}` → DOM `inert=""`). React 17/18 do not
+ * recognize it and only forward it as a string (`inert="true"` → DOM
+ * `inert="true"`). Either of the *other* forms (a boolean on React 17/18, or an
+ * empty string on React 19) emits a console warning and/or drops the attribute.
+ * We therefore pick the correct form per major version via `React.version`. The
+ * resulting DOM attribute is present and falls back to `tabIndex={-1}` +
+ * `aria-hidden` on the rare engines lacking `inert` support.
+ *
+ * **Styling is out of scope.** The HTML `hidden` attribute applies
+ * `display: none`. If a consumer needs the element to remain *visible in the
+ * layout* (e.g. hidden purely via CSS or kept for transitions), pass
+ * `{ setHiddenAttribute: false }` so the `hidden` attribute is omitted while the
+ * a11y/focus semantics (`aria-hidden`, `inert`, `tabIndex={-1}`) still apply.
+ * The remaining styling is then the consumer's concern.
+ *
+ * @param hidden Whether the control is currently hidden.
+ * @param options Behavior options — see {@link UseInertWhenHiddenOptions}. Use
+ *   `{ setHiddenAttribute: false }` for elements hidden via CSS/transition.
+ * @returns A stable, memoized props object to spread onto the element.
+ */
+export declare const useInertWhenHidden: (hidden: boolean, options?: UseInertWhenHiddenOptions) => InertWhenHiddenProps;
+//# sourceMappingURL=useInertWhenHidden.d.ts.map

package/dist/types/components/Accessibility/hooks/useInertWhenHidden.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInertWhenHidden.d.ts","sourceRoot":"","sources":["../../../../../src/components/Accessibility/hooks/useInertWhenHidden.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,aAAa,EAAE,IAAI,GAAG,SAAS,CAAC;IAChC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B,KAAK,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B,CAAC;AAqCF;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;;;;;;;OASG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,OAAO,EACf,UAAU,yBAAyB,KAClC,oBAMF,CAAC"}

package/dist/types/components/Accessibility/hooks/useInteractionAnnouncements.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Optional delivery overrides a call site may pass ALONGSIDE an interaction's message params.
+ * These are not consumed by the message resolver — they only affect how the announcement is
+ * delivered. `debounceMs` overrides that interaction's default debounce ({@link
+ * INTERACTION_DEBOUNCE_MS}) for THIS call, and enables debouncing for an interaction that has no
+ * default. `delayMs` overrides the default delay ({@link INTERACTION_DELAY_MS}) for the
+ * (non-debounced) immediate path. Param-less (discrete) interactions are always immediate and do
+ * not accept overrides.
+ *
+ * `debounceMs` vs `delayMs`: a debounce collapses rapid repeats on a per-call-site timer and is
+ * **cancelled if that call site unmounts** — right for a value that keeps changing in place (a
+ * result count). `delayMs` schedules a single deferred emit in the shared announcer PROVIDER, so it
+ * **survives the caller unmounting** — right for a one-shot confirmation whose origin (e.g. a list
+ * row) disappears on the very action being confirmed (opening a channel/thread hides the list on
+ * mobile). Both let the message land after a competing focus/typing read-out. `debounceMs` wins if
+ * both are given.
+ */
+export type InteractionDeliveryOptions = {
+    debounceMs?: number;
+    delayMs?: number;
+};
+/**
+ * Parameters accepted by each parameterized interaction announcement.
+ * Interactions that take no parameters map to `undefined`. Param-ful interactions additionally
+ * accept {@link InteractionDeliveryOptions} (e.g. a per-call `debounceMs`).
+ */
+export type InteractionAnnouncementParams = {
+    /** Audio playback speed was changed via the playback-rate button. `rate` is the new multiplier. */
+    'audioPlayer.playbackRateChanged': InteractionDeliveryOptions & {
+        rate: number;
+    };
+    /** A channel was opened from the channel list. `name` is its display title. */
+    'channel.opened': InteractionDeliveryOptions & {
+        name: string;
+    };
+    /** A slash command was activated from the Instant Commands menu. `command` is its name. */
+    'command.selected': InteractionDeliveryOptions & {
+        command: string;
+    };
+    'giphy.canceled': undefined;
+    'giphy.sent': undefined;
+    'giphy.shuffled': InteractionDeliveryOptions & {
+        title?: string;
+    };
+    'poll.dialogOpened': undefined;
+    /** A poll option was dropped at a new position during keyboard reorder. */
+    'poll.optionDropped': InteractionDeliveryOptions & {
+        option: string;
+        position: number;
+    };
+    /** A poll option was picked up to start a keyboard reorder. `option` is its text (or a fallback). */
+    'poll.optionPickedUp': InteractionDeliveryOptions & {
+        option: string;
+    };
+    'poll.optionRemoved': InteractionDeliveryOptions & {
+        option: string;
+    };
+    'poll.sent': undefined;
+    'search.cleared': undefined;
+    'search.resultCount': InteractionDeliveryOptions & {
+        /** Whether every active source is fully loaded — appends an "all results loaded" clause. */
+        allResultsLoaded?: boolean;
+        count: number;
+    };
+    'suggestions.count': InteractionDeliveryOptions & {
+        count: number;
+        suggestionsLabel?: string;
+    };
+    /** A thread was opened from the thread list. `name` is its channel's display title. */
+    'thread.opened': InteractionDeliveryOptions & {
+        name: string;
+    };
+    'user.selected': InteractionDeliveryOptions & {
+        user: string;
+    };
+    /** A finished voice recording was added to the composer (async multi-send: not sent yet). */
+    'voiceRecording.attached': undefined;
+    'voiceRecording.paused': undefined;
+    'voiceRecording.resumed': undefined;
+    /** A finished voice recording was sent immediately as a message. */
+    'voiceRecording.sent': undefined;
+    'voiceRecording.started': undefined;
+};
+export type InteractionAnnouncementType = keyof InteractionAnnouncementParams;
+type AnnounceInteraction = {
+    <T extends InteractionAnnouncementType>(interaction: InteractionAnnouncementParams[T] extends undefined ? T : never): void;
+    <T extends InteractionAnnouncementType>(interaction: InteractionAnnouncementParams[T] extends undefined ? never : T, params: InteractionAnnouncementParams[T]): void;
+};
+export type UseInteractionAnnouncementsValue = {
+    /**
+     * Announce a predefined interaction event to assistive technology. The
+     * interaction name maps to a localized message and a baked-in aria-live
+     * priority.
+     */
+    announceInteraction: AnnounceInteraction;
+    /**
+     * Cancel pending (debounced, not-yet-spoken) announcements: a single `interaction`, or all when
+     * omitted. Call this when the source of a debounced announcement is torn down (e.g. search exited)
+     * so a queued message is not spoken after its context is gone. An announcement already emitted into
+     * the live region cannot be recalled.
+     */
+    cancelInteraction: (interaction?: InteractionAnnouncementType) => void;
+};
+/**
+ * Thin, typed wrapper over the aria-live announcer exposing intention-revealing
+ * helpers for transient, user-initiated UI interactions (e.g. a Giphy being
+ * sent, a poll being created, a mention being picked). They map to i18n keys with
+ * baked-in priorities and reuse the existing live region via
+ * {@link useAriaLiveAnnouncer}. New interactions are registered as a single entry
+ * in {@link INTERACTION_MESSAGES}.
+ */
+export declare const useInteractionAnnouncements: () => UseInteractionAnnouncementsValue;
+export {};
+//# sourceMappingURL=useInteractionAnnouncements.d.ts.map

package/dist/types/components/Accessibility/hooks/useInteractionAnnouncements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInteractionAnnouncements.d.ts","sourceRoot":"","sources":["../../../../../src/components/Accessibility/hooks/useInteractionAnnouncements.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,0BAA0B,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnF;;;;GAIG;AACH,MAAM,MAAM,6BAA6B,GAAG;IAC1C,mGAAmG;IACnG,iCAAiC,EAAE,0BAA0B,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACjF,+EAA+E;IAC/E,gBAAgB,EAAE,0BAA0B,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAChE,2FAA2F;IAC3F,kBAAkB,EAAE,0BAA0B,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACrE,gBAAgB,EAAE,SAAS,CAAC;IAC5B,YAAY,EAAE,SAAS,CAAC;IACxB,gBAAgB,EAAE,0BAA0B,GAAG;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAClE,mBAAmB,EAAE,SAAS,CAAC;IAC/B,2EAA2E;IAC3E,oBAAoB,EAAE,0BAA0B,GAAG;QACjD,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,qGAAqG;IACrG,qBAAqB,EAAE,0BAA0B,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACvE,oBAAoB,EAAE,0BAA0B,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE,WAAW,EAAE,SAAS,CAAC;IACvB,gBAAgB,EAAE,SAAS,CAAC;IAC5B,oBAAoB,EAAE,0BAA0B,GAAG;QACjD,4FAA4F;QAC5F,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAC3B,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,mBAAmB,EAAE,0BAA0B,GAAG;QAChD,KAAK,EAAE,MAAM,CAAC;QACd,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,uFAAuF;IACvF,eAAe,EAAE,0BAA0B,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/D,eAAe,EAAE,0BAA0B,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/D,6FAA6F;IAC7F,yBAAyB,EAAE,SAAS,CAAC;IACrC,uBAAuB,EAAE,SAAS,CAAC;IACnC,wBAAwB,EAAE,SAAS,CAAC;IACpC,oEAAoE;IACpE,qBAAqB,EAAE,SAAS,CAAC;IACjC,wBAAwB,EAAE,SAAS,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,MAAM,6BAA6B,CAAC;AAgL9E,KAAK,mBAAmB,GAAG;IACzB,CAAC,CAAC,SAAS,2BAA2B,EACpC,WAAW,EAAE,6BAA6B,CAAC,CAAC,CAAC,SAAS,SAAS,GAAG,CAAC,GAAG,KAAK,GAC1E,IAAI,CAAC;IACR,CAAC,CAAC,SAAS,2BAA2B,EACpC,WAAW,EAAE,6BAA6B,CAAC,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,CAAC,EAC3E,MAAM,EAAE,6BAA6B,CAAC,CAAC,CAAC,GACvC,IAAI,CAAC;CACT,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG;IAC7C;;;;OAIG;IACH,mBAAmB,EAAE,mBAAmB,CAAC;IACzC;;;;;OAKG;IACH,iBAAiB,EAAE,CAAC,WAAW,CAAC,EAAE,2BAA2B,KAAK,IAAI,CAAC;CACxE,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,QAAO,gCA6E9C,CAAC"}

package/dist/types/components/Accessibility/index.d.ts

@@ -1,5 +1,11 @@
-export * from './AriaLiveRegion';
+export * from './AriaLiveAnnouncerProvider';
+export * from './AriaLiveOutlet';
+export * from './AriaLiveOutletContext';
 export * from './NotificationAnnouncer';
+export * from './scheduling';
+export * from './hooks/useFocusReturn';
 export * from './hooks/useIncomingMessageAnnouncements';
+export * from './hooks/useInertWhenHidden';
+export * from './hooks/useInteractionAnnouncements';
 export * from './useAriaLiveAnnouncer';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/components/Accessibility/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/Accessibility/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yCAAyC,CAAC;AACxD,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/Accessibility/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAC7B,cAAc,wBAAwB,CAAC;AACvC,cAAc,yCAAyC,CAAC;AACxD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qCAAqC,CAAC;AACpD,cAAc,wBAAwB,CAAC"}

package/dist/types/components/Accessibility/scheduling/index.d.ts

@@ -0,0 +1,4 @@
+export * from './useAnnouncementQueue';
+export * from './useDebouncedAnnounce';
+export * from './useSettledAnnouncement';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/components/Accessibility/scheduling/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/Accessibility/scheduling/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC"}

package/dist/types/components/Accessibility/scheduling/useAnnouncementQueue.d.ts

@@ -0,0 +1,25 @@
+import type { AriaLiveAnnounce, AriaLivePriority } from '../useAriaLiveAnnouncer';
+export type QueuedAnnouncement = {
+    message: string;
+    priority?: AriaLivePriority;
+};
+export type UseAnnouncementQueueOptions = {
+    /** Minimum delay between successive announcements, in ms. Defaults to 150. */
+    gapMs?: number;
+};
+export type UseAnnouncementQueueResult = {
+    /** Enqueue an announcement. The first drains immediately; the rest are paced by `gapMs`. */
+    enqueue: (announcement: QueuedAnnouncement) => void;
+};
+/**
+ * L2 scheduling policy: announce queued messages one at a time, spaced by `gapMs`, through the
+ * provided `announce` (from `useAriaLiveAnnouncer`). Replaces per-consumer queue/timer
+ * bookkeeping (e.g. the old `NotificationAnnouncer` state machine). The unified announcer already
+ * appends a fresh node per call, so no "clear region first" trick is needed — the gap simply
+ * prevents successive messages from clobbering each other in the screen-reader buffer.
+ *
+ * React 17/18/19 compatible — `useCallback`/`useRef`/`useEffect` only. Pending timers and the
+ * queue are cleared on unmount.
+ */
+export declare const useAnnouncementQueue: (announce: AriaLiveAnnounce, { gapMs }?: UseAnnouncementQueueOptions) => UseAnnouncementQueueResult;
+//# sourceMappingURL=useAnnouncementQueue.d.ts.map

package/dist/types/components/Accessibility/scheduling/useAnnouncementQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnnouncementQueue.d.ts","sourceRoot":"","sources":["../../../../../src/components/Accessibility/scheduling/useAnnouncementQueue.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAElF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,8EAA8E;IAC9E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,4FAA4F;IAC5F,OAAO,EAAE,CAAC,YAAY,EAAE,kBAAkB,KAAK,IAAI,CAAC;CACrD,CAAC;AAIF;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,GAC/B,UAAU,gBAAgB,EAC1B,YAA4B,2BAAgC,KAC3D,0BAwCF,CAAC"}