@gooddata/sdk-ui-kit 11.40.0-alpha.3 → 11.40.0-alpha.5

package/esm/@ui/UiToast/UiToastProvider.d.ts

@@ -0,0 +1,51 @@
+import { type ReactNode } from "react";
+import { type IUiToast, type IUiToastOptions, type IUseUiToastResult, type UiToastKind } from "./types.js";
+interface IUiToastContextValue {
+    /** Currently shown toasts, oldest first. */
+    toasts: IUiToast[];
+    /**
+     * Push a toast onto the queue and return its id. `text` is already
+     * resolved by the consumer — see [[useUiToast]] for the wrapper that
+     * runs `resolveText` against the consumer's `useIntl()`.
+     */
+    push: (kind: UiToastKind, text: string, options?: IUiToastOptions) => string;
+    /** Dismiss one toast by id. */
+    remove: (id: string) => void;
+    /** Dismiss all toasts. */
+    removeAll: () => void;
+    /**
+     * Whether this provider is nested inside another `UiToastProvider`. The
+     * outermost provider renders the visible container; nested providers
+     * forward through context so the topmost-only behaviour is preserved.
+     */
+    isNested: boolean;
+}
+/**
+ * Mount once near the root of your app. Provides the toast queue + dismiss
+ * timers consumed by `useUiToast` and `UiToastsContainer`. Nesting is safe
+ * — only the outermost `<UiToastsContainer>` renders any visible toasts.
+ *
+ * Known limitation: if a root provider with in-flight toasts is **re-parented**
+ * under a new outer provider mid-flight (e.g. the app rearranges its tree),
+ * the inner instance's queue and timers don't migrate to the parent. Mount
+ * the provider once at the stable app root to avoid this.
+ *
+ * @internal
+ */
+export declare function UiToastProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Consumer hook. Resolves the toast message via the **caller's**
+ * `useIntl()` so a consumer rendered under a nested `IntlProvider` formats
+ * `MessageDescriptor` content with that subtree's locale, not the
+ * provider's. Throws when called outside a `UiToastProvider`.
+ *
+ * @internal
+ */
+export declare function useUiToast(): IUseUiToastResult;
+/**
+ * @internal
+ */
+export declare const UiToastContextInternal: import("react").Context<IUiToastContextValue | null>;
+export {};

package/esm/@ui/UiToast/UiToastProvider.js

@@ -0,0 +1,193 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { createContext, useCallback, useContext, useEffect, useId, useMemo, useRef, useState, } from "react";
+import { useIntl } from "react-intl";
+const DEFAULT_DURATION_MS = 4000;
+/**
+ * Resolve a `UiToastMessage` to a flat string using the supplied `intl`.
+ * `UiToastIntlValues` only accepts `PrimitiveType` interpolation values, so
+ * `formatMessage` always returns `string` — no `ReactNode[]` coercion needed.
+ *
+ * Called from `useUiToast` so resolution uses the **consumer's** `useIntl()`
+ * (the locale of the calling subtree) rather than the provider's — a
+ * provider mounted at the app root would otherwise format with the root
+ * locale even when the caller sits under a nested `IntlProvider`.
+ */
+const resolveText = (intl, message, options) => {
+    if (typeof message === "string") {
+        return options?.values
+            ? intl.formatMessage({ id: message, defaultMessage: message }, options.values)
+            : message;
+    }
+    return intl.formatMessage(message.descriptor, message.values);
+};
+const UiToastContext = createContext(null);
+/**
+ * Mount once near the root of your app. Provides the toast queue + dismiss
+ * timers consumed by `useUiToast` and `UiToastsContainer`. Nesting is safe
+ * — only the outermost `<UiToastsContainer>` renders any visible toasts.
+ *
+ * Known limitation: if a root provider with in-flight toasts is **re-parented**
+ * under a new outer provider mid-flight (e.g. the app rearranges its tree),
+ * the inner instance's queue and timers don't migrate to the parent. Mount
+ * the provider once at the stable app root to avoid this.
+ *
+ * @internal
+ */
+export function UiToastProvider({ children }) {
+    const parent = useContext(UiToastContext);
+    const [toasts, setToasts] = useState([]);
+    // `toastsRef` is the synchronous source of truth for the queue —
+    // mutators (`push` / `remove` / `removeAll`) update it FIRST and only
+    // then schedule the `setToasts` render. That way a same-tick
+    // `add → remove` sequence sees the just-added toast in the ref, and
+    // side effects (timers, `onDismiss`) run consistently without depending
+    // on React's commit timing. React state mirrors the ref on every render.
+    const toastsRef = useRef(toasts);
+    const timersRef = useRef(new Map());
+    const dismissedRef = useRef(new Set());
+    const idPrefix = useId();
+    const counterRef = useRef(0);
+    const clearTimer = useCallback((id) => {
+        const timer = timersRef.current.get(id);
+        if (timer) {
+            clearTimeout(timer);
+            timersRef.current.delete(id);
+        }
+    }, []);
+    // Single mutation point — update the ref synchronously, then sync the
+    // React state via the same value. Other mutators call this so the ref
+    // and the state stay in lockstep without depending on commit timing.
+    const commit = useCallback((next) => {
+        toastsRef.current = next;
+        setToasts(next);
+    }, []);
+    const remove = useCallback((id) => {
+        // Bail if this id has already been dismissed (auto-dismiss +
+        // manual race, or StrictMode's double-invocation). Otherwise
+        // tear down synchronously: ref + state in the same tick, side
+        // effects (timer cleanup, `onDismiss`) right after.
+        if (dismissedRef.current.has(id))
+            return;
+        const t = toastsRef.current.find((x) => x.id === id);
+        if (!t)
+            return;
+        dismissedRef.current.add(id);
+        clearTimer(id);
+        commit(toastsRef.current.filter((x) => x.id !== id));
+        t.onDismiss?.();
+    }, [clearTimer, commit]);
+    const removeAll = useCallback(() => {
+        // Snapshot first so the loop sees a stable list even if `onDismiss`
+        // turns around and calls `add` / `remove` synchronously. Ref +
+        // state are cleared together; side effects run after the commit
+        // call, so a throwing `onDismiss` can't corrupt the queue.
+        const snapshot = toastsRef.current;
+        const onDismisses = [];
+        for (const t of snapshot) {
+            if (!dismissedRef.current.has(t.id)) {
+                dismissedRef.current.add(t.id);
+                if (t.onDismiss)
+                    onDismisses.push(t.onDismiss);
+            }
+            clearTimer(t.id);
+        }
+        commit([]);
+        for (const cb of onDismisses)
+            cb();
+    }, [clearTimer, commit]);
+    const push = useCallback((kind, text, options) => {
+        const id = options?.id ?? `${idPrefix}-${counterRef.current++}`;
+        const sticky = options?.sticky ?? false;
+        const durationMs = options?.durationMs ?? DEFAULT_DURATION_MS;
+        const toast = {
+            id,
+            kind,
+            text,
+            sticky,
+            durationMs,
+            action: options?.action,
+            accessibilityConfig: options?.accessibilityConfig,
+            onDismiss: options?.onDismiss,
+        };
+        // Reusing an existing id replaces the toast in place and resets
+        // its dismiss timer.
+        clearTimer(id);
+        dismissedRef.current.delete(id);
+        const prev = toastsRef.current;
+        const existing = prev.findIndex((t) => t.id === id);
+        const next = existing >= 0 ? prev.map((t, i) => (i === existing ? toast : t)) : [...prev, toast];
+        commit(next);
+        if (!sticky) {
+            const timer = setTimeout(() => remove(id), durationMs);
+            timersRef.current.set(id, timer);
+        }
+        return id;
+    }, [idPrefix, remove, clearTimer, commit]);
+    // Cancel pending dismiss timers on unmount.
+    useEffect(() => {
+        const timers = timersRef.current;
+        return () => {
+            for (const timer of timers.values())
+                clearTimeout(timer);
+            timers.clear();
+        };
+    }, []);
+    // Trim `dismissedRef` to ids still in `toasts` once React commits a
+    // removal. The ref's only job is to dedupe within a single dispatch
+    // (StrictMode double-invocation, auto-dismiss + manual race) — once
+    // the toast has left state, no future call can race on the same id,
+    // so the ref entry is dead weight. Without this trim the Set would
+    // grow monotonically for every auto-generated id in a long-running
+    // SPA. Runs after commit, so StrictMode's pre-commit second pass
+    // still sees the id during the dispatch that removed it.
+    useEffect(() => {
+        const liveIds = new Set(toasts.map((t) => t.id));
+        for (const id of dismissedRef.current) {
+            if (!liveIds.has(id))
+                dismissedRef.current.delete(id);
+        }
+    }, [toasts]);
+    const value = useMemo(() => {
+        if (parent) {
+            // Nested provider: forward to the parent so a single queue is the
+            // source of truth. `isNested` flips so any nested
+            // `UiToastsContainer` knows to render nothing.
+            return { ...parent, isNested: true };
+        }
+        return { toasts, push, remove, removeAll, isNested: false };
+    }, [parent, toasts, push, remove, removeAll]);
+    return _jsx(UiToastContext.Provider, { value: value, children: children });
+}
+/**
+ * Consumer hook. Resolves the toast message via the **caller's**
+ * `useIntl()` so a consumer rendered under a nested `IntlProvider` formats
+ * `MessageDescriptor` content with that subtree's locale, not the
+ * provider's. Throws when called outside a `UiToastProvider`.
+ *
+ * @internal
+ */
+export function useUiToast() {
+    const ctx = useContext(UiToastContext);
+    if (!ctx) {
+        throw new Error("useUiToast must be used inside <UiToastProvider>");
+    }
+    const intl = useIntl();
+    const { push, remove, removeAll } = ctx;
+    return useMemo(() => {
+        const add = (kind, message, options) => push(kind, resolveText(intl, message, options), options);
+        return {
+            addSuccess: (message, options) => add("success", message, options),
+            addInfo: (message, options) => add("info", message, options),
+            addWarning: (message, options) => add("warning", message, options),
+            addError: (message, options) => add("error", message, options),
+            add,
+            remove,
+            removeAll,
+        };
+    }, [intl, push, remove, removeAll]);
+}
+/**
+ * @internal
+ */
+export const UiToastContextInternal = UiToastContext;

package/esm/@ui/UiToast/UiToastsContainer.d.ts

@@ -0,0 +1,33 @@
+import { type ReactNode } from "react";
+import { type IUiToast } from "./types.js";
+/**
+ * @internal
+ */
+export interface IUiToastItemProps {
+    toast: IUiToast;
+    /** Fired when the user dismisses (close X or action click). */
+    onClose: (id: string) => void;
+}
+/**
+ * Presentational single-toast component. Most consumers use
+ * `UiToastsContainer` (which reads queued toasts from the provider), but
+ * this can be rendered directly for static demos or one-off composition.
+ *
+ * @internal
+ */
+export declare function UiToastItem({ toast, onClose }: IUiToastItemProps): ReactNode;
+/**
+ * @internal
+ */
+export interface IUiToastsContainerProps {
+    /** Test id forwarded to the root element. */
+    dataTestId?: string;
+}
+/**
+ * Renders the list of toasts queued by `useUiToast`. Mount once near the app
+ * root, inside a `UiToastProvider`. Nested containers render nothing — only
+ * the outermost one is visible, preserving the topmost-only behaviour.
+ *
+ * @internal
+ */
+export declare function UiToastsContainer({ dataTestId }: IUiToastsContainerProps): ReactNode;

package/esm/@ui/UiToast/UiToastsContainer.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useContext, useMemo } from "react";
+import { useIntl } from "react-intl";
+import { commonDialogMessages } from "../../locales.js";
+import { bem } from "../@utils/bem.js";
+import { UiIcon } from "../UiIcon/UiIcon.js";
+import { UiToastContextInternal } from "./UiToastProvider.js";
+const { b, e } = bem("gd-ui-kit-toast");
+// Errors and warnings interrupt screen readers by default; success/info wait
+// for the assistive-tech queue to be free. Callers can override per toast.
+const DEFAULT_ARIA_LIVE = {
+    success: "polite",
+    info: "polite",
+    warning: "assertive",
+    error: "assertive",
+};
+/**
+ * Presentational single-toast component. Most consumers use
+ * `UiToastsContainer` (which reads queued toasts from the provider), but
+ * this can be rendered directly for static demos or one-off composition.
+ *
+ * @internal
+ */
+export function UiToastItem({ toast, onClose }) {
+    const intl = useIntl();
+    const ariaLive = toast.accessibilityConfig?.ariaLive ?? DEFAULT_ARIA_LIVE[toast.kind];
+    const role = toast.accessibilityConfig?.role ?? (ariaLive === "assertive" ? "alert" : "status");
+    const closeLabel = toast.accessibilityConfig?.closeButtonLabel ?? intl.formatMessage(commonDialogMessages.close);
+    return (_jsxs("div", { className: e("item", { kind: toast.kind }), role: role, "aria-live": ariaLive, "aria-label": toast.accessibilityConfig?.ariaLabel, "aria-labelledby": toast.accessibilityConfig?.ariaLabelledBy, "aria-describedby": toast.accessibilityConfig?.ariaDescribedBy, "data-testid": `gd-ui-kit-toast-${toast.kind}-${toast.id}`, children: [
+            _jsx("span", { className: e("body"), children: toast.text }), toast.action ? (_jsx("button", { type: "button", className: e("action"), onClick: () => {
+                    toast.action.onClick();
+                    onClose(toast.id);
+                }, children: toast.action.label })) : null, _jsx("button", { type: "button", className: e("close"), onClick: () => onClose(toast.id), "aria-label": closeLabel, children: _jsx(UiIcon, { type: "cross", size: 14, color: "currentColor" }) })
+        ] }));
+}
+/**
+ * Renders the list of toasts queued by `useUiToast`. Mount once near the app
+ * root, inside a `UiToastProvider`. Nested containers render nothing — only
+ * the outermost one is visible, preserving the topmost-only behaviour.
+ *
+ * @internal
+ */
+export function UiToastsContainer({ dataTestId }) {
+    const ctx = useContext(UiToastContextInternal);
+    // Render newest-first so the most recent notification sits at the top
+    // of the stack — matches the legacy `ToastsCenter` overlay
+    // (`messages.sort((a, b) => b.createdAt - a.createdAt)`). The queue
+    // itself stays in insertion order for `push` / `remove` correctness;
+    // only the rendered list is reversed.
+    const items = useMemo(() => (ctx?.toasts ? [...ctx.toasts].reverse() : []), [ctx?.toasts]);
+    if (!ctx || ctx.isNested) {
+        return null;
+    }
+    return (_jsx("div", { className: b(), "data-testid": dataTestId, children: items.map((toast) => (_jsx(UiToastItem, { toast: toast, onClose: ctx.remove }, toast.id))) }));
+}

package/esm/@ui/UiToast/types.d.ts

@@ -0,0 +1,125 @@
+import { type MessageDescriptor, type PrimitiveType } from "react-intl";
+import { type IAccessibilityConfigBase } from "../../typings/accessibility.js";
+/**
+ * Interpolation values accepted by `react-intl`'s `formatMessage`, **narrowed
+ * to plain primitives** for toast use. Toast text is plain text by contract,
+ * so React-element interpolation values (`<b>name</b>`) are intentionally
+ * disallowed — `formatMessage` would otherwise return `ReactNode[]` which our
+ * downstream `text: string` would have to stringify, producing
+ * `"[object Object]"` for any element. Reject at compile time instead.
+ *
+ * @internal
+ */
+export type UiToastIntlValues = Record<string, PrimitiveType>;
+/**
+ * Severity / visual kind of a toast.
+ *
+ * @internal
+ */
+export type UiToastKind = "success" | "info" | "warning" | "error";
+/**
+ * Toast text content. Either a plain string or an `intl` message descriptor
+ * with optional interpolation values.
+ *
+ * @internal
+ */
+export type UiToastMessage = string | {
+    descriptor: MessageDescriptor;
+    values?: UiToastIntlValues;
+};
+/**
+ * Optional per-toast accessibility overrides. The container is a polite live
+ * region by default; `error` and `warning` toasts upgrade to assertive
+ * `role="alert"` unless overridden here.
+ *
+ * @internal
+ */
+export interface IUiToastAccessibilityConfig extends Pick<IAccessibilityConfigBase, "ariaLabel" | "ariaLabelledBy" | "ariaDescribedBy" | "role"> {
+    ariaLive?: "off" | "polite" | "assertive";
+    /**
+     * Accessible name for the close button. Defaults to the localized
+     * "Close" — pass a context-specific string (e.g. "Dismiss the
+     * 'access updated' notification") when a generic label isn't
+     * descriptive enough for screen-reader users.
+     */
+    closeButtonLabel?: string;
+}
+/**
+ * Optional inline action rendered next to the toast text (e.g. "Undo").
+ *
+ * @internal
+ */
+export interface IUiToastAction {
+    /** Visible label on the action button. */
+    label: string;
+    /** Fired when the action is activated. */
+    onClick: () => void;
+}
+/**
+ * Options accepted by `useUiToast`'s `add*` methods (and the generic `add`).
+ *
+ * @internal
+ */
+export interface IUiToastOptions {
+    /**
+     * Caller-supplied id. When omitted a stable id is generated. Use to
+     * dedupe or to remove a specific toast programmatically.
+     */
+    id?: string;
+    /**
+     * Skip auto-dismiss — the toast stays until the user closes it or
+     * `remove(id)` is called. Defaults to `false`.
+     */
+    sticky?: boolean;
+    /**
+     * Auto-dismiss delay in milliseconds. Ignored when `sticky` is true.
+     * Defaults to 4000 ms.
+     */
+    durationMs?: number;
+    /** Optional inline action rendered next to the message. */
+    action?: IUiToastAction;
+    /**
+     * Optional intl interpolation values used when `message` is a string —
+     * exposed primarily so the kind-specific `add*` helpers can forward
+     * intl values supplied alongside a `MessageDescriptor`.
+     */
+    values?: UiToastIntlValues;
+    /** Fires once when the toast is dismissed (auto or user). */
+    onDismiss?: () => void;
+    /** Per-toast accessibility overrides. */
+    accessibilityConfig?: IUiToastAccessibilityConfig;
+}
+/**
+ * A toast as the container renders it. Internal — not part of the public API.
+ *
+ * @internal
+ */
+export interface IUiToast {
+    id: string;
+    kind: UiToastKind;
+    /** Resolved display text (already passed through `formatMessage` if needed). */
+    text: string;
+    sticky: boolean;
+    durationMs: number;
+    action?: IUiToastAction;
+    accessibilityConfig?: IUiToastAccessibilityConfig;
+    onDismiss?: () => void;
+}
+/**
+ * Public hook surface. Each `add*` returns the toast id, which callers can
+ * pass to `remove` to dismiss it programmatically.
+ *
+ * @internal
+ */
+export interface IUseUiToastResult {
+    addSuccess: (message: UiToastMessage, options?: IUiToastOptions) => string;
+    addInfo: (message: UiToastMessage, options?: IUiToastOptions) => string;
+    addWarning: (message: UiToastMessage, options?: IUiToastOptions) => string;
+    addError: (message: UiToastMessage, options?: IUiToastOptions) => string;
+    /** Generic add — provide your own `kind`. */
+    add: (kind: UiToastKind, message: UiToastMessage, options?: IUiToastOptions) => string;
+    /** Dismiss a single toast by id. No-op if no toast with that id is showing. */
+    remove: (id: string) => void;
+    /** Dismiss all currently showing toasts. */
+    removeAll: () => void;
+}

package/esm/@ui/UiToast/types.js

@@ -0,0 +1,2 @@
+// (C) 2026 GoodData Corporation
+export {};

package/esm/FlexDimensions/FlexDimensions.d.ts

@@ -12,6 +12,7 @@ export declare class FlexDimensions extends Component<IFlexDimensionsProps, IFle
     };
     private wrapperRef;
     private readonly throttledUpdateSize;
+    private readonly resizeObserver;
     constructor(props: IFlexDimensionsProps);
     componentDidMount(): void;
     componentWillUnmount(): void;

package/esm/FlexDimensions/FlexDimensions.js

@@ -16,6 +16,7 @@ export class FlexDimensions extends Component {
     };
     wrapperRef = createRef();
     throttledUpdateSize;
+    resizeObserver;
     constructor(props) {
         super(props);
         this.state = {
@@ -23,14 +24,17 @@ export class FlexDimensions extends Component {
             height: 0,
         };
         this.throttledUpdateSize = throttle(this.updateSize, 250, { leading: false });
+        this.resizeObserver = new ResizeObserver(this.throttledUpdateSize);
     }
     componentDidMount() {
-        window.addEventListener("resize", this.throttledUpdateSize);
+        if (this.wrapperRef.current) {
+            this.resizeObserver.observe(this.wrapperRef.current);
+        }
         this.throttledUpdateSize();
     }
     componentWillUnmount() {
         this.throttledUpdateSize.cancel();
-        window.removeEventListener("resize", this.throttledUpdateSize);
+        this.resizeObserver.disconnect();
     }
     getChildrenDimensions() {
         return pickBy(this.state, (_, key) => {

package/esm/Header/generateHeaderMenuItemsGroups.js

@@ -65,7 +65,7 @@ function createInsightsItemsGroup(featureFlags, workspaceId, workspacePermission
     const insightItemsGroup = [];
     const kpisUrl = kpisItemUrl(baseUrl, workspaceId);
     pushConditionally(insightItemsGroup, createIHeaderMenuItem(HEADER_ITEM_ID_KPIS_NEW, "s-menu-kpis", kpisUrl), canShowKpisItem(workspacePermissions, hasAnalyticalDashboards));
-    const analyzeUrl = analyzeItemUrl(baseUrl, workspaceId);
+    const analyzeUrl = analyzeItemUrl(baseUrl, workspaceId, featureFlags);
     pushConditionally(insightItemsGroup, createIHeaderMenuItem(HEADER_ITEM_ID_ANALYZE, "s-menu-analyze", analyzeUrl), canShowAnalyzeItem(workspacePermissions));
     const measuresUrl = measuresItemUrl(baseUrl, workspaceId, featureFlags);
     pushConditionally(insightItemsGroup, createIHeaderMenuItem(HEADER_ITEM_ID_METRICS, "s-menu-metrics", measuresUrl), canShowMetricsItem(hasMeasures, workspacePermissions));
@@ -124,7 +124,10 @@ function kpisItemUrl(baseUrl, workspaceId) {
 function canShowKpisItem(workspacePermissions, hasAnalyticalDashboards) {
     return Boolean(hasAnalyticalDashboards || workspacePermissions.canCreateAnalyticalDashboard === true);
 }
-function analyzeItemUrl(baseUrl, workspaceId) {
+function analyzeItemUrl(baseUrl, workspaceId, featureFlags) {
+    if (featureFlags.enableShellApplication_analyticalDesigner) {
+        return withBaseUrl(baseUrl, `/workspace/${workspaceId}/analyze/#/reportId/edit`);
+    }
     return withBaseUrl(baseUrl, `/analyze/#/${workspaceId}/reportId/edit`);
 }
 function canShowAnalyzeItem(workspacePermissions) {

package/esm/ShortenedText/ShortenedText.js

@@ -92,13 +92,15 @@ export class ShortenedText extends PureComponent {
         if (elementWidth > 0 && elementWidth < element.scrollWidth) {
             this.setState({ title: getShortenedTitle(title, element, ellipsisPosition), customTitle: true });
         }
+        else {
+            this.setState({
+                title: this.props.children,
+                customTitle: false,
+            });
+        }
     }
     recomputeShortening() {
-        // causes repaint & checkTitle to be called
-        this.setState({
-            title: this.props.children,
-            customTitle: false,
-        });
+        this.checkTitle();
     }
     renderTextWithBubble() {
         return (_jsxs(BubbleHoverTrigger, { showDelay: 0, hideDelay: 0, eventsOnBubble: this.props.tooltipVisibleOnMouseOver, children: [

package/esm/index.d.ts

@@ -468,3 +468,6 @@ export { UiLabelsList, type IUiLabelsListProps, type IUiLabelsListItem, } from "
 export { UiLabelsPicker, isLabelsPickerItemChecked, type IUiLabelsPickerProps, type IUiLabelsPickerItem, } from "./@ui/UiLabelsPicker/UiLabelsPicker.js";
 export { UiPermissionMenu, type IUiPermissionMenuProps, type PermissionMenuLevel, } from "./@ui/UiPermissionMenu/UiPermissionMenu.js";
 export { UiGranteeRowControls, type IUiGranteeRowControlsProps, } from "./@ui/UiGranteeRowControls/UiGranteeRowControls.js";
+export { UiToastProvider, useUiToast } from "./@ui/UiToast/UiToastProvider.js";
+export { UiToastItem, UiToastsContainer, type IUiToastItemProps, type IUiToastsContainerProps, } from "./@ui/UiToast/UiToastsContainer.js";
+export { type IUiToast, type IUiToastAccessibilityConfig, type IUiToastAction, type IUiToastOptions, type IUseUiToastResult, type UiToastIntlValues, type UiToastKind, type UiToastMessage, } from "./@ui/UiToast/types.js";

package/esm/index.js

@@ -423,3 +423,5 @@ export { UiLabelsList, } from "./@ui/UiLabelsList/UiLabelsList.js";
 export { UiLabelsPicker, isLabelsPickerItemChecked, } from "./@ui/UiLabelsPicker/UiLabelsPicker.js";
 export { UiPermissionMenu, } from "./@ui/UiPermissionMenu/UiPermissionMenu.js";
 export { UiGranteeRowControls, } from "./@ui/UiGranteeRowControls/UiGranteeRowControls.js";
+export { UiToastProvider, useUiToast } from "./@ui/UiToast/UiToastProvider.js";
+export { UiToastItem, UiToastsContainer, } from "./@ui/UiToast/UiToastsContainer.js";