@cube-dev/ui-kit 0.113.1 → 0.115.0

package/dist/components/overlays/Notifications/use-persistent-notifications.js

@@ -0,0 +1,61 @@
+/** @license MIT | @cube-dev/ui-kit v0.115.0 | Cube Dev Team */
+import { usePersistentNotificationsContext } from "./NotificationContext.js";
+import { useMemo } from "react";
+
+//#region src/components/overlays/Notifications/use-persistent-notifications.ts
+/**
+* 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>
+* );
+* ```
+*/
+function usePersistentNotifications() {
+	const { persistentItems, removePersistentItem, clearPersistentItems, markAllAsRead } = usePersistentNotificationsContext();
+	return useMemo(() => ({
+		items: persistentItems,
+		count: persistentItems.length,
+		remove: removePersistentItem,
+		clear: clearPersistentItems,
+		markAllAsRead
+	}), [persistentItems]);
+}
+/**
+* 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} />;
+* ```
+*/
+function useNotificationsCount() {
+	const { persistentItems } = usePersistentNotificationsContext();
+	return useMemo(() => ({
+		total: persistentItems.length,
+		unread: persistentItems.filter((i) => !i.isRead).length
+	}), [persistentItems]);
+}
+
+//#endregion
+export { useNotificationsCount, usePersistentNotifications };
+//# sourceMappingURL=use-persistent-notifications.js.map

package/dist/components/overlays/Notifications/use-persistent-notifications.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-persistent-notifications.js","names":[],"sources":["../../../../src/components/overlays/Notifications/use-persistent-notifications.ts"],"sourcesContent":["import { Key, useMemo } from 'react';\n\nimport { usePersistentNotificationsContext } from './NotificationContext';\n\nimport type { PersistentNotificationItem } from './types';\n\n/**\n * Hook to access the persistent notifications list.\n *\n * Items are ordered newest first (by `createdAt`, descending).\n *\n * @example\n * ```tsx\n * const { items, count, remove, clear } = usePersistentNotifications();\n *\n * return (\n *   <div>\n *     <span>Notifications ({count})</span>\n *     {items.map(item => (\n *       <div key={item.id}>\n *         {item.title}\n *         <button onClick={() => remove(item.id)}>Remove</button>\n *       </div>\n *     ))}\n *     <button onClick={clear}>Clear all</button>\n *   </div>\n * );\n * ```\n */\nexport function usePersistentNotifications(): {\n  items: PersistentNotificationItem[];\n  count: number;\n  remove: (id: Key) => void;\n  clear: () => void;\n  markAllAsRead: () => void;\n} {\n  const {\n    persistentItems,\n    removePersistentItem,\n    clearPersistentItems,\n    markAllAsRead,\n  } = usePersistentNotificationsContext();\n\n  return useMemo(\n    () => ({\n      items: persistentItems,\n      count: persistentItems.length,\n      remove: removePersistentItem,\n      clear: clearPersistentItems,\n      markAllAsRead,\n    }),\n    [persistentItems],\n  );\n}\n\n/**\n * Hook to get total and unread counts for persistent notifications.\n *\n * - `total` — number of items in the persistent list.\n * - `unread` — items that haven't been seen in `PersistentNotificationsList` yet.\n *\n * @example\n * ```tsx\n * const { total, unread } = useNotificationsCount();\n * return <Badge count={unread} />;\n * ```\n */\nexport function useNotificationsCount(): { total: number; unread: number } {\n  const { persistentItems } = usePersistentNotificationsContext();\n\n  return useMemo(\n    () => ({\n      total: persistentItems.length,\n      unread: persistentItems.filter((i) => !i.isRead).length,\n    }),\n    [persistentItems],\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,6BAMd;CACA,MAAM,EACJ,iBACA,sBACA,sBACA,kBACE,mCAAmC;AAEvC,QAAO,eACE;EACL,OAAO;EACP,OAAO,gBAAgB;EACvB,QAAQ;EACR,OAAO;EACP;EACD,GACD,CAAC,gBAAgB,CAClB;;;;;;;;;;;;;;AAeH,SAAgB,wBAA2D;CACzE,MAAM,EAAE,oBAAoB,mCAAmC;AAE/D,QAAO,eACE;EACL,OAAO,gBAAgB;EACvB,QAAQ,gBAAgB,QAAQ,MAAM,CAAC,EAAE,OAAO,CAAC;EAClD,GACD,CAAC,gBAAgB,CAClB"}

package/dist/components/overlays/Notifications/use-persistent-state.js

@@ -0,0 +1,64 @@
+/** @license MIT | @cube-dev/ui-kit v0.115.0 | Cube Dev Team */
+import { useEvent } from "../../../_internal/hooks/use-event.js";
+import { useRef, useState } from "react";
+
+//#region src/components/overlays/Notifications/use-persistent-state.ts
+function usePersistentState(maxItems) {
+	const [persistentItems, setPersistentItems] = useState([]);
+	const dismissedPersistentIdsRef = useRef(/* @__PURE__ */ new Set());
+	const fullyDismissedIdsRef = useRef(/* @__PURE__ */ new Set());
+	return {
+		persistentItems,
+		addPersistentItem: useEvent((item) => {
+			if (fullyDismissedIdsRef.current.has(item.id)) return;
+			dismissedPersistentIdsRef.current.add(item.id);
+			setPersistentItems((prev) => {
+				const existingIndex = prev.findIndex((i) => i.id === item.id);
+				let newItems;
+				if (existingIndex !== -1) {
+					newItems = [...prev];
+					newItems[existingIndex] = {
+						...newItems[existingIndex],
+						...item,
+						isRead: false
+					};
+				} else newItems = [{
+					...item,
+					isRead: item.isRead ?? false
+				}, ...prev];
+				if (newItems.length > maxItems) newItems = newItems.slice(0, maxItems);
+				newItems.sort((a, b) => b.createdAt - a.createdAt);
+				return newItems;
+			});
+		}),
+		removePersistentItem: useEvent((id) => {
+			fullyDismissedIdsRef.current.add(id);
+			setPersistentItems((prev) => prev.filter((i) => i.id !== id));
+		}),
+		removePersistentItemsByOwner: useEvent((ownerId) => {
+			setPersistentItems((prev) => prev.filter((i) => i.ownerId !== ownerId));
+		}),
+		clearPersistentItems: useEvent(() => {
+			setPersistentItems([]);
+		}),
+		markAllAsRead: useEvent(() => {
+			setPersistentItems((prev) => {
+				if (!prev.some((i) => !i.isRead)) return prev;
+				return prev.map((i) => i.isRead ? i : {
+					...i,
+					isRead: true
+				});
+			});
+		}),
+		hasDismissedPersistentId: useEvent((id) => {
+			return dismissedPersistentIdsRef.current.has(id);
+		}),
+		isFullyDismissedId: useEvent((id) => {
+			return fullyDismissedIdsRef.current.has(id);
+		})
+	};
+}
+
+//#endregion
+export { usePersistentState };
+//# sourceMappingURL=use-persistent-state.js.map

package/dist/components/overlays/Notifications/use-persistent-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-persistent-state.js","names":[],"sources":["../../../../src/components/overlays/Notifications/use-persistent-state.ts"],"sourcesContent":["import { Key, useRef, useState } from 'react';\n\nimport { useEvent } from '../../../_internal';\n\nimport type { PersistentNotificationItem } from './types';\n\n// ─── Types ───────────────────────────────────────────────────────────\n\nexport interface PersistentState {\n  persistentItems: PersistentNotificationItem[];\n  addPersistentItem: (item: PersistentNotificationItem) => void;\n  removePersistentItem: (id: Key) => void;\n  removePersistentItemsByOwner: (ownerId: string) => void;\n  clearPersistentItems: () => void;\n  markAllAsRead: () => void;\n  /**\n   * Returns true if the given id was previously moved to the persistent list\n   * and has NOT been explicitly removed from it (i.e. still archived, or was\n   * auto-dismissed but not yet user-dismissed from the persistent list).\n   */\n  hasDismissedPersistentId: (id: Key) => boolean;\n  /**\n   * Returns true if the given id was explicitly removed from the persistent\n   * list by the user. Such notifications should be completely ignored on\n   * subsequent triggers (no overlay, no persistent storage).\n   */\n  isFullyDismissedId: (id: Key) => boolean;\n}\n\n// ─── Hook ────────────────────────────────────────────────────────────\n\nexport function usePersistentState(maxItems: number): PersistentState {\n  const [persistentItems, setPersistentItems] = useState<\n    PersistentNotificationItem[]\n  >([]);\n\n  // Tracks IDs that have been moved to the persistent list at least once.\n  // Used to skip the overlay when the same id reappears.\n  const dismissedPersistentIdsRef = useRef<Set<Key>>(new Set());\n\n  // Tracks IDs that were explicitly removed from the persistent list by the\n  // user. These should be completely ignored on subsequent triggers.\n  const fullyDismissedIdsRef = useRef<Set<Key>>(new Set());\n\n  const addPersistentItem = useEvent((item: PersistentNotificationItem) => {\n    // If the user already dismissed this item from the persistent list, don't re-add it.\n    if (fullyDismissedIdsRef.current.has(item.id)) return;\n\n    dismissedPersistentIdsRef.current.add(item.id);\n\n    setPersistentItems((prev) => {\n      // Upsert by id\n      const existingIndex = prev.findIndex((i) => i.id === item.id);\n      let newItems: PersistentNotificationItem[];\n\n      if (existingIndex !== -1) {\n        newItems = [...prev];\n        // Updated items are marked unread again\n        newItems[existingIndex] = {\n          ...newItems[existingIndex],\n          ...item,\n          isRead: false,\n        };\n      } else {\n        newItems = [{ ...item, isRead: item.isRead ?? false }, ...prev];\n      }\n\n      // Enforce max cap\n      if (newItems.length > maxItems) {\n        newItems = newItems.slice(0, maxItems);\n      }\n\n      // Sort newest first\n      newItems.sort((a, b) => b.createdAt - a.createdAt);\n\n      return newItems;\n    });\n  });\n\n  const removePersistentItem = useEvent((id: Key) => {\n    fullyDismissedIdsRef.current.add(id);\n    setPersistentItems((prev) => prev.filter((i) => i.id !== id));\n  });\n\n  const removePersistentItemsByOwner = useEvent((ownerId: string) => {\n    setPersistentItems((prev) => prev.filter((i) => i.ownerId !== ownerId));\n  });\n\n  const clearPersistentItems = useEvent(() => {\n    setPersistentItems([]);\n  });\n\n  const markAllAsRead = useEvent(() => {\n    setPersistentItems((prev) => {\n      const hasUnread = prev.some((i) => !i.isRead);\n\n      if (!hasUnread) return prev;\n\n      return prev.map((i) => (i.isRead ? i : { ...i, isRead: true }));\n    });\n  });\n\n  const hasDismissedPersistentId = useEvent((id: Key): boolean => {\n    return dismissedPersistentIdsRef.current.has(id);\n  });\n\n  const isFullyDismissedId = useEvent((id: Key): boolean => {\n    return fullyDismissedIdsRef.current.has(id);\n  });\n\n  return {\n    persistentItems,\n    addPersistentItem,\n    removePersistentItem,\n    removePersistentItemsByOwner,\n    clearPersistentItems,\n    markAllAsRead,\n    hasDismissedPersistentId,\n    isFullyDismissedId,\n  };\n}\n"],"mappings":";;;;;AA+BA,SAAgB,mBAAmB,UAAmC;CACpE,MAAM,CAAC,iBAAiB,sBAAsB,SAE5C,EAAE,CAAC;CAIL,MAAM,4BAA4B,uBAAiB,IAAI,KAAK,CAAC;CAI7D,MAAM,uBAAuB,uBAAiB,IAAI,KAAK,CAAC;AAoExD,QAAO;EACL;EACA,mBApEwB,UAAU,SAAqC;AAEvE,OAAI,qBAAqB,QAAQ,IAAI,KAAK,GAAG,CAAE;AAE/C,6BAA0B,QAAQ,IAAI,KAAK,GAAG;AAE9C,uBAAoB,SAAS;IAE3B,MAAM,gBAAgB,KAAK,WAAW,MAAM,EAAE,OAAO,KAAK,GAAG;IAC7D,IAAI;AAEJ,QAAI,kBAAkB,IAAI;AACxB,gBAAW,CAAC,GAAG,KAAK;AAEpB,cAAS,iBAAiB;MACxB,GAAG,SAAS;MACZ,GAAG;MACH,QAAQ;MACT;UAED,YAAW,CAAC;KAAE,GAAG;KAAM,QAAQ,KAAK,UAAU;KAAO,EAAE,GAAG,KAAK;AAIjE,QAAI,SAAS,SAAS,SACpB,YAAW,SAAS,MAAM,GAAG,SAAS;AAIxC,aAAS,MAAM,GAAG,MAAM,EAAE,YAAY,EAAE,UAAU;AAElD,WAAO;KACP;IACF;EAoCA,sBAlC2B,UAAU,OAAY;AACjD,wBAAqB,QAAQ,IAAI,GAAG;AACpC,uBAAoB,SAAS,KAAK,QAAQ,MAAM,EAAE,OAAO,GAAG,CAAC;IAC7D;EAgCA,8BA9BmC,UAAU,YAAoB;AACjE,uBAAoB,SAAS,KAAK,QAAQ,MAAM,EAAE,YAAY,QAAQ,CAAC;IACvE;EA6BA,sBA3B2B,eAAe;AAC1C,sBAAmB,EAAE,CAAC;IACtB;EA0BA,eAxBoB,eAAe;AACnC,uBAAoB,SAAS;AAG3B,QAAI,CAFc,KAAK,MAAM,MAAM,CAAC,EAAE,OAAO,CAE7B,QAAO;AAEvB,WAAO,KAAK,KAAK,MAAO,EAAE,SAAS,IAAI;KAAE,GAAG;KAAG,QAAQ;KAAM,CAAE;KAC/D;IACF;EAiBA,0BAf+B,UAAU,OAAqB;AAC9D,UAAO,0BAA0B,QAAQ,IAAI,GAAG;IAChD;EAcA,oBAZyB,UAAU,OAAqB;AACxD,UAAO,qBAAqB,QAAQ,IAAI,GAAG;IAC3C;EAWD"}

package/dist/components/overlays/Notifications/use-toast-state.js

@@ -0,0 +1,108 @@
+/** @license MIT | @cube-dev/ui-kit v0.115.0 | Cube Dev Team */
+import { useEvent } from "../../../_internal/hooks/use-event.js";
+import { useRef, useState } from "react";
+
+//#region src/components/overlays/Notifications/use-toast-state.ts
+const DEFAULT_TOAST_DURATION = 5e3;
+const MAX_TOASTS = 3;
+/**
+* Generate a deduplication key for a toast.
+* Uses JSON.stringify with alphabetically ordered keys to prevent false
+* collisions when title/description contains separator characters.
+*/
+function generateToastDedupeKey(data) {
+	if (data.id != null) return String(data.id);
+	return JSON.stringify({
+		description: typeof data.description === "string" ? data.description : "",
+		theme: data.theme ?? "default",
+		title: typeof data.title === "string" ? data.title : ""
+	});
+}
+function matchesToastId(item, id) {
+	return item.id === id || item.internalId === String(id);
+}
+function findToast(list, id) {
+	return list.find((t) => matchesToastId(t, id));
+}
+/**
+* @param timersRef - Ref to the shared OverlayTimers instance. Accessed only
+*   inside callbacks (never during render), so it is guaranteed to be populated.
+*/
+function useToastState(timersRef) {
+	const [toasts, setToasts] = useState([]);
+	const toastsRef = useRef(toasts);
+	toastsRef.current = toasts;
+	const idCounter = useRef(0);
+	const removeToast = useEvent((id) => {
+		const toast = findToast(toastsRef.current, id);
+		if (toast) timersRef.current?.clearToastTimer(toast.internalId);
+		setToasts((prev) => prev.map((t) => matchesToastId(t, id) ? {
+			...t,
+			isExiting: true
+		} : t));
+	});
+	const finalizeToastRemoval = useEvent((internalId) => {
+		setToasts((prev) => prev.filter((t) => t.internalId !== internalId));
+	});
+	return {
+		toasts,
+		toastsRef,
+		addToast: useEvent((data, isProgress = false) => {
+			idCounter.current += 1;
+			const internalId = `toast-${idCounter.current}-${Date.now()}`;
+			const dedupeKey = generateToastDedupeKey(data);
+			const duration = isProgress ? null : data.duration ?? DEFAULT_TOAST_DURATION;
+			const newToast = {
+				...data,
+				internalId,
+				isProgress,
+				dedupeKey,
+				createdAt: Date.now()
+			};
+			const existingToast = toastsRef.current.find((t) => t.dedupeKey === dedupeKey && !t.isExiting);
+			if (existingToast) timersRef.current?.clearToastTimer(existingToast.internalId);
+			let wasEvicted = false;
+			const evictedIds = [];
+			setToasts((prev) => {
+				let newToasts = prev;
+				if (existingToast) newToasts = newToasts.map((t) => t.internalId === existingToast.internalId ? {
+					...t,
+					isExiting: true
+				} : t);
+				newToasts = [...newToasts, newToast];
+				const activeToasts = newToasts.filter((t) => !t.isExiting);
+				const progressToasts = activeToasts.filter((t) => t.isProgress);
+				const temporalToasts = activeToasts.filter((t) => !t.isProgress);
+				while (activeToasts.length > MAX_TOASTS) if (temporalToasts.length > 1 || progressToasts.length < MAX_TOASTS) {
+					const oldestTemporal = temporalToasts.shift();
+					if (oldestTemporal) {
+						evictedIds.push(oldestTemporal.internalId);
+						newToasts = newToasts.map((t) => t.internalId === oldestTemporal.internalId ? {
+							...t,
+							isExiting: true
+						} : t);
+						const idx = activeToasts.findIndex((t) => t.internalId === oldestTemporal.internalId);
+						if (idx !== -1) activeToasts.splice(idx, 1);
+						if (oldestTemporal.internalId === internalId) wasEvicted = true;
+					} else break;
+				} else break;
+				return newToasts;
+			});
+			for (const evictedId of evictedIds) timersRef.current?.clearToastTimer(evictedId);
+			if (!wasEvicted && duration != null && duration > 0) timersRef.current?.startToastTimer(internalId, data.id ?? internalId, duration);
+			return data.id ?? internalId;
+		}),
+		removeToast,
+		updateToast: useEvent((id, data) => {
+			setToasts((prev) => prev.map((t) => matchesToastId(t, id) ? {
+				...t,
+				...data
+			} : t));
+		}),
+		finalizeToastRemoval
+	};
+}
+
+//#endregion
+export { useToastState };
+//# sourceMappingURL=use-toast-state.js.map

package/dist/components/overlays/Notifications/use-toast-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-toast-state.js","names":[],"sources":["../../../../src/components/overlays/Notifications/use-toast-state.ts"],"sourcesContent":["import { Key, useRef, useState } from 'react';\n\nimport { useEvent } from '../../../_internal';\n\nimport type { InternalToast, ToastData } from '../Toast/types';\nimport type { OverlayTimers } from './use-overlay-timers';\n\n// ─── Constants ───────────────────────────────────────────────────────\n\nconst DEFAULT_TOAST_DURATION = 5000;\nconst MAX_TOASTS = 3;\n\n// ─── Dedupe Key ──────────────────────────────────────────────────────\n\n/**\n * Generate a deduplication key for a toast.\n * Uses JSON.stringify with alphabetically ordered keys to prevent false\n * collisions when title/description contains separator characters.\n */\nfunction generateToastDedupeKey(data: ToastData): string {\n  if (data.id != null) return String(data.id);\n\n  return JSON.stringify({\n    description: typeof data.description === 'string' ? data.description : '',\n    theme: data.theme ?? 'default',\n    title: typeof data.title === 'string' ? data.title : '',\n  });\n}\n\n// ─── Helpers ─────────────────────────────────────────────────────────\n\nfunction matchesToastId(item: InternalToast, id: Key): boolean {\n  return item.id === id || item.internalId === String(id);\n}\n\nfunction findToast(list: InternalToast[], id: Key): InternalToast | undefined {\n  return list.find((t) => matchesToastId(t, id));\n}\n\n// ─── Types ───────────────────────────────────────────────────────────\n\nexport interface ToastState {\n  toasts: InternalToast[];\n  toastsRef: ReturnType<typeof useRef<InternalToast[]>>;\n  addToast: (data: ToastData, isProgress?: boolean) => Key;\n  removeToast: (id: Key) => void;\n  updateToast: (id: Key, data: Partial<ToastData>) => void;\n  finalizeToastRemoval: (internalId: string) => void;\n}\n\n// ─── Hook ────────────────────────────────────────────────────────────\n\n/**\n * @param timersRef - Ref to the shared OverlayTimers instance. Accessed only\n *   inside callbacks (never during render), so it is guaranteed to be populated.\n */\nexport function useToastState(\n  timersRef: ReturnType<typeof useRef<OverlayTimers>>,\n): ToastState {\n  const [toasts, setToasts] = useState<InternalToast[]>([]);\n  const toastsRef = useRef(toasts);\n  toastsRef.current = toasts;\n\n  const idCounter = useRef(0);\n\n  const removeToast = useEvent((id: Key) => {\n    // Perform side effects outside the updater (StrictMode-safe).\n    const toast = findToast(toastsRef.current, id);\n\n    if (toast) {\n      timersRef.current?.clearToastTimer(toast.internalId);\n    }\n\n    setToasts((prev) =>\n      prev.map((t) => (matchesToastId(t, id) ? { ...t, isExiting: true } : t)),\n    );\n  });\n\n  const finalizeToastRemoval = useEvent((internalId: string) => {\n    setToasts((prev) => prev.filter((t) => t.internalId !== internalId));\n  });\n\n  const addToast = useEvent((data: ToastData, isProgress = false): Key => {\n    idCounter.current += 1;\n    const internalId = `toast-${idCounter.current}-${Date.now()}`;\n    const dedupeKey = generateToastDedupeKey(data);\n    const duration = isProgress\n      ? null\n      : data.duration ?? DEFAULT_TOAST_DURATION;\n\n    const newToast: InternalToast = {\n      ...data,\n      internalId,\n      isProgress,\n      dedupeKey,\n      createdAt: Date.now(),\n    };\n\n    // Perform dedupe side effects outside the updater (StrictMode-safe).\n    const existingToast = toastsRef.current.find(\n      (t) => t.dedupeKey === dedupeKey && !t.isExiting,\n    );\n\n    if (existingToast) {\n      timersRef.current?.clearToastTimer(existingToast.internalId);\n    }\n\n    // Single setState call: mark duplicate as exiting, append new toast,\n    // and evict oldest temporal toasts if we exceed MAX_TOASTS.\n    // Track evicted IDs so we can clear timers outside the updater (StrictMode-safe).\n    let wasEvicted = false;\n    const evictedIds: string[] = [];\n\n    setToasts((prev) => {\n      let newToasts = prev;\n\n      // Mark existing toast with same dedupe key as exiting\n      if (existingToast) {\n        newToasts = newToasts.map((t) =>\n          t.internalId === existingToast.internalId\n            ? { ...t, isExiting: true }\n            : t,\n        );\n      }\n\n      // Append the new toast\n      newToasts = [...newToasts, newToast];\n\n      // Evict oldest temporal toasts if over the cap\n      const activeToasts = newToasts.filter((t) => !t.isExiting);\n      const progressToasts = activeToasts.filter((t) => t.isProgress);\n      const temporalToasts = activeToasts.filter((t) => !t.isProgress);\n\n      while (activeToasts.length > MAX_TOASTS) {\n        if (temporalToasts.length > 1 || progressToasts.length < MAX_TOASTS) {\n          const oldestTemporal = temporalToasts.shift();\n\n          if (oldestTemporal) {\n            evictedIds.push(oldestTemporal.internalId);\n            newToasts = newToasts.map((t) =>\n              t.internalId === oldestTemporal.internalId\n                ? { ...t, isExiting: true }\n                : t,\n            );\n            const idx = activeToasts.findIndex(\n              (t) => t.internalId === oldestTemporal.internalId,\n            );\n\n            if (idx !== -1) activeToasts.splice(idx, 1);\n\n            // Check if the newly added toast was evicted\n            if (oldestTemporal.internalId === internalId) {\n              wasEvicted = true;\n            }\n          } else {\n            break;\n          }\n        } else {\n          break;\n        }\n      }\n\n      return newToasts;\n    });\n\n    // Clear timers for evicted toasts outside the updater (StrictMode-safe)\n    for (const evictedId of evictedIds) {\n      timersRef.current?.clearToastTimer(evictedId);\n    }\n\n    // Start timer only if the toast wasn't immediately evicted\n    if (!wasEvicted && duration != null && duration > 0) {\n      timersRef.current?.startToastTimer(\n        internalId,\n        data.id ?? internalId,\n        duration,\n      );\n    }\n\n    return data.id ?? internalId;\n  });\n\n  const updateToast = useEvent((id: Key, data: Partial<ToastData>) => {\n    setToasts((prev) =>\n      prev.map((t) => (matchesToastId(t, id) ? { ...t, ...data } : t)),\n    );\n  });\n\n  return {\n    toasts,\n    toastsRef,\n    addToast,\n    removeToast,\n    updateToast,\n    finalizeToastRemoval,\n  };\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,23 @@
+
+import { CubeItemProps } from "../../content/Item/Item.js";
+import { ToastType } from "./types.js";
+import * as react from "react";
+import { ReactNode } from "react";
+
+//#region src/components/overlays/Toast/ToastItem.d.ts
+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) */
+  description?: ReactNode;
+  /** Visual theme */
+  theme?: ToastType;
+  /** Whether the toast is in loading state */
+  isLoading?: boolean;
+  /** Icon to display (resolved ReactNode, not a dynamic icon function) */
+  icon?: ReactNode;
+}
+declare const ToastItem: react.ForwardRefExoticComponent<ToastItemProps & react.RefAttributes<HTMLElement>>;
+//#endregion
+export { ToastItem, ToastItemProps };
+//# sourceMappingURL=ToastItem.d.ts.map

package/dist/components/overlays/Toast/ToastItem.js

@@ -0,0 +1,34 @@
+/** @license MIT | @cube-dev/ui-kit v0.115.0 | Cube Dev Team */
+import { tasty } from "../../../tasty/tasty.js";
+import { _Item } from "../../content/Item/Item.js";
+import { getThemeIcon } from "./useToast.js";
+import { forwardRef } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/components/overlays/Toast/ToastItem.tsx
+const StyledItem = tasty(_Item, { styles: {
+	shadow: "$shadow",
+	transition: "theme, inset",
+	pointerEvents: "none",
+	Description: { preset: "t4" }
+} });
+const ToastItem = forwardRef(function ToastItem(props, ref) {
+	const { title, description, theme, isLoading, icon: providedIcon, children, qa, ...itemProps } = props;
+	const icon = getThemeIcon(theme, providedIcon, isLoading);
+	const primaryContent = children ?? title ?? description;
+	return /* @__PURE__ */ jsx(StyledItem, {
+		ref,
+		qa: qa ?? "Toast",
+		type: "card",
+		theme,
+		icon,
+		isLoading,
+		description: children || title ? description : void 0,
+		...itemProps,
+		children: primaryContent
+	});
+});
+
+//#endregion
+export { ToastItem };
+//# sourceMappingURL=ToastItem.js.map

package/dist/components/overlays/Toast/ToastItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToastItem.js","names":["Item"],"sources":["../../../../src/components/overlays/Toast/ToastItem.tsx"],"sourcesContent":["import { forwardRef, ReactNode } from 'react';\n\nimport { tasty } from '../../../tasty';\nimport { CubeItemProps, Item } from '../../content/Item/Item';\n\nimport { getThemeIcon } from './useToast';\n\nimport type { ToastType } from './types';\n\nexport interface ToastItemProps\n  extends Partial<Omit<CubeItemProps, 'type' | 'icon'>> {\n  /** Primary content (→ Item children). Also supports description-only for migration. */\n  title?: ReactNode;\n  /** Secondary content (or primary if no title/children) */\n  description?: ReactNode;\n  /** Visual theme */\n  theme?: ToastType;\n  /** Whether the toast is in loading state */\n  isLoading?: boolean;\n  /** Icon to display (resolved ReactNode, not a dynamic icon function) */\n  icon?: ReactNode;\n}\n\nconst StyledItem = tasty(Item, {\n  styles: {\n    shadow: '$shadow',\n    transition: 'theme, inset',\n    pointerEvents: 'none',\n\n    Description: {\n      preset: 't4',\n    },\n  },\n});\n\nexport const ToastItem = forwardRef<HTMLElement, ToastItemProps>(\n  function ToastItem(props, ref) {\n    const {\n      title,\n      description,\n      theme,\n      isLoading,\n      icon: providedIcon,\n      children,\n      qa,\n      ...itemProps\n    } = props;\n\n    const icon = getThemeIcon(theme, providedIcon, isLoading);\n\n    // If only description provided (no title/children), use description as primary content\n    const primaryContent = children ?? title ?? description;\n    const secondaryContent = children || title ? description : undefined;\n\n    return (\n      <StyledItem\n        ref={ref}\n        qa={qa ?? 'Toast'}\n        type=\"card\"\n        theme={theme}\n        icon={icon}\n        isLoading={isLoading}\n        description={secondaryContent}\n        {...itemProps}\n      >\n        {primaryContent}\n      </StyledItem>\n    );\n  },\n);\n"],"mappings":";;;;;;;;AAuBA,MAAM,aAAa,MAAMA,OAAM,EAC7B,QAAQ;CACN,QAAQ;CACR,YAAY;CACZ,eAAe;CAEf,aAAa,EACX,QAAQ,MACT;CACF,EACF,CAAC;AAEF,MAAa,YAAY,WACvB,SAAS,UAAU,OAAO,KAAK;CAC7B,MAAM,EACJ,OACA,aACA,OACA,WACA,MAAM,cACN,UACA,IACA,GAAG,cACD;CAEJ,MAAM,OAAO,aAAa,OAAO,cAAc,UAAU;CAGzD,MAAM,iBAAiB,YAAY,SAAS;AAG5C,QACE,oBAAC;EACM;EACL,IAAI,MAAM;EACV,MAAK;EACE;EACD;EACK;EACX,aAVqB,YAAY,QAAQ,cAAc;EAWvD,GAAI;YAEH;GACU;EAGlB"}

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

@@ -0,0 +1,2 @@
+
+import { useToastContext } from "../Notifications/NotificationContext.js";

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

@@ -0,0 +1,54 @@
+
+import { ProgressToastEmpty, ProgressToastOptions, ToastApi, ToastData, ToastType } from "./types.js";
+import { useToastContext } from "../Notifications/NotificationContext.js";
+import "./ToastProvider.js";
+import { ToastItem, ToastItemProps } from "./ToastItem.js";
+import { getThemeIcon, useToast } from "./useToast.js";
+import { useProgressToast } from "./useProgressToast.js";
+import { ReactNode } from "react";
+
+//#region src/components/overlays/Toast/index.d.ts
+interface ToastProps extends Omit<ToastData, 'duration'> {
+  /** Primary content */
+  children?: ReactNode;
+}
+/**
+ * Declarative Toast component that shows a toast while mounted.
+ *
+ * @example
+ * ```tsx
+ * // Simple toast (visible while mounted)
+ * <Toast theme="success">Saved successfully</Toast>
+ *
+ * // With description
+ * <Toast title="Success" description="Changes saved" theme="success" />
+ * ```
+ */
+declare function Toast(props: ToastProps): null;
+declare namespace Toast {
+  var Progress: typeof ToastProgress;
+}
+interface ToastProgressProps extends ProgressToastOptions {
+  /** Primary content (alternative to title) */
+  children?: ReactNode;
+}
+/**
+ * Declarative Progress Toast component.
+ *
+ * @example
+ * ```tsx
+ * <Toast.Progress
+ *   {...(isLoading
+ *     ? { isLoading: true, title: 'Saving...' }
+ *     : { isLoading: false, title: 'Saved!', theme: 'success' }
+ *   )}
+ * />
+ * ```
+ */
+declare function ToastProgress(props: ToastProgressProps): null;
+type ToastComponent = typeof Toast & {
+  Progress: typeof ToastProgress;
+};
+//#endregion
+export { Toast, ToastComponent, ToastProgressProps, ToastProps };
+//# sourceMappingURL=index.d.ts.map

package/dist/components/overlays/Toast/index.js

@@ -0,0 +1,80 @@
+/** @license MIT | @cube-dev/ui-kit v0.115.0 | Cube Dev Team */
+import { useToastContext } from "../Notifications/NotificationContext.js";
+import { useProgressToast } from "./useProgressToast.js";
+import { getThemeIcon, useToast } from "./useToast.js";
+import { ToastItem } from "./ToastItem.js";
+import { useEffect, useRef } from "react";
+
+//#region src/components/overlays/Toast/index.ts
+/**
+* Declarative Toast component that shows a toast while mounted.
+*
+* @example
+* ```tsx
+* // Simple toast (visible while mounted)
+* <Toast theme="success">Saved successfully</Toast>
+*
+* // With description
+* <Toast title="Success" description="Changes saved" theme="success" />
+* ```
+*/
+function Toast(props) {
+	const { children, ...toastData } = props;
+	const { addToast, removeToast, updateToast } = useToastContext();
+	const toastIdRef = useRef(null);
+	useEffect(() => {
+		toastIdRef.current = addToast({
+			...toastData,
+			title: toastData.title ?? children,
+			duration: null
+		}, true);
+		return () => {
+			if (toastIdRef.current != null) {
+				removeToast(toastIdRef.current);
+				toastIdRef.current = null;
+			}
+		};
+	}, []);
+	useEffect(() => {
+		if (toastIdRef.current != null) updateToast(toastIdRef.current, {
+			...toastData,
+			title: toastData.title ?? children
+		});
+	}, [
+		children,
+		toastData.title,
+		toastData.description,
+		toastData.theme,
+		toastData.icon,
+		toastData.isLoading,
+		toastData.id,
+		updateToast
+	]);
+	return null;
+}
+/**
+* Declarative Progress Toast component.
+*
+* @example
+* ```tsx
+* <Toast.Progress
+*   {...(isLoading
+*     ? { isLoading: true, title: 'Saving...' }
+*     : { isLoading: false, title: 'Saved!', theme: 'success' }
+*   )}
+* />
+* ```
+*/
+function ToastProgress(props) {
+	const { children, ...progressOptions } = props;
+	useProgressToast({
+		...progressOptions,
+		title: progressOptions.title ?? children
+	});
+	return null;
+}
+Toast.Progress = ToastProgress;
+
+//#endregion
+export { Toast };
+//# sourceMappingURL=index.js.map

package/dist/components/overlays/Toast/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/components/overlays/Toast/index.ts"],"sourcesContent":["// Declarative Toast component\nimport { Key, ReactNode, useEffect, useRef } from 'react';\n\nimport { useToastContext } from './ToastProvider';\nimport { ProgressToastOptions, ToastData } from './types';\nimport { useProgressToast } from './useProgressToast';\n\nexport { useToastContext } from './ToastProvider';\nexport { ToastItem } from './ToastItem';\nexport type { ToastItemProps } from './ToastItem';\nexport { useToast, getThemeIcon } from './useToast';\nexport { useProgressToast } from './useProgressToast';\nexport type {\n  ToastData,\n  ToastType,\n  ToastApi,\n  ProgressToastOptions,\n  ProgressToastEmpty,\n} from './types';\n\nexport interface ToastProps extends Omit<ToastData, 'duration'> {\n  /** Primary content */\n  children?: ReactNode;\n  /** Duration is ignored for declarative toasts - they stay visible while mounted */\n}\n\n/**\n * Declarative Toast component that shows a toast while mounted.\n *\n * @example\n * ```tsx\n * // Simple toast (visible while mounted)\n * <Toast theme=\"success\">Saved successfully</Toast>\n *\n * // With description\n * <Toast title=\"Success\" description=\"Changes saved\" theme=\"success\" />\n * ```\n */\nexport function Toast(props: ToastProps): null {\n  const { children, ...toastData } = props;\n  const { addToast, removeToast, updateToast } = useToastContext();\n  const toastIdRef = useRef<Key | null>(null);\n\n  useEffect(() => {\n    // Add toast on mount\n    // Icon is auto-resolved by ToastItem based on theme/isLoading\n    toastIdRef.current = addToast(\n      {\n        ...toastData,\n        title: toastData.title ?? children,\n        duration: null, // Persistent while mounted\n      },\n      true, // isProgress = true (persistent)\n    );\n\n    return () => {\n      // Remove toast on unmount\n      if (toastIdRef.current != null) {\n        removeToast(toastIdRef.current);\n        toastIdRef.current = null;\n      }\n    };\n  }, []);\n\n  // Update toast when props change\n  useEffect(() => {\n    if (toastIdRef.current != null) {\n      updateToast(toastIdRef.current, {\n        ...toastData,\n        title: toastData.title ?? children,\n      });\n    }\n  }, [\n    children,\n    toastData.title,\n    toastData.description,\n    toastData.theme,\n    toastData.icon,\n    toastData.isLoading,\n    toastData.id,\n    // Note: itemProps is intentionally excluded - it's an object that would cause\n    // unnecessary re-runs. Users needing dynamic itemProps should remount the component.\n    updateToast,\n  ]);\n\n  return null;\n}\n\nexport interface ToastProgressProps extends ProgressToastOptions {\n  /** Primary content (alternative to title) */\n  children?: ReactNode;\n}\n\n/**\n * Declarative Progress Toast component.\n *\n * @example\n * ```tsx\n * <Toast.Progress\n *   {...(isLoading\n *     ? { isLoading: true, title: 'Saving...' }\n *     : { isLoading: false, title: 'Saved!', theme: 'success' }\n *   )}\n * />\n * ```\n */\nfunction ToastProgress(props: ToastProgressProps): null {\n  const { children, ...progressOptions } = props;\n\n  useProgressToast({\n    ...progressOptions,\n    title: progressOptions.title ?? children,\n  });\n\n  return null;\n}\n\nToast.Progress = ToastProgress;\n\n// Type for compound component\nexport type ToastComponent = typeof Toast & {\n  Progress: typeof ToastProgress;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,MAAM,OAAyB;CAC7C,MAAM,EAAE,UAAU,GAAG,cAAc;CACnC,MAAM,EAAE,UAAU,aAAa,gBAAgB,iBAAiB;CAChE,MAAM,aAAa,OAAmB,KAAK;AAE3C,iBAAgB;AAGd,aAAW,UAAU,SACnB;GACE,GAAG;GACH,OAAO,UAAU,SAAS;GAC1B,UAAU;GACX,EACD,KACD;AAED,eAAa;AAEX,OAAI,WAAW,WAAW,MAAM;AAC9B,gBAAY,WAAW,QAAQ;AAC/B,eAAW,UAAU;;;IAGxB,EAAE,CAAC;AAGN,iBAAgB;AACd,MAAI,WAAW,WAAW,KACxB,aAAY,WAAW,SAAS;GAC9B,GAAG;GACH,OAAO,UAAU,SAAS;GAC3B,CAAC;IAEH;EACD;EACA,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EACV,UAAU;EAGV;EACD,CAAC;AAEF,QAAO;;;;;;;;;;;;;;;AAqBT,SAAS,cAAc,OAAiC;CACtD,MAAM,EAAE,UAAU,GAAG,oBAAoB;AAEzC,kBAAiB;EACf,GAAG;EACH,OAAO,gBAAgB,SAAS;EACjC,CAAC;AAEF,QAAO;;AAGT,MAAM,WAAW"}

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

@@ -0,0 +1,74 @@
+
+import { CubeItemProps } from "../../content/Item/Item.js";
+import { NotificationType } from "../Notifications/types.js";
+import { Key, ReactNode } from "react";
+
+//#region src/components/overlays/Toast/types.d.ts
+/** @deprecated Use `NotificationType` instead. Kept as alias for backward compatibility. */
+type ToastType = NotificationType;
+interface ToastData {
+  /** Unique identifier for deduplication (auto-generated if not provided) */
+  id?: Key;
+  /** Primary content (→ Item children) */
+  title?: ReactNode;
+  /** Secondary content (or primary if no title) */
+  description?: ReactNode;
+  /** Visual theme */
+  theme?: ToastType;
+  /** Icon to display */
+  icon?: ReactNode;
+  /** Whether the toast is in loading state (shows loading indicator) */
+  isLoading?: boolean;
+  /** Duration in ms before auto-dismiss. null = persistent */
+  duration?: number | null;
+  /** Additional Item props to pass through */
+  itemProps?: Partial<CubeItemProps>;
+}
+interface ProgressToastOptions extends Omit<ToastData, 'duration'> {
+  /** Whether the toast is in loading state */
+  isLoading: boolean;
+}
+/**
+ * Empty value that indicates no toast should be shown.
+ * When passed to useProgressToast, any existing toast is immediately removed.
+ */
+type ProgressToastEmpty = null | undefined | false | Record<string, never>;
+interface ToastApi {
+  /** Show a toast with default theme */
+  (data: ToastData | ReactNode): Key;
+  /** Show a success toast */
+  success: (data: ToastData | ReactNode) => Key;
+  /** Show a danger toast */
+  danger: (data: ToastData | ReactNode) => Key;
+  /** Show a warning toast */
+  warning: (data: ToastData | ReactNode) => Key;
+  /** Show a note toast */
+  note: (data: ToastData | ReactNode) => Key;
+  /** Remove a toast by id */
+  remove: (id: Key) => void;
+}
+interface InternalToast extends ToastData {
+  /** Internal unique identifier */
+  internalId: string;
+  /** Whether this is a progress toast (persistent) */
+  isProgress: boolean;
+  /** Deduplication key */
+  dedupeKey: string;
+  /** Timestamp when toast was created */
+  createdAt: number;
+  /** Whether the toast is exiting (used for exit transition) */
+  isExiting?: boolean;
+}
+interface ToastContextValue {
+  /** Add a toast */
+  addToast: (data: ToastData, isProgress?: boolean) => Key;
+  /** Remove a toast by id */
+  removeToast: (id: Key) => void;
+  /** Update a toast */
+  updateToast: (id: Key, data: Partial<ToastData>) => void;
+  /** Current toasts */
+  toasts: InternalToast[];
+}
+//#endregion
+export { ProgressToastEmpty, ProgressToastOptions, ToastApi, ToastContextValue, ToastData, ToastType };
+//# sourceMappingURL=types.d.ts.map

package/dist/components/overlays/Toast/useProgressToast.d.ts

@@ -0,0 +1,32 @@
+
+import { ProgressToastEmpty, ProgressToastOptions } from "./types.js";
+
+//#region src/components/overlays/Toast/useProgressToast.d.ts
+/**
+ * Hook to display a progress toast that persists while loading.
+ *
+ * @example
+ * ```tsx
+ * useProgressToast(
+ *   isLoading
+ *     ? { isLoading: true, title: 'Saving...', icon: <Spinner /> }
+ *     : { isLoading: false, title: 'Saved!', icon: <IconCheck />, theme: 'success' }
+ * );
+ *
+ * // Or with error handling:
+ * useProgressToast(
+ *   isLoading
+ *     ? { isLoading: true, title: 'Saving...', icon: <Spinner /> }
+ *     : isError
+ *       ? { isLoading: false, title: 'Error', description: errorMessage, theme: 'danger' }
+ *       : { isLoading: false, title: 'Saved!', theme: 'success' }
+ * );
+ *
+ * // Pass empty value to immediately remove any existing toast:
+ * useProgressToast(shouldShow ? { isLoading: true, title: 'Loading...' } : null);
+ * ```
+ */
+declare function useProgressToast(options: ProgressToastOptions | ProgressToastEmpty): void;
+//#endregion
+export { useProgressToast };
+//# sourceMappingURL=useProgressToast.d.ts.map