@fluentui/react-toast 0.0.0-nightly-20230704-0416.1

package/dist/index.d.ts

@@ -0,0 +1,485 @@
+/// <reference types="react" />
+
+import { ARIAButtonResultProps } from '@fluentui/react-aria';
+import { ARIAButtonType } from '@fluentui/react-aria';
+import { BackgroundAppearanceContextValue } from '@fluentui/react-shared-contexts';
+import type { ComponentProps } from '@fluentui/react-utilities';
+import type { ComponentState } from '@fluentui/react-utilities';
+import type { ForwardRefComponent } from '@fluentui/react-utilities';
+import { JSXElementConstructor } from 'react';
+import * as React_2 from 'react';
+import { ReactElement } from 'react';
+import type { Slot } from '@fluentui/react-utilities';
+import type { SlotClassNames } from '@fluentui/react-utilities';
+import type { TriggerProps } from '@fluentui/react-utilities';
+
+declare type Announce = (message: string, options: AnnounceOptions) => void;
+
+declare type AnnounceOptions = {
+    politeness: AriaLivePoliteness;
+};
+
+declare type AriaLivePoliteness = 'polite' | 'assertive';
+
+/**
+ * AriaLive Props
+ */
+declare type AriaLiveProps = ComponentProps<Partial<AriaLiveSlots>> & {
+    announceRef: React_2.Ref<Announce>;
+};
+
+declare type AriaLiveSlots = {
+    assertive: NonNullable<Slot<'div'>>;
+    polite: NonNullable<Slot<'div'>>;
+};
+
+declare interface CommonToastDetail {
+    toasterId?: ToasterId;
+}
+
+declare interface DispatchToastOptions extends Partial<Omit<ToastOptions, 'toasterId'>> {
+    root?: RootSlot;
+}
+
+/**
+ * Render the final JSX of Toast
+ */
+export declare const renderToast_unstable: (state: ToastState, contextValues: ToastContextValues) => JSX.Element;
+
+/**
+ * Render the final JSX of ToastBody
+ */
+export declare const renderToastBody_unstable: (state: ToastBodyState) => JSX.Element;
+
+/**
+ * Render the final JSX of Toaster
+ */
+export declare const renderToaster_unstable: (state: ToasterState) => JSX.Element;
+
+/**
+ * Render the final JSX of ToastFooter
+ */
+export declare const renderToastFooter_unstable: (state: ToastFooterState) => JSX.Element;
+
+/**
+ * Render the final JSX of ToastTitle
+ */
+export declare const renderToastTitle_unstable: (state: ToastTitleState) => JSX.Element;
+
+/**
+ * Render the final JSX of MenuTrigger
+ *
+ * Only renders children
+ */
+export declare const renderToastTrigger_unstable: (state: ToastTriggerState) => ReactElement<any, string | JSXElementConstructor<any>> | null;
+
+declare type RootSlot = Slot<'div'>;
+
+/**
+ * Toast component
+ */
+export declare const Toast: ForwardRefComponent<ToastProps>;
+
+declare interface Toast_2<TData = object> extends ToastOptions<TData> {
+    /**
+     * Determines the visiblity of a toast
+     */
+    close: () => void;
+    /**
+     * Removes a toast completely
+     */
+    remove: () => void;
+    /**
+     * A number used to track updates immutably
+     */
+    updateId: number;
+    /**
+     * Used to determine default priority when the user does not set one
+     * Simple counter of toasts dispatched.
+     */
+    order: number;
+    imperativeRef: React_2.RefObject<ToastImperativeRef>;
+}
+
+/**
+ * ToastBody component
+ */
+export declare const ToastBody: ForwardRefComponent<ToastBodyProps>;
+
+export declare const toastBodyClassNames: SlotClassNames<ToastBodySlots>;
+
+/**
+ * ToastBody Props
+ */
+export declare type ToastBodyProps = ComponentProps<ToastBodySlots> & {};
+
+export declare type ToastBodySlots = {
+    root: Slot<'div'>;
+    subtitle?: Slot<'div'>;
+};
+
+/**
+ * State used in rendering ToastBody
+ */
+export declare type ToastBodyState = ComponentState<ToastBodySlots> & {
+    backgroundAppearance: BackgroundAppearanceContextValue;
+};
+
+declare interface ToastChangeData extends ToastOptions, Pick<Toast_2, 'updateId'> {
+    status: ToastStatus;
+}
+
+declare type ToastChangeHandler = (event: null, data: ToastChangeData) => void;
+
+export declare const toastClassNames: SlotClassNames<ToastSlots>;
+
+declare type ToastContainerContextValue = {
+    close: () => void;
+    intent: ToastIntent | undefined;
+    bodyId: string;
+    titleId: string;
+};
+
+declare type ToastContextValues = {
+    backgroundAppearance: BackgroundAppearanceContextValue;
+};
+
+/**
+ * Toaster component - renders a collection of toasts dispatched imperatively
+ */
+export declare const Toaster: React_2.FC<ToasterProps>;
+
+export declare const toasterClassNames: SlotClassNames<ToasterSlots>;
+
+declare type ToasterId = string;
+
+declare interface ToasterOptions extends Pick<ToastOptions, 'position' | 'timeout' | 'pauseOnWindowBlur' | 'pauseOnHover' | 'priority'> {
+    offset?: ToastOffset;
+    toasterId?: ToasterId;
+    limit?: number;
+    shortcuts?: ToasterShortcuts;
+}
+
+/**
+ * Toaster Props
+ */
+export declare type ToasterProps = Omit<ComponentProps<ToasterSlots>, 'children'> & Partial<ToasterOptions> & {
+    /**
+     * User override API for aria-live narration for toasts
+     */
+    announce?: Announce;
+};
+
+declare interface ToasterShortcuts {
+    focus: (e: KeyboardEvent) => boolean;
+}
+
+export declare type ToasterSlots = {
+    /**
+     * NOTE: This root slot maps in exactly the same way to the containers rendered for each toast position
+     * There is no intention (currently) to let users customize the div for each toast position.
+     */
+    root: Slot<'div'>;
+};
+
+declare type ToasterSlotsInternal = ToasterSlots & {
+    bottomEnd?: Slot<'div'>;
+    bottomStart?: Slot<'div'>;
+    topEnd?: Slot<'div'>;
+    topStart?: Slot<'div'>;
+};
+
+/**
+ * State used in rendering Toaster
+ */
+export declare type ToasterState = ComponentState<ToasterSlotsInternal> & Pick<AriaLiveProps, 'announceRef'> & Pick<Required<ToasterProps>, 'announce'> & {
+    offset: ToasterOptions['offset'] | undefined;
+    renderAriaLive: boolean;
+    dir: 'rtl' | 'ltr';
+};
+
+/**
+ * ToastFooter component
+ */
+export declare const ToastFooter: ForwardRefComponent<ToastFooterProps>;
+
+export declare const toastFooterClassNames: SlotClassNames<ToastFooterSlots>;
+
+/**
+ * ToastFooter Props
+ */
+export declare type ToastFooterProps = ComponentProps<ToastFooterSlots> & {};
+
+export declare type ToastFooterSlots = {
+    root: Slot<'div'>;
+};
+
+/**
+ * State used in rendering ToastFooter
+ */
+export declare type ToastFooterState = ComponentState<ToastFooterSlots>;
+
+export declare type ToastId = string;
+
+declare type ToastImperativeRef = {
+    /**
+     * Focuses the Toast.
+     * If there are no focusable elements in the Toast, the Toast itself is focused.
+     */
+    focus: () => void;
+    /**
+     * Resumes the timeout of a paused toast
+     */
+    play: () => void;
+    /**
+     * Pauses the timeout of a toast
+     */
+    pause: () => void;
+};
+
+export declare type ToastIntent = 'info' | 'success' | 'error' | 'warning';
+
+export declare type ToastOffset = Partial<Record<ToastPosition, ToastOffsetObject>> | ToastOffsetObject;
+
+declare interface ToastOffsetObject {
+    horizontal?: number;
+    vertical?: number;
+}
+
+declare interface ToastOptions<TData = object> {
+    /**
+     * Uniquely identifies a toast, used for update and dismiss operations
+     */
+    toastId: ToastId;
+    /**
+     * The position the toast should render to
+     */
+    position: ToastPosition;
+    /**
+     * Toast content
+     */
+    content: unknown;
+    /**
+     * Auto dismiss timeout in milliseconds
+     * @default 3000
+     */
+    timeout: number;
+    /**
+     * Toast timeout pauses while focus is on another window
+     * @default false
+     */
+    pauseOnWindowBlur: boolean;
+    /**
+     * Toast timeout pauses while user cursor is on the toast
+     * @default false
+     */
+    pauseOnHover: boolean;
+    /**
+     * Toast belongs to a specific toaster
+     */
+    toasterId: ToasterId | undefined;
+    /**
+     * Higher priority toasts will be rendered before lower priority toasts
+     */
+    priority: number;
+    /**
+     * Used to determine [aria-live](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Live_Regions) narration
+     * This will override the intent prop
+     */
+    politeness?: ToastPoliteness;
+    /**
+     * Default toast types that determine the urgency or [aria-live](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Live_Regions) narration
+     * The UI layer may use these intents to apply specific styling.
+     * @default info
+     */
+    intent?: ToastIntent;
+    /**
+     * Additional data that needs to be passed to the toast
+     */
+    data: TData;
+    /**
+     * Reports changes to the Toast lifecycle
+     */
+    onStatusChange: ToastChangeHandler | undefined;
+}
+
+export declare type ToastPoliteness = 'assertive' | 'polite';
+
+export declare type ToastPosition = 'top-end' | 'top-start' | 'bottom-end' | 'bottom-start';
+
+/**
+ * Toast Props
+ */
+export declare type ToastProps = ComponentProps<ToastSlots> & {
+    appearance?: BackgroundAppearanceContextValue;
+};
+
+export declare type ToastSlots = {
+    root: Slot<'div'>;
+};
+
+/**
+ * State used in rendering Toast
+ */
+export declare type ToastState = ComponentState<ToastSlots> & {
+    backgroundAppearance: BackgroundAppearanceContextValue;
+};
+
+export declare type ToastStatus = 'queued' | 'visible' | 'dismissed' | 'unmounted';
+
+/**
+ * ToastTitle component
+ */
+export declare const ToastTitle: ForwardRefComponent<ToastTitleProps>;
+
+export declare const toastTitleClassNames: SlotClassNames<ToastTitleSlots>;
+
+/**
+ * ToastTitle Props
+ */
+export declare type ToastTitleProps = ComponentProps<ToastTitleSlots> & {};
+
+export declare type ToastTitleSlots = {
+    root: NonNullable<Slot<'div'>>;
+    media?: Slot<'div'>;
+    action?: Slot<'div'>;
+};
+
+/**
+ * State used in rendering ToastTitle
+ */
+export declare type ToastTitleState = ComponentState<ToastTitleSlots> & Pick<ToastContainerContextValue, 'intent'> & {
+    backgroundAppearance: BackgroundAppearanceContextValue;
+};
+
+/**
+ * ToastTrigger component
+ */
+export declare const ToastTrigger: React_2.FC<ToastTriggerProps>;
+
+/**
+ * Props that are passed to the child of the ToastTrigger when cloned to ensure correct behaviour for the Toast
+ */
+export declare type ToastTriggerChildProps<Type extends ARIAButtonType = ARIAButtonType, Props = {}> = ARIAButtonResultProps<Type, Props>;
+
+export declare type ToastTriggerProps = TriggerProps<ToastTriggerChildProps> & {
+    /**
+     * Disables internal trigger mechanism that ensures a child provided will be a compliant ARIA button.
+     * @default false
+     */
+    disableButtonEnhancement?: boolean;
+};
+
+export declare type ToastTriggerState = {
+    children: React_2.ReactElement | null;
+};
+
+declare interface UpdateToastEventDetail extends Partial<ToastOptions>, CommonToastDetail {
+    toastId: ToastId;
+}
+
+declare interface UpdateToastOptions extends UpdateToastEventDetail {
+    root?: RootSlot;
+}
+
+/**
+ * Create the state required to render Toast.
+ *
+ * The returned state can be modified with hooks such as useToastStyles_unstable,
+ * before being passed to renderToast_unstable.
+ *
+ * @param props - props from this instance of Toast
+ * @param ref - reference to root HTMLElement of Toast
+ */
+export declare const useToast_unstable: (props: ToastProps, ref: React_2.Ref<HTMLElement>) => ToastState;
+
+/**
+ * Create the state required to render ToastBody.
+ *
+ * The returned state can be modified with hooks such as useToastBodyStyles_unstable,
+ * before being passed to renderToastBody_unstable.
+ *
+ * @param props - props from this instance of ToastBody
+ * @param ref - reference to root HTMLElement of ToastBody
+ */
+export declare const useToastBody_unstable: (props: ToastBodyProps, ref: React_2.Ref<HTMLElement>) => ToastBodyState;
+
+/**
+ * Apply styling to the ToastBody slots based on the state
+ */
+export declare const useToastBodyStyles_unstable: (state: ToastBodyState) => ToastBodyState;
+
+/**
+ * @param toasterId - If an id is provided all imperative methods control that specific toaster
+ * @returns Imperative methods to control toasts
+ */
+export declare function useToastController(toasterId?: ToasterId): {
+    dispatchToast: (content: React_2.ReactNode, options?: DispatchToastOptions) => void;
+    dismissToast: (toastId: ToastId) => void;
+    dismissAllToasts: () => void;
+    updateToast: (options: UpdateToastOptions) => void;
+    pauseToast: (toastId: ToastId) => void;
+    playToast: (toastId: ToastId) => void;
+};
+
+/**
+ * Create the state required to render Toaster.
+ *
+ * @param props - props from this instance of Toaster
+ */
+export declare const useToaster_unstable: (props: ToasterProps) => ToasterState;
+
+/**
+ * Apply styling to the Toaster slots based on the state
+ */
+export declare const useToasterStyles_unstable: (state: ToasterState) => ToasterState;
+
+/**
+ * Create the state required to render ToastFooter.
+ *
+ * The returned state can be modified with hooks such as useToastFooterStyles_unstable,
+ * before being passed to renderToastFooter_unstable.
+ *
+ * @param props - props from this instance of ToastFooter
+ * @param ref - reference to root HTMLElement of ToastFooter
+ */
+export declare const useToastFooter_unstable: (props: ToastFooterProps, ref: React_2.Ref<HTMLElement>) => ToastFooterState;
+
+/**
+ * Apply styling to the ToastFooter slots based on the state
+ */
+export declare const useToastFooterStyles_unstable: (state: ToastFooterState) => ToastFooterState;
+
+/**
+ * Apply styling to the Toast slots based on the state
+ */
+export declare const useToastStyles_unstable: (state: ToastState) => ToastState;
+
+/**
+ * Create the state required to render ToastTitle.
+ *
+ * The returned state can be modified with hooks such as useToastTitleStyles_unstable,
+ * before being passed to renderToastTitle_unstable.
+ *
+ * @param props - props from this instance of ToastTitle
+ * @param ref - reference to root HTMLElement of ToastTitle
+ */
+export declare const useToastTitle_unstable: (props: ToastTitleProps, ref: React_2.Ref<HTMLElement>) => ToastTitleState;
+
+/**
+ * Apply styling to the ToastTitle slots based on the state
+ */
+export declare const useToastTitleStyles_unstable: (state: ToastTitleState) => ToastTitleState;
+
+/**
+ * A non-visual component that wraps its child
+ * and configures them to be the trigger that will close a `Toast`.
+ * This component should only accept one child.
+ *
+ * This component sole purpose is to avoid opting out of the internal controlled open state of a `Toast`
+ * Besides being a trigger that closes a toast through context this component doesn't do much,
+ * making it basically unnecessary in cases where the trigger is outside of a toast.
+ */
+export declare const useToastTrigger_unstable: (props: ToastTriggerProps) => ToastTriggerState;
+
+export { }

package/lib/AriaLive.js

@@ -0,0 +1 @@
+export * from './components/AriaLive/index';

package/lib/AriaLive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["AriaLive.ts"],"sourcesContent":["export * from './components/AriaLive/index';\n"],"names":[],"mappings":"AAAA,cAAc,8BAA8B"}

package/lib/Toast.js

@@ -0,0 +1 @@
+export * from './components/Toast/index';

package/lib/Toast.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Toast.ts"],"sourcesContent":["export * from './components/Toast/index';\n"],"names":[],"mappings":"AAAA,cAAc,2BAA2B"}

package/lib/ToastBody.js

@@ -0,0 +1 @@
+export * from './components/ToastBody/index';

package/lib/ToastBody.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ToastBody.ts"],"sourcesContent":["export * from './components/ToastBody/index';\n"],"names":[],"mappings":"AAAA,cAAc,+BAA+B"}

package/lib/ToastContainer.js

@@ -0,0 +1 @@
+export * from './components/ToastContainer/index';

package/lib/ToastContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ToastContainer.ts"],"sourcesContent":["export * from './components/ToastContainer/index';\n"],"names":[],"mappings":"AAAA,cAAc,oCAAoC"}

package/lib/ToastFooter.js

@@ -0,0 +1 @@
+export * from './components/ToastFooter/index';

package/lib/ToastFooter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ToastFooter.ts"],"sourcesContent":["export * from './components/ToastFooter/index';\n"],"names":[],"mappings":"AAAA,cAAc,iCAAiC"}

package/lib/ToastTitle.js

@@ -0,0 +1 @@
+export * from './components/ToastTitle/index';

package/lib/ToastTitle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ToastTitle.ts"],"sourcesContent":["export * from './components/ToastTitle/index';\n"],"names":[],"mappings":"AAAA,cAAc,gCAAgC"}

package/lib/ToastTrigger.js

@@ -0,0 +1 @@
+export * from './components/ToastTrigger/index';

package/lib/ToastTrigger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ToastTrigger.ts"],"sourcesContent":["export * from './components/ToastTrigger/index';\n"],"names":[],"mappings":"AAAA,cAAc,kCAAkC"}

package/lib/Toaster.js

@@ -0,0 +1 @@
+export * from './components/Toaster/index';

package/lib/Toaster.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Toaster.ts"],"sourcesContent":["export * from './components/Toaster/index';\n"],"names":[],"mappings":"AAAA,cAAc,6BAA6B"}

package/lib/components/AriaLive/AriaLive.js

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { useAriaLive_unstable } from './useAriaLive';
+import { renderAriaLive_unstable } from './renderAriaLive';
+import { useAriaLiveStyles_unstable } from './useAriaLiveStyles.styles';
+/**
+ * A component that manages aria live announcements imperatively
+ */ export const AriaLive = (props)=>{
+    const state = useAriaLive_unstable(props);
+    useAriaLiveStyles_unstable(state);
+    return renderAriaLive_unstable(state);
+};
+AriaLive.displayName = 'AriaLive';

package/lib/components/AriaLive/AriaLive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["AriaLive.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useAriaLive_unstable } from './useAriaLive';\nimport { renderAriaLive_unstable } from './renderAriaLive';\nimport { useAriaLiveStyles_unstable } from './useAriaLiveStyles.styles';\nimport type { AriaLiveProps } from './AriaLive.types';\n\n/**\n * A component that manages aria live announcements imperatively\n */\nexport const AriaLive: React.FC<AriaLiveProps> = props => {\n  const state = useAriaLive_unstable(props);\n\n  useAriaLiveStyles_unstable(state);\n  return renderAriaLive_unstable(state);\n};\n\nAriaLive.displayName = 'AriaLive';\n"],"names":["React","useAriaLive_unstable","renderAriaLive_unstable","useAriaLiveStyles_unstable","AriaLive","props","state","displayName"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,oBAAoB,QAAQ,gBAAgB;AACrD,SAASC,uBAAuB,QAAQ,mBAAmB;AAC3D,SAASC,0BAA0B,QAAQ,6BAA6B;AAGxE;;CAEC,GACD,OAAO,MAAMC,WAAoCC,CAAAA,QAAS;IACxD,MAAMC,QAAQL,qBAAqBI;IAEnCF,2BAA2BG;IAC3B,OAAOJ,wBAAwBI;AACjC,EAAE;AAEFF,SAASG,WAAW,GAAG"}

package/lib/components/AriaLive/AriaLive.types.js

@@ -0,0 +1 @@
+import * as React from 'react';

package/lib/components/AriaLive/AriaLive.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["AriaLive.types.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\n\nexport type AriaLiveSlots = {\n  assertive: NonNullable<Slot<'div'>>;\n  polite: NonNullable<Slot<'div'>>;\n};\n\nexport type AriaLivePoliteness = 'polite' | 'assertive';\n\n/**\n * AriaLive Props\n */\nexport type AriaLiveProps = ComponentProps<Partial<AriaLiveSlots>> & {\n  announceRef: React.Ref<Announce>;\n};\n\n/**\n * State used in rendering AriaLive\n */\nexport type AriaLiveState = ComponentState<AriaLiveSlots>;\n\nexport type Announce = (message: string, options: AnnounceOptions) => void;\n\nexport type LiveMessage = {\n  message: string;\n  createdAt: number;\n  politeness: AriaLivePoliteness;\n};\n\nexport type AnnounceOptions = {\n  politeness: AriaLivePoliteness;\n};\n"],"names":["React"],"mappings":"AAAA,YAAYA,WAAW,QAAQ"}

package/lib/components/AriaLive/index.js

@@ -0,0 +1,5 @@
+export * from './AriaLive';
+export * from './AriaLive.types';
+export * from './renderAriaLive';
+export * from './useAriaLive';
+export * from './useAriaLiveStyles.styles';

package/lib/components/AriaLive/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './AriaLive';\nexport * from './AriaLive.types';\nexport * from './renderAriaLive';\nexport * from './useAriaLive';\nexport * from './useAriaLiveStyles.styles';\n"],"names":[],"mappings":"AAAA,cAAc,aAAa;AAC3B,cAAc,mBAAmB;AACjC,cAAc,mBAAmB;AACjC,cAAc,gBAAgB;AAC9B,cAAc,6BAA6B"}

package/lib/components/AriaLive/renderAriaLive.js

@@ -0,0 +1,8 @@
+/** @jsxRuntime classic */ /** @jsxFrag Fragment */ /** @jsx createElement */ import { createElement, Fragment } from '@fluentui/react-jsx-runtime';
+import { getSlotsNext } from '@fluentui/react-utilities';
+/**
+ * Render the final JSX of AriaLive
+ */ export const renderAriaLive_unstable = (state)=>{
+    const { slots , slotProps  } = getSlotsNext(state);
+    return /*#__PURE__*/ createElement(Fragment, null, /*#__PURE__*/ createElement(slots.assertive, slotProps.assertive), /*#__PURE__*/ createElement(slots.polite, slotProps.polite));
+};

package/lib/components/AriaLive/renderAriaLive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["renderAriaLive.tsx"],"sourcesContent":["/** @jsxRuntime classic */\n/** @jsxFrag Fragment */\n/** @jsx createElement */\n\nimport { createElement, Fragment } from '@fluentui/react-jsx-runtime';\nimport { getSlotsNext } from '@fluentui/react-utilities';\nimport type { AriaLiveState, AriaLiveSlots } from './AriaLive.types';\n\n/**\n * Render the final JSX of AriaLive\n */\nexport const renderAriaLive_unstable = (state: AriaLiveState) => {\n  const { slots, slotProps } = getSlotsNext<AriaLiveSlots>(state);\n\n  return (\n    <>\n      <slots.assertive {...slotProps.assertive} />\n      <slots.polite {...slotProps.polite} />\n    </>\n  );\n};\n"],"names":["createElement","Fragment","getSlotsNext","renderAriaLive_unstable","state","slots","slotProps","assertive","polite"],"mappings":"AAAA,wBAAwB,GACxB,sBAAsB,GACtB,uBAAuB,GAEvB,SAASA,aAAa,EAAEC,QAAQ,QAAQ,8BAA8B;AACtE,SAASC,YAAY,QAAQ,4BAA4B;AAGzD;;CAEC,GACD,OAAO,MAAMC,0BAA0B,CAACC,QAAyB;IAC/D,MAAM,EAAEC,MAAK,EAAEC,UAAS,EAAE,GAAGJ,aAA4BE;IAEzD,qBACE,AAbJ,cADA,8BAeM,AAdN,cAcOC,MAAME,SAAS,EAAKD,UAAUC,SAAS,iBACxC,AAfN,cAeOF,MAAMG,MAAM,EAAKF,UAAUE,MAAM;AAGxC,EAAE"}

package/lib/components/AriaLive/useAriaLive.js

@@ -0,0 +1,73 @@
+import * as React from 'react';
+import { resolveShorthand, createPriorityQueue, useEventCallback } from '@fluentui/react-utilities';
+/** The duration the message needs to be in present in DOM for screen readers to register a change and announce */ const MESSAGE_DURATION = 500;
+/**
+ * Create the state required to render AriaLive.
+ *
+ * The returned state can be modified with hooks such as useAriaLiveStyles_unstable,
+ * before being passed to renderAriaLive_unstable.
+ *
+ * @param props - props from this instance of AriaLive
+ */ export const useAriaLive_unstable = (props)=>{
+    const [currentMessage, setCurrentMessage] = React.useState(undefined);
+    // Can't rely on Date.now() if user invokes announce more than once in a code block
+    const order = React.useRef(0);
+    const [messageQueue] = React.useState(()=>createPriorityQueue((a, b)=>{
+            if (a.politeness === b.politeness) {
+                return a.createdAt - b.createdAt;
+            }
+            return a.politeness === 'assertive' ? -1 : 1;
+        }));
+    const announce = useEventCallback((message, options)=>{
+        const { politeness  } = options;
+        if (message === (currentMessage === null || currentMessage === void 0 ? void 0 : currentMessage.message)) {
+            return;
+        }
+        const liveMessage = {
+            message,
+            politeness,
+            createdAt: order.current++
+        };
+        if (!currentMessage) {
+            setCurrentMessage(liveMessage);
+        } else {
+            messageQueue.enqueue(liveMessage);
+        }
+    });
+    React.useEffect(()=>{
+        const timeout = setTimeout(()=>{
+            if (messageQueue.peek()) {
+                setCurrentMessage(messageQueue.dequeue());
+            } else {
+                setCurrentMessage(undefined);
+            }
+        }, MESSAGE_DURATION);
+        return ()=>clearTimeout(timeout);
+    }, [
+        currentMessage,
+        messageQueue
+    ]);
+    React.useImperativeHandle(props.announceRef, ()=>announce);
+    const politeMessage = (currentMessage === null || currentMessage === void 0 ? void 0 : currentMessage.politeness) === 'polite' ? currentMessage.message : undefined;
+    const assertiveMessage = (currentMessage === null || currentMessage === void 0 ? void 0 : currentMessage.politeness) === 'assertive' ? currentMessage.message : undefined;
+    return {
+        components: {
+            assertive: 'div',
+            polite: 'div'
+        },
+        assertive: resolveShorthand(props.assertive, {
+            required: true,
+            defaultProps: {
+                'aria-live': 'assertive',
+                children: assertiveMessage
+            }
+        }),
+        polite: resolveShorthand(props.polite, {
+            required: true,
+            defaultProps: {
+                'aria-live': 'polite',
+                children: politeMessage
+            }
+        })
+    };
+};