@cube-dev/ui-kit 0.0.0-canary-e2a9f35 → 0.0.0-canary-c48279e

package/types/components/overlays/Notifications/NotificationCard.d.ts

@@ -0,0 +1,37 @@
+import { Key, ReactNode } from 'react';
+import type { DismissReason, NotificationType } from './types';
+export interface NotificationCardProps {
+    qa?: string;
+    /** Notification theme */
+    theme?: NotificationType;
+    /** Primary text */
+    title?: ReactNode;
+    /** Secondary text */
+    description?: ReactNode;
+    /** Custom icon override (theme default used if omitted) */
+    icon?: ReactNode;
+    /** Action buttons rendered below description */
+    actions?: ReactNode;
+    /**
+     * Whether the notification shows the default dismiss UI (auto-appended
+     * "Dismiss" button and Escape key). Default: true.
+     *
+     * When false, no default "Dismiss" button is rendered and Escape does
+     * nothing, but actions with `closeOnPress` (default) can still close
+     * the notification.
+     */
+    isDismissible?: boolean;
+    /** When false the card drops its shadow (e.g. inside a list). Default: true. */
+    elevated?: boolean;
+    /** Notification id */
+    notificationId?: Key;
+    /** Called when the notification is dismissed */
+    onDismiss?: (id: Key, reason: DismissReason) => void;
+    /** Suffix content (e.g. timestamp) */
+    suffix?: ReactNode;
+}
+/**
+ * Shared presentational card used by both overlay NotificationItem
+ * and PersistentNotificationListItem.
+ */
+export declare function NotificationCard({ qa, theme, title, description, icon: providedIcon, actions, isDismissible, elevated, notificationId, onDismiss, suffix, }: NotificationCardProps): import("react/jsx-runtime").JSX.Element;

package/types/components/overlays/Notifications/NotificationContext.d.ts

@@ -0,0 +1,16 @@
+import type { ToastContextValue } from '../Toast/types';
+import type { InternalNotificationContextValue, PersistentNotificationsContextValue } from './types';
+export declare const ToastContext: import("react").Context<ToastContextValue | null>;
+/**
+ * Internal context for overlay notification machinery.
+ * Not exported publicly — consumers should use `useNotifications` hook.
+ */
+export declare const NotificationContext: import("react").Context<InternalNotificationContextValue | null>;
+/**
+ * Public context for persistent notifications.
+ * Used by `usePersistentNotifications` and `useNotificationsCount` hooks.
+ */
+export declare const PersistentNotificationsContext: import("react").Context<PersistentNotificationsContextValue | null>;
+export declare function useToastContext(): ToastContextValue;
+export declare function useNotificationContext(): InternalNotificationContextValue;
+export declare function usePersistentNotificationsContext(): PersistentNotificationsContextValue;

package/types/components/overlays/Notifications/NotificationItem.d.ts

@@ -0,0 +1,7 @@
+import { Key } from 'react';
+import type { DismissReason, InternalNotification } from './types';
+export interface NotificationItemProps {
+    notification: InternalNotification;
+    onDismiss: (id: Key, reason: DismissReason) => void;
+}
+export declare function NotificationItem({ notification, onDismiss, }: NotificationItemProps): import("react/jsx-runtime").JSX.Element;

package/types/components/overlays/Notifications/OverlayContainer.d.ts

@@ -0,0 +1,12 @@
+import { Key } from 'react';
+import type { InternalToast } from '../Toast/types';
+import type { DismissReason, InternalNotification } from './types';
+export interface OverlayContainerProps {
+    toasts: InternalToast[];
+    notifications: InternalNotification[];
+    onToastExitComplete: (internalId: string) => void;
+    onNotificationExitComplete: (internalId: string) => void;
+    onNotificationDismiss: (id: Key, reason: DismissReason) => void;
+    onPauseChange: (paused: boolean) => void;
+}
+export declare function OverlayContainer({ toasts, notifications, onToastExitComplete, onNotificationExitComplete, onNotificationDismiss, onPauseChange, }: OverlayContainerProps): import("react/jsx-runtime").JSX.Element | null;

package/types/components/overlays/Notifications/OverlayProvider.d.ts

@@ -0,0 +1,3 @@
+import type { OverlayProviderProps } from './types';
+export { useToastContext, useNotificationContext } from './NotificationContext';
+export declare function OverlayProvider({ children, maxPersistentNotifications, }: OverlayProviderProps): import("react/jsx-runtime").JSX.Element;

package/types/components/overlays/Notifications/PersistentNotificationsList.d.ts

@@ -0,0 +1,18 @@
+import type { PersistentNotificationsListProps } from './types';
+/**
+ * Standardized rendering for archived/persistent notifications.
+ * Always reads items from the notification context.
+ * Composable with app-specific shells (popover, dialog, page section).
+ *
+ * Marks all items as read after being visible for 2 seconds.
+ * Relative timestamps refresh every 10 seconds while the list is mounted.
+ *
+ * @example
+ * ```tsx
+ * <PersistentNotificationsList
+ *   onDismissItem={(item) => remove(item.id)}
+ *   emptyState="No notifications"
+ * />
+ * ```
+ */
+export declare function PersistentNotificationsList({ onDismissItem, onAction, emptyState, }: PersistentNotificationsListProps): import("react/jsx-runtime").JSX.Element;

package/types/components/overlays/Notifications/format-relative-time.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lightweight relative time formatter.
+ * No external dependencies.
+ *
+ * Output format:
+ * - `just now` (< 1 minute)
+ * - `N min ago` (1–59 minutes)
+ * - `N h ago` (1–23 hours)
+ * - `N d ago` (1–6 days)
+ * - `N w ago` (1–4 weeks)
+ * - `N mo ago` (1–11 months)
+ * - `N y ago` (1+ years)
+ */
+export declare function formatRelativeTime(timestamp: number): string;

package/types/components/overlays/Notifications/index.d.ts

@@ -0,0 +1,40 @@
+import { Notification as NotificationBase } from './Notification';
+import { NotificationAction } from './NotificationAction';
+export { NotificationAction } from './NotificationAction';
+export { NotificationCard } from './NotificationCard';
+export type { NotificationCardProps } from './NotificationCard';
+export { NotificationItem } from './NotificationItem';
+export type { NotificationItemProps } from './NotificationItem';
+export { PersistentNotificationsList } from './PersistentNotificationsList';
+export { OverlayProvider } from './OverlayProvider';
+export { useToastContext } from './NotificationContext';
+export { useNotifications } from './use-notifications';
+export { usePersistentNotifications, useNotificationsCount, } from './use-persistent-notifications';
+export { formatRelativeTime } from './format-relative-time';
+export type { NotificationType, DismissReason, NotificationBaseOptions, OverlayNotificationOptions, StoredNotificationOptions, NotificationOptions, NotificationActionProps, NotificationHandle, NotificationsApi, PersistentNotificationItem, PersistentNotificationsListProps, OverlayProviderProps, NotificationProps, } from './types';
+/**
+ * Declarative Notification component with compound API.
+ *
+ * @example
+ * ```tsx
+ * // Declarative usage
+ * <Notification
+ *   id="release:new-version"
+ *   theme="warning"
+ *   title="New release available"
+ *   description="2.0.0 can be installed now."
+ *   actions={
+ *     <>
+ *       <Notification.Action>Later</Notification.Action>
+ *       <Notification.Action onPress={() => openUpgradeDialog()}>
+ *         Upgrade
+ *       </Notification.Action>
+ *     </>
+ *   }
+ * />
+ * ```
+ */
+export declare const Notification: typeof NotificationBase & {
+    Action: typeof NotificationAction;
+};
+export type NotificationComponent = typeof Notification;

package/types/components/overlays/Notifications/types.d.ts

@@ -0,0 +1,147 @@
+import type { Key, ReactNode } from 'react';
+export type NotificationType = 'default' | 'success' | 'danger' | 'warning' | 'note';
+export interface NotificationBaseOptions {
+    id?: Key;
+    theme?: NotificationType;
+    title?: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+}
+export interface OverlayNotificationOptions extends NotificationBaseOptions {
+    mode?: 'overlay';
+    /**
+     * Action buttons rendered below the notification description.
+     * A default "Dismiss" button is auto-appended unless any action has
+     * `isDismiss` set (detected automatically via context).
+     * When omitted, only the default "Dismiss" button is shown (if `isDismissible`).
+     */
+    actions?: ReactNode;
+    /**
+     * Whether the notification shows the default dismiss UI:
+     * - Auto-appended "Dismiss" button (suppressed when false)
+     * - Escape key dismissal (disabled when false)
+     *
+     * Actions with `closeOnPress` (default `true`) can still close the
+     * notification regardless of this setting.
+     *
+     * Default: true
+     */
+    isDismissible?: boolean;
+    /**
+     * Duration in ms before auto-dismiss.
+     * Default: 5000ms (non-persistent) or 10000ms (persistent).
+     * null = no auto-dismiss.
+     */
+    duration?: number | null;
+    /**
+     * Whether to retain in persistent list on timeout dismissal.
+     * Only `timeout` dismissals move to the persistent list — user-initiated
+     * dismissals (`close`, `action`) intentionally skip persistence.
+     * Default: false
+     */
+    persistent?: boolean;
+}
+export interface StoredNotificationOptions extends NotificationBaseOptions {
+    mode: 'stored';
+    /** Action buttons (same ReactNode format as overlay notifications) */
+    actions?: ReactNode;
+    /**
+     * Timestamp (epoch ms) for when the notification was originally created.
+     * Use this when restoring server-sourced notifications to preserve the original time.
+     * Defaults to `Date.now()` if omitted.
+     */
+    createdAt?: number;
+}
+export type NotificationOptions = OverlayNotificationOptions | StoredNotificationOptions;
+export type DismissReason = 'close' | 'timeout' | 'action' | 'api';
+export interface NotificationActionProps {
+    /** Action label */
+    children?: ReactNode;
+    /** Called when the action is pressed */
+    onPress?: () => void;
+    /** Whether to auto-dismiss the notification after onPress. Default: true */
+    closeOnPress?: boolean;
+    /** Whether the action is disabled */
+    isDisabled?: boolean;
+    /**
+     * Marks this action as the notification's dismiss button.
+     * Detected automatically via context — when any action in the notification
+     * has `isDismiss` set, the auto-appended default "Dismiss" button is suppressed.
+     */
+    isDismiss?: boolean;
+}
+export interface NotificationHandle {
+    id: Key;
+    dismiss: () => void;
+}
+export interface NotificationsApi {
+    notify: (options: NotificationOptions) => NotificationHandle;
+    /**
+     * Shorthand for `notify({ mode: 'stored', ... })`.
+     * Stores a notification directly to the persistent list without showing an overlay.
+     * Kept as a separate method to make the "stored-only" intent explicit at call sites.
+     */
+    record: (options: Omit<StoredNotificationOptions, 'mode'>) => NotificationHandle;
+    dismiss: (id: Key) => void;
+}
+export interface InternalNotification extends OverlayNotificationOptions {
+    internalId: string;
+    createdAt: number;
+    updatedAt: number;
+    isExiting?: boolean;
+    ownerId?: string;
+}
+export interface PersistentNotificationItem {
+    id: Key;
+    theme?: NotificationType;
+    title?: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+    /** Action buttons (ReactNode) */
+    actions?: ReactNode;
+    createdAt: number;
+    updatedAt: number;
+    /** Whether the notification has been seen in the persistent list */
+    isRead?: boolean;
+    /** Owner ID for cleanup on hook/component unmount */
+    ownerId?: string;
+}
+export interface PersistentNotificationsListProps {
+    onDismissItem?: (item: PersistentNotificationItem) => void;
+    /** Called before any action's onPress handler fires. Useful for closing a parent popover. */
+    onAction?: () => void;
+    emptyState?: ReactNode;
+}
+/**
+ * Internal context for overlay notification machinery.
+ * Not exported publicly — consumers should use `useNotifications` hook instead.
+ */
+export interface InternalNotificationContextValue {
+    addNotification: (options: OverlayNotificationOptions, ownerId?: string) => Key;
+    removeNotification: (id: Key, reason?: DismissReason) => void;
+    updateNotification: (id: Key, options: Partial<OverlayNotificationOptions>) => void;
+    notifications: InternalNotification[];
+    addPersistentItem: (item: PersistentNotificationItem) => void;
+    removePersistentItem: (id: Key) => void;
+    removePersistentItemsByOwner: (ownerId: string) => void;
+    removeByOwner: (ownerId: string) => void;
+}
+/**
+ * Public context for persistent notifications.
+ * Used by `usePersistentNotifications` and `useNotificationsCount`.
+ */
+export interface PersistentNotificationsContextValue {
+    persistentItems: PersistentNotificationItem[];
+    removePersistentItem: (id: Key) => void;
+    clearPersistentItems: () => void;
+    markAllAsRead: () => void;
+}
+export interface OverlayProviderProps {
+    children: ReactNode;
+    /** Maximum number of persistent notifications to keep. Default: 200 */
+    maxPersistentNotifications?: number;
+}
+export interface NotificationProps extends OverlayNotificationOptions {
+    /** If true, the notification is not removed when the component unmounts */
+    disableRemoveOnUnmount?: boolean;
+}

package/types/components/overlays/Notifications/use-notification-state.d.ts

@@ -0,0 +1,20 @@
+import { Key, useRef } from 'react';
+import type { DismissReason, InternalNotification, OverlayNotificationOptions, PersistentNotificationItem } from './types';
+import type { OverlayTimers } from './use-overlay-timers';
+export interface PersistentCallbacks {
+    addPersistentItem: (item: PersistentNotificationItem) => void;
+}
+export interface NotificationState {
+    notifications: InternalNotification[];
+    notificationsRef: ReturnType<typeof useRef<InternalNotification[]>>;
+    addNotification: (options: OverlayNotificationOptions, ownerId?: string) => Key;
+    removeNotification: (id: Key, reason?: DismissReason) => void;
+    updateNotification: (id: Key, options: Partial<OverlayNotificationOptions>) => void;
+    finalizeNotificationRemoval: (internalId: string) => void;
+    removeByOwner: (ownerId: string) => void;
+}
+/**
+ * @param timersRef - Ref to the shared OverlayTimers instance. Accessed only
+ *   inside callbacks (never during render), so it is guaranteed to be populated.
+ */
+export declare function useNotificationState(timersRef: ReturnType<typeof useRef<OverlayTimers>>, persistent: PersistentCallbacks): NotificationState;

package/types/components/overlays/Notifications/use-notifications.d.ts

@@ -0,0 +1,36 @@
+import type { NotificationsApi } from './types';
+/**
+ * Hook to display and manage notifications.
+ *
+ * Each hook instance acts as an owner scope:
+ * - `notify()` created from this instance attaches ownership metadata.
+ * - On unmount, all attached visible overlay notifications are dismissed.
+ * - On unmount, all attached persistent records are also removed.
+ * - `notify()`/`dismiss()` calls from stale closures after unmount are no-ops.
+ *
+ * @example
+ * ```tsx
+ * const { notify, record, dismiss } = useNotifications();
+ *
+ * notify({
+ *   id: 'deploy:123',
+ *   theme: 'success',
+ *   title: 'Deployment completed',
+ *   description: 'Version 1.4.2 is live.',
+ *   actions: (
+ *     <>
+ *       <Notification.Action onPress={() => openLogs()}>View logs</Notification.Action>
+ *       <Notification.Action onPress={() => openDeployment()}>Open</Notification.Action>
+ *     </>
+ *   ),
+ * });
+ *
+ * // Store directly to persistent list (no overlay)
+ * record({
+ *   id: 'server:alert-1',
+ *   theme: 'warning',
+ *   title: 'Server alert',
+ * });
+ * ```
+ */
+export declare function useNotifications(): NotificationsApi;

package/types/components/overlays/Notifications/use-overlay-timers.d.ts

@@ -0,0 +1,26 @@
+import { Key, useRef } from 'react';
+import type { InternalToast } from '../Toast/types';
+import type { DismissReason, InternalNotification } from './types';
+export interface OverlayTimers {
+    /** Start a toast auto-dismiss timer */
+    startToastTimer: (internalId: string, id: Key, duration: number) => void;
+    /** Clear a toast timer */
+    clearToastTimer: (internalId: string) => void;
+    /** Start a notification auto-dismiss timer */
+    startNotificationTimer: (internalId: string, id: Key, duration: number) => void;
+    /** Clear a notification timer */
+    clearNotificationTimer: (internalId: string) => void;
+    /** Handle pause/resume of all timers (e.g. on hover/focus) */
+    handlePauseChange: (paused: boolean) => void;
+}
+export interface OverlayTimersDeps {
+    /** Ref to current toasts (for resume lookup) */
+    toastsRef: ReturnType<typeof useRef<InternalToast[]>>;
+    /** Ref to current notifications (for resume lookup) */
+    notificationsRef: ReturnType<typeof useRef<InternalNotification[]>>;
+    /** Remove a toast by id */
+    removeToast: (id: Key) => void;
+    /** Remove a notification by id with reason (also invokes onDismiss callback) */
+    removeNotification: (id: Key, reason: DismissReason) => void;
+}
+export declare function useOverlayTimers(deps: OverlayTimersDeps): OverlayTimers;

package/types/components/overlays/Notifications/use-persistent-notifications.d.ts

@@ -0,0 +1,48 @@
+import { Key } from 'react';
+import type { PersistentNotificationItem } from './types';
+/**
+ * Hook to access the persistent notifications list.
+ *
+ * Items are ordered newest first (by `createdAt`, descending).
+ *
+ * @example
+ * ```tsx
+ * const { items, count, remove, clear } = usePersistentNotifications();
+ *
+ * return (
+ *   <div>
+ *     <span>Notifications ({count})</span>
+ *     {items.map(item => (
+ *       <div key={item.id}>
+ *         {item.title}
+ *         <button onClick={() => remove(item.id)}>Remove</button>
+ *       </div>
+ *     ))}
+ *     <button onClick={clear}>Clear all</button>
+ *   </div>
+ * );
+ * ```
+ */
+export declare function usePersistentNotifications(): {
+    items: PersistentNotificationItem[];
+    count: number;
+    remove: (id: Key) => void;
+    clear: () => void;
+    markAllAsRead: () => void;
+};
+/**
+ * Hook to get total and unread counts for persistent notifications.
+ *
+ * - `total` — number of items in the persistent list.
+ * - `unread` — items that haven't been seen in `PersistentNotificationsList` yet.
+ *
+ * @example
+ * ```tsx
+ * const { total, unread } = useNotificationsCount();
+ * return <Badge count={unread} />;
+ * ```
+ */
+export declare function useNotificationsCount(): {
+    total: number;
+    unread: number;
+};

package/types/components/overlays/Notifications/use-persistent-state.d.ts

@@ -0,0 +1,11 @@
+import { Key } from 'react';
+import type { PersistentNotificationItem } from './types';
+export interface PersistentState {
+    persistentItems: PersistentNotificationItem[];
+    addPersistentItem: (item: PersistentNotificationItem) => void;
+    removePersistentItem: (id: Key) => void;
+    removePersistentItemsByOwner: (ownerId: string) => void;
+    clearPersistentItems: () => void;
+    markAllAsRead: () => void;
+}
+export declare function usePersistentState(maxItems: number): PersistentState;

package/types/components/overlays/Notifications/use-toast-state.d.ts

@@ -0,0 +1,16 @@
+import { Key, useRef } from 'react';
+import type { InternalToast, ToastData } from '../Toast/types';
+import type { OverlayTimers } from './use-overlay-timers';
+export interface ToastState {
+    toasts: InternalToast[];
+    toastsRef: ReturnType<typeof useRef<InternalToast[]>>;
+    addToast: (data: ToastData, isProgress?: boolean) => Key;
+    removeToast: (id: Key) => void;
+    updateToast: (id: Key, data: Partial<ToastData>) => void;
+    finalizeToastRemoval: (internalId: string) => void;
+}
+/**
+ * @param timersRef - Ref to the shared OverlayTimers instance. Accessed only
+ *   inside callbacks (never during render), so it is guaranteed to be populated.
+ */
+export declare function useToastState(timersRef: ReturnType<typeof useRef<OverlayTimers>>): ToastState;

package/types/components/overlays/Toast/ToastItem.d.ts

@@ -1,7 +1,7 @@
 import { ReactNode } from 'react';
 import { CubeItemProps } from '../../content/Item/Item';
 import type { ToastType } from './types';
-export interface ToastItemProps extends Partial<Omit<CubeItemProps, 'type'>> {
+export interface ToastItemProps extends Partial<Omit<CubeItemProps, 'type' | 'icon'>> {
     /** Primary content (→ Item children). Also supports description-only for migration. */
     title?: ReactNode;
     /** Secondary content (or primary if no title/children) */
@@ -10,5 +10,7 @@ export interface ToastItemProps extends Partial<Omit<CubeItemProps, 'type'>> {
     theme?: ToastType;
     /** Whether the toast is in loading state */
     isLoading?: boolean;
+    /** Icon to display (resolved ReactNode, not a dynamic icon function) */
+    icon?: ReactNode;
 }
 export declare const ToastItem: import("react").ForwardRefExoticComponent<ToastItemProps & import("react").RefAttributes<HTMLElement>>;

package/types/components/overlays/Toast/ToastProvider.d.ts

@@ -1,8 +1,5 @@
-import { ReactNode } from 'react';
-import type { ToastContextValue } from './types';
-export declare function useToastContext(): ToastContextValue;
-interface ToastProviderProps {
-    children: ReactNode;
-}
-export declare function ToastProvider({ children }: ToastProviderProps): import("react/jsx-runtime").JSX.Element;
-export {};
+/**
+ * Toast context is now provided by OverlayProvider.
+ * This module re-exports useToastContext for backward compatibility.
+ */
+export { useToastContext } from '../Notifications/NotificationContext';

package/types/components/overlays/Toast/index.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
 import { ProgressToastOptions, ToastData } from './types';
-export { ToastProvider, useToastContext } from './ToastProvider';
+export { useToastContext } from './ToastProvider';
 export { ToastItem } from './ToastItem';
 export type { ToastItemProps } from './ToastItem';
 export { useToast, getThemeIcon } from './useToast';

package/types/components/overlays/Toast/types.d.ts

@@ -1,6 +1,8 @@
 import type { Key, ReactNode } from 'react';
 import type { CubeItemProps } from '../../content/Item/Item';
-export type ToastType = 'default' | 'success' | 'danger' | 'warning' | 'note';
+import type { NotificationType } from '../Notifications/types';
+/** @deprecated Use `NotificationType` instead. Kept as alias for backward compatibility. */
+export type ToastType = NotificationType;
 export interface ToastData {
     /** Unique identifier for deduplication (auto-generated if not provided) */
     id?: Key;

package/types/index.d.ts

@@ -105,8 +105,6 @@ export { StatsCard } from './components/organisms/StatsCard/StatsCard';
 export type { CubeStatsCard } from './components/organisms/StatsCard/StatsCard';
 export { AlertDialog, useAlertDialogAPI, } from './components/overlays/AlertDialog';
 export type { CubeAlertDialogProps } from './components/overlays/AlertDialog';
-export { notification } from './services/notification';
-export type { CubeNotificationOptions } from './services/notification';
 export * from './tasty';
 export declare const Typography: {
     Text: import("./components/content/Text").TextComponent;
@@ -128,8 +126,8 @@ export * from './utils';
 export * from './tasty';
 export { default as copy } from 'clipboard-copy';
 export * from '@react-aria/ssr';
-export * from './components/overlays/NewNotifications';
 export * from './components/overlays/Toast';
+export * from './components/overlays/Notifications';
 export * from './shared';
 export * from './icons';
 export * from './components/form';

package/types/tasty/index.d.ts

@@ -29,5 +29,3 @@ export * from './debug';
 export type { TastyProps, TastyElementOptions, TastyElementProps, AllBasePropsWithMods, SubElementDefinition, ElementsDefinition, SubElementProps, } from './tasty';
 export type { AllBaseProps, BaseProps, BaseStyleProps, DimensionStyleProps, ColorStyleProps, OuterStyleProps, PositionStyleProps, TextStyleProps, BlockStyleProps, BlockInnerStyleProps, BlockOuterStyleProps, ContainerStyleProps, BasePropsWithoutChildren, Props, FlowStyleProps, ShortGridStyles, GlobalStyledProps, TagName, Mods, ModValue, Tokens, TokenValue, TastyExtensionConfig, } from './types';
 export type { StylesInterface, Styles, StylesWithoutSelectors, RecipeStyles, NoType, Selector, SuffixForSelector, NotSelector, } from './styles/types';
-export { glaze } from './glaze';
-export type { GlazeConfig, GlazeTheme, GlazePalette, GlazeTokenOptions, GlazeJsonOptions, GlazeOutputModes, ColorDef, ResolvedColor, AdaptationMode, HCPair, MinContrast, } from './glaze';

package/es/components/overlays/NewNotifications/Bar/FloatingNotification.js

@@ -1,54 +0,0 @@
-/**
- * @license MIT
- * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-e2a9f35
- * Released under the MIT license.
- */
-
-import { jsx as _jsx } from "react/jsx-runtime";
-import { memo, useRef } from 'react';
-import { useChainedCallback, useEvent, useTimer } from '../../../../_internal/index.js';
-import { tasty } from '../../../../tasty/index.js';
-import { useNotificationListItem, } from '../hooks/index.js';
-import { NotificationView } from '../NotificationView/index.js';
-const NotificationContainer = tasty({
-    styles: {
-        overflow: 'hidden',
-        radius: '1cr',
-        shadow: true,
-        pointerEvents: 'auto',
-    },
-});
-/**
- * @internal This component is unstable and must not be used outside of `NotificationsBar`.
- */
-export const FloatingNotification = memo(function FloatingNotification(props) {
-    const { item, state, onRemoveNotification, id, isDisabledTimer, onDismissNotification, } = props;
-    const { props: notificationProps, key } = item;
-    const ref = useRef(null);
-    const onCloseEvent = useChainedCallback(() => onRemoveNotification(id), notificationProps.onClose);
-    const chainedOnDismiss = useChainedCallback(() => onDismissNotification(id), () => onRemoveNotification(id), notificationProps.onDismiss);
-    const onKeyDown = useEvent(({ key }) => {
-        if (notificationProps.isDismissible === false) {
-            return;
-        }
-        const closeKeys = ['Delete', 'Backspace', 'Escape'];
-        if (closeKeys.includes(key)) {
-            chainedOnDismiss();
-        }
-    });
-    const { itemProps } = useNotificationListItem({ key, ref, state });
-    const { timer } = useTimer({
-        callback: chainedOnDismiss,
-        delay: notificationProps.duration,
-        isDisabled: isDisabledTimer,
-    });
-    return (_jsx(NotificationContainer, { children: _jsx(NotificationView, { ref: ref, ...notificationProps, timer: timer, attributes: {
-                ...itemProps,
-                onKeyDown,
-                role: 'status',
-                'aria-atomic': 'true',
-            }, qa: "FloatingNotification", onDismiss: chainedOnDismiss, onClose: onCloseEvent }) }));
-});
-
-