@cube-dev/ui-kit 0.113.1 → 0.114.0

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

@@ -0,0 +1,85 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.114.0
+ * Released under the MIT license.
+ */
+
+import { useRef, useState } from 'react';
+import { useEvent } from '../../../_internal/index.js';
+// ─── Hook ────────────────────────────────────────────────────────────
+export function usePersistentState(maxItems) {
+    const [persistentItems, setPersistentItems] = useState([]);
+    // Tracks IDs that have been moved to the persistent list at least once.
+    // Used to skip the overlay when the same id reappears.
+    const dismissedPersistentIdsRef = useRef(new Set());
+    // Tracks IDs that were explicitly removed from the persistent list by the
+    // user. These should be completely ignored on subsequent triggers.
+    const fullyDismissedIdsRef = useRef(new Set());
+    const addPersistentItem = useEvent((item) => {
+        // If the user already dismissed this item from the persistent list, don't re-add it.
+        if (fullyDismissedIdsRef.current.has(item.id))
+            return;
+        dismissedPersistentIdsRef.current.add(item.id);
+        setPersistentItems((prev) => {
+            // Upsert by id
+            const existingIndex = prev.findIndex((i) => i.id === item.id);
+            let newItems;
+            if (existingIndex !== -1) {
+                newItems = [...prev];
+                // Updated items are marked unread again
+                newItems[existingIndex] = {
+                    ...newItems[existingIndex],
+                    ...item,
+                    isRead: false,
+                };
+            }
+            else {
+                newItems = [{ ...item, isRead: item.isRead ?? false }, ...prev];
+            }
+            // Enforce max cap
+            if (newItems.length > maxItems) {
+                newItems = newItems.slice(0, maxItems);
+            }
+            // Sort newest first
+            newItems.sort((a, b) => b.createdAt - a.createdAt);
+            return newItems;
+        });
+    });
+    const removePersistentItem = useEvent((id) => {
+        fullyDismissedIdsRef.current.add(id);
+        setPersistentItems((prev) => prev.filter((i) => i.id !== id));
+    });
+    const removePersistentItemsByOwner = useEvent((ownerId) => {
+        setPersistentItems((prev) => prev.filter((i) => i.ownerId !== ownerId));
+    });
+    const clearPersistentItems = useEvent(() => {
+        setPersistentItems([]);
+    });
+    const markAllAsRead = useEvent(() => {
+        setPersistentItems((prev) => {
+            const hasUnread = prev.some((i) => !i.isRead);
+            if (!hasUnread)
+                return prev;
+            return prev.map((i) => (i.isRead ? i : { ...i, isRead: true }));
+        });
+    });
+    const hasDismissedPersistentId = useEvent((id) => {
+        return dismissedPersistentIdsRef.current.has(id);
+    });
+    const isFullyDismissedId = useEvent((id) => {
+        return fullyDismissedIdsRef.current.has(id);
+    });
+    return {
+        persistentItems,
+        addPersistentItem,
+        removePersistentItem,
+        removePersistentItemsByOwner,
+        clearPersistentItems,
+        markAllAsRead,
+        hasDismissedPersistentId,
+        isFullyDismissedId,
+    };
+}
+
+        

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

@@ -0,0 +1,143 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.114.0
+ * Released under the MIT license.
+ */
+
+import { useRef, useState } from 'react';
+import { useEvent } from '../../../_internal/index.js';
+// ─── Constants ───────────────────────────────────────────────────────
+const DEFAULT_TOAST_DURATION = 5000;
+const MAX_TOASTS = 3;
+// ─── Dedupe Key ──────────────────────────────────────────────────────
+/**
+ * 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 : '',
+    });
+}
+// ─── Helpers ─────────────────────────────────────────────────────────
+function matchesToastId(item, id) {
+    return item.id === id || item.internalId === String(id);
+}
+function findToast(list, id) {
+    return list.find((t) => matchesToastId(t, id));
+}
+// ─── Hook ────────────────────────────────────────────────────────────
+/**
+ * @param timersRef - Ref to the shared OverlayTimers instance. Accessed only
+ *   inside callbacks (never during render), so it is guaranteed to be populated.
+ */
+export function useToastState(timersRef) {
+    const [toasts, setToasts] = useState([]);
+    const toastsRef = useRef(toasts);
+    toastsRef.current = toasts;
+    const idCounter = useRef(0);
+    const removeToast = useEvent((id) => {
+        // Perform side effects outside the updater (StrictMode-safe).
+        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));
+    });
+    const 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(),
+        };
+        // Perform dedupe side effects outside the updater (StrictMode-safe).
+        const existingToast = toastsRef.current.find((t) => t.dedupeKey === dedupeKey && !t.isExiting);
+        if (existingToast) {
+            timersRef.current?.clearToastTimer(existingToast.internalId);
+        }
+        // Single setState call: mark duplicate as exiting, append new toast,
+        // and evict oldest temporal toasts if we exceed MAX_TOASTS.
+        // Track evicted IDs so we can clear timers outside the updater (StrictMode-safe).
+        let wasEvicted = false;
+        const evictedIds = [];
+        setToasts((prev) => {
+            let newToasts = prev;
+            // Mark existing toast with same dedupe key as exiting
+            if (existingToast) {
+                newToasts = newToasts.map((t) => t.internalId === existingToast.internalId
+                    ? { ...t, isExiting: true }
+                    : t);
+            }
+            // Append the new toast
+            newToasts = [...newToasts, newToast];
+            // Evict oldest temporal toasts if over the cap
+            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);
+                        // Check if the newly added toast was evicted
+                        if (oldestTemporal.internalId === internalId) {
+                            wasEvicted = true;
+                        }
+                    }
+                    else {
+                        break;
+                    }
+                }
+                else {
+                    break;
+                }
+            }
+            return newToasts;
+        });
+        // Clear timers for evicted toasts outside the updater (StrictMode-safe)
+        for (const evictedId of evictedIds) {
+            timersRef.current?.clearToastTimer(evictedId);
+        }
+        // Start timer only if the toast wasn't immediately evicted
+        if (!wasEvicted && duration != null && duration > 0) {
+            timersRef.current?.startToastTimer(internalId, data.id ?? internalId, duration);
+        }
+        return data.id ?? internalId;
+    });
+    const updateToast = useEvent((id, data) => {
+        setToasts((prev) => prev.map((t) => (matchesToastId(t, id) ? { ...t, ...data } : t)));
+    });
+    return {
+        toasts,
+        toastsRef,
+        addToast,
+        removeToast,
+        updateToast,
+        finalizeToastRemoval,
+    };
+}
+
+        

package/es/components/overlays/OverlayWrapper.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.113.1
+ * @cube-dev/ui-kit v0.114.0
  * Released under the MIT license.
  */
 

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

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.113.1
+ * @cube-dev/ui-kit v0.114.0
  * Released under the MIT license.
  */
 
@@ -9,8 +9,10 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from 'react';
 import { tasty } from '../../../tasty/index.js';
 import { Item } from '../../content/Item/Item.js';
+import { getThemeIcon } from './useToast.js';
 const StyledItem = tasty(Item, {
     styles: {
+        shadow: '$card-shadow',
         transition: 'theme, inset',
         pointerEvents: 'none',
         Description: {
@@ -19,11 +21,12 @@ const StyledItem = tasty(Item, {
     },
 });
 export const ToastItem = forwardRef(function ToastItem(props, ref) {
-    const { title, description, theme, isLoading, children, qa, ...itemProps } = props;
+    const { title, description, theme, isLoading, icon: providedIcon, children, qa, ...itemProps } = props;
+    const icon = getThemeIcon(theme, providedIcon, isLoading);
     // If only description provided (no title/children), use description as primary content
     const primaryContent = children ?? title ?? description;
     const secondaryContent = children || title ? description : undefined;
-    return (_jsx(StyledItem, { ref: ref, qa: qa ?? 'Toast', type: "card", theme: theme, isLoading: isLoading, description: secondaryContent, ...itemProps, children: primaryContent }));
+    return (_jsx(StyledItem, { ref: ref, qa: qa ?? 'Toast', type: "card", theme: theme, icon: icon, isLoading: isLoading, description: secondaryContent, ...itemProps, children: primaryContent }));
 });
 
         

package/es/components/overlays/Toast/ToastProvider.js

@@ -1,360 +1,14 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.113.1
+ * @cube-dev/ui-kit v0.114.0
  * Released under the MIT license.
  */
 
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
-import { useEvent } from '../../../_internal/index.js';
-import { tasty } from '../../../tasty/index.js';
-import { DisplayTransition } from '../../helpers/DisplayTransition/DisplayTransition.js';
-import { Portal } from '../../portal/index.js';
-import { ToastItem } from './ToastItem.js';
-const DEFAULT_DURATION = 5000;
-const MAX_TOASTS = 3;
-const COLLAPSE_VISIBLE_HEIGHT = 10;
-const CONTAINER_OFFSET = 16; // Container's top offset from viewport (2x)
-// Generate deduplication key from toast data
-function generateDedupeKey(data) {
-    const id = data.id;
-    if (id != null) {
-        return String(id);
-    }
-    // Hash based on title + description + theme
-    const parts = [
-        typeof data.title === 'string' ? data.title : '',
-        typeof data.description === 'string' ? data.description : '',
-        data.theme ?? 'default',
-    ];
-    return parts.join('|');
-}
-const ToastContext = createContext(null);
-export function useToastContext() {
-    const context = useContext(ToastContext);
-    if (!context) {
-        throw new Error('useToastContext must be used within a ToastProvider');
-    }
-    return context;
-}
-const TOAST_GAP = 8; // Gap between toasts in pixels
-const ToastContainerElement = tasty({
-    styles: {
-        position: 'fixed',
-        top: '2x',
-        left: '50%',
-        transform: 'translateX(-50%)',
-        zIndex: 10000,
-        padding: '1x',
-        height: '0',
-        pointerEvents: 'none',
-    },
-});
-const ToastWrapper = tasty({
-    styles: {
-        position: 'absolute',
-        top: '0',
-        left: '50%',
-        transform: 'translateX(-50%)',
-        width: 'max-content 50x',
-        pointerEvents: 'auto',
-        transition: 'top 0.3s, opacity 0.3s',
-        opacity: {
-            '': 0,
-            isShown: 1,
-        },
-    },
-});
-// Default height used for initial positioning before measurement
-const DEFAULT_TOAST_HEIGHT = 56;
-function ToastContainer({ toasts, onExitComplete }) {
-    const [isCollapsed, setIsCollapsed] = useState(false);
-    const [heights, setHeights] = useState({});
-    const containerRef = useRef(null);
-    const boundsRef = useRef(null);
-    const toastRefs = useRef(new Map());
-    // Track last known positions for exiting toasts to prevent animation to top: 0
-    const lastPositionsRef = useRef(new Map());
-    // Calculate bounds from all toast elements
-    const updateBounds = useCallback(() => {
-        const refs = toastRefs.current;
-        if (refs.size === 0) {
-            boundsRef.current = null;
-            return;
-        }
-        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-        refs.forEach((el) => {
-            const rect = el.getBoundingClientRect();
-            minX = Math.min(minX, rect.left);
-            minY = Math.min(minY, rect.top);
-            maxX = Math.max(maxX, rect.right);
-            maxY = Math.max(maxY, rect.bottom);
-        });
-        // Use DOMRect if available (browser), otherwise create a plain object (test environment)
-        if (typeof DOMRect !== 'undefined') {
-            boundsRef.current = new DOMRect(minX, minY, maxX - minX, maxY - minY);
-        }
-        else {
-            boundsRef.current = {
-                x: minX,
-                y: minY,
-                width: maxX - minX,
-                height: maxY - minY,
-                top: minY,
-                right: maxX,
-                bottom: maxY,
-                left: minX,
-                toJSON: () => ({}),
-            };
-        }
-    }, []);
-    // Track mouse position to detect when it leaves toast area
-    useEffect(() => {
-        if (!isCollapsed)
-            return;
-        const handleMouseMove = (e) => {
-            const bounds = boundsRef.current;
-            if (!bounds) {
-                setIsCollapsed(false);
-                return;
-            }
-            // Add some padding to the bounds for smoother UX
-            const padding = 20;
-            const isInBounds = e.clientX >= bounds.left - padding &&
-                e.clientX <= bounds.right + padding &&
-                e.clientY >= bounds.top - padding &&
-                e.clientY <= bounds.bottom + padding;
-            if (!isInBounds) {
-                setIsCollapsed(false);
-            }
-        };
-        window.addEventListener('mousemove', handleMouseMove);
-        return () => window.removeEventListener('mousemove', handleMouseMove);
-    }, [isCollapsed]);
-    // Update bounds when toasts change
-    useEffect(() => {
-        updateBounds();
-    }, [toasts, updateBounds]);
-    const handleMouseEnter = useCallback(() => {
-        updateBounds();
-        setIsCollapsed(true);
-    }, [updateBounds]);
-    // Measure heights after render using useEffect
-    useEffect(() => {
-        const newHeights = {};
-        let hasChanges = false;
-        toastRefs.current.forEach((el, id) => {
-            const height = el.offsetHeight || DEFAULT_TOAST_HEIGHT;
-            newHeights[id] = height;
-            if (heights[id] !== height) {
-                hasChanges = true;
-            }
-        });
-        // Also check for removed toasts
-        for (const id of Object.keys(heights)) {
-            if (!toastRefs.current.has(id)) {
-                hasChanges = true;
-            }
-        }
-        if (hasChanges) {
-            setHeights(newHeights);
-        }
-    });
-    // Create ref callback that stores refs without triggering updates
-    const createRefCallback = useCallback((internalId, displayRef) => (el) => {
-        displayRef(el);
-        if (el) {
-            toastRefs.current.set(internalId, el);
-        }
-        else {
-            toastRefs.current.delete(internalId);
-        }
-    }, []);
-    // Calculate top positions for visible (non-exiting) toasts
-    const visibleToasts = toasts.filter((t) => !t.isExiting);
-    const positions = useMemo(() => {
-        const posMap = new Map();
-        let currentTop = 0;
-        for (const toast of visibleToasts) {
-            posMap.set(toast.internalId, currentTop);
-            const height = heights[toast.internalId] ?? DEFAULT_TOAST_HEIGHT;
-            currentTop += height + TOAST_GAP;
-        }
-        return posMap;
-    }, [visibleToasts, heights]);
-    // Update lastPositionsRef with current positions for visible toasts
-    // This preserves positions for toasts that will exit later
-    useEffect(() => {
-        positions.forEach((pos, id) => {
-            lastPositionsRef.current.set(id, pos);
-        });
-    }, [positions]);
-    // Clean up lastPositionsRef when toast exit completes
-    const handleExitComplete = useCallback((internalId) => {
-        lastPositionsRef.current.delete(internalId);
-        onExitComplete(internalId);
-    }, [onExitComplete]);
-    // Calculate collapsed positions
-    const getToastStyle = useCallback((toast, index, total) => {
-        // Use current position for visible toasts, or last known position for exiting toasts
-        const baseTop = positions.get(toast.internalId) ??
-            lastPositionsRef.current.get(toast.internalId) ??
-            0;
-        const height = heights[toast.internalId] ?? DEFAULT_TOAST_HEIGHT;
-        if (!isCollapsed) {
-            return { top: `${baseTop}px` };
-        }
-        // In collapsed state, all toasts overlap completely
-        // Only COLLAPSE_VISIBLE_HEIGHT of the toast should be visible from viewport top
-        // Container is at CONTAINER_OFFSET from viewport, so we compensate for that
-        const isNewest = index === total - 1;
-        const collapsedTop = COLLAPSE_VISIBLE_HEIGHT - CONTAINER_OFFSET - height;
-        return {
-            top: `${collapsedTop}px`,
-            zIndex: index, // Newest on top (highest index = highest z)
-            opacity: isNewest ? 1 : 0,
-            pointerEvents: 'none',
-        };
-    }, [isCollapsed, positions, heights]);
-    if (toasts.length === 0)
-        return null;
-    return (_jsx(Portal, { children: _jsx(ToastContainerElement, { ref: containerRef, children: toasts.map((toast) => {
-                const visibleIndex = visibleToasts.findIndex((t) => t.internalId === toast.internalId);
-                return (_jsx(DisplayTransition, { animateOnMount: true, isShown: !toast.isExiting, onRest: (transition) => {
-                        if (transition === 'exit') {
-                            handleExitComplete(toast.internalId);
-                        }
-                    }, children: ({ isShown, ref }) => (_jsx(ToastWrapper, { ref: createRefCallback(toast.internalId, ref), mods: { isShown }, style: getToastStyle(toast, visibleIndex >= 0 ? visibleIndex : 0, visibleToasts.length), onMouseEnter: handleMouseEnter, children: _jsx(ToastItem, { ...toast.itemProps, title: toast.title, description: toast.description, theme: toast.theme, icon: toast.icon, isLoading: toast.isLoading }) })) }, toast.internalId));
-            }) }) }));
-}
-export function ToastProvider({ children }) {
-    const [toasts, setToasts] = useState([]);
-    const timersRef = useRef(new Map());
-    const idCounter = useRef(0);
-    const generateId = useCallback(() => {
-        idCounter.current += 1;
-        return `toast-${idCounter.current}-${Date.now()}`;
-    }, []);
-    const clearTimer = useCallback((internalId) => {
-        const timer = timersRef.current.get(internalId);
-        if (timer) {
-            clearTimeout(timer);
-            timersRef.current.delete(internalId);
-        }
-    }, []);
-    // Mark toast as exiting (triggers exit transition)
-    const removeToast = useEvent((id) => {
-        setToasts((prev) => {
-            const toast = prev.find((t) => t.id === id || t.internalId === String(id));
-            if (toast) {
-                clearTimer(toast.internalId);
-            }
-            // Mark as exiting instead of removing immediately
-            return prev.map((t) => {
-                if (t.id === id || t.internalId === String(id)) {
-                    return { ...t, isExiting: true };
-                }
-                return t;
-            });
-        });
-    });
-    // Actually remove the toast from the array after exit transition completes
-    const finalizeRemoval = useEvent((internalId) => {
-        setToasts((prev) => prev.filter((t) => t.internalId !== internalId));
-    });
-    const addToast = useEvent((data, isProgress = false) => {
-        const internalId = generateId();
-        const dedupeKey = generateDedupeKey(data);
-        const duration = isProgress ? null : data.duration ?? DEFAULT_DURATION;
-        // Mark existing toast with same dedupe key as exiting
-        setToasts((prev) => {
-            const existingIndex = prev.findIndex((t) => t.dedupeKey === dedupeKey && !t.isExiting);
-            if (existingIndex !== -1) {
-                const existing = prev[existingIndex];
-                clearTimer(existing.internalId);
-                // Mark as exiting instead of removing immediately
-                return prev.map((t, i) => {
-                    if (i === existingIndex) {
-                        return { ...t, isExiting: true };
-                    }
-                    return t;
-                });
-            }
-            return prev;
-        });
-        const newToast = {
-            ...data,
-            internalId,
-            isProgress,
-            dedupeKey,
-            createdAt: Date.now(),
-        };
-        setToasts((prev) => {
-            let newToasts = [...prev, newToast];
-            // Enforce max toasts limit (only count non-exiting toasts)
-            const activeToasts = newToasts.filter((t) => !t.isExiting);
-            const progressToasts = activeToasts.filter((t) => t.isProgress);
-            const temporalToasts = activeToasts.filter((t) => !t.isProgress);
-            // If we exceed limit, mark oldest temporal toasts as exiting
-            while (activeToasts.length > MAX_TOASTS) {
-                // Always allow at least 1 temporal toast even with 3 progress toasts
-                if (temporalToasts.length > 1 || progressToasts.length < MAX_TOASTS) {
-                    const oldestTemporal = temporalToasts.shift();
-                    if (oldestTemporal) {
-                        clearTimer(oldestTemporal.internalId);
-                        newToasts = newToasts.map((t) => {
-                            if (t.internalId === oldestTemporal.internalId) {
-                                return { ...t, isExiting: true };
-                            }
-                            return t;
-                        });
-                        // Update activeToasts count
-                        const idx = activeToasts.findIndex((t) => t.internalId === oldestTemporal.internalId);
-                        if (idx !== -1)
-                            activeToasts.splice(idx, 1);
-                    }
-                    else {
-                        break;
-                    }
-                }
-                else {
-                    break;
-                }
-            }
-            return newToasts;
-        });
-        // Set auto-dismiss timer for non-progress toasts
-        if (duration != null && duration > 0) {
-            const timer = setTimeout(() => {
-                removeToast(data.id ?? internalId);
-            }, duration);
-            timersRef.current.set(internalId, timer);
-        }
-        return data.id ?? internalId;
-    });
-    const updateToast = useEvent((id, data) => {
-        setToasts((prev) => prev.map((t) => {
-            if (t.id === id || t.internalId === String(id)) {
-                return { ...t, ...data };
-            }
-            return t;
-        }));
-    });
-    // Cleanup timers on unmount
-    useEffect(() => {
-        return () => {
-            timersRef.current.forEach((timer) => clearTimeout(timer));
-            timersRef.current.clear();
-        };
-    }, []);
-    const contextValue = useMemo(() => ({
-        addToast,
-        removeToast,
-        updateToast,
-        toasts,
-    }), [addToast, removeToast, updateToast, toasts]);
-    return (_jsxs(ToastContext.Provider, { value: contextValue, children: [children, _jsx(ToastContainer, { toasts: toasts, onExitComplete: finalizeRemoval })] }));
-}
+/**
+ * Toast context is now provided by OverlayProvider.
+ * This module re-exports useToastContext for backward compatibility.
+ */
+export { useToastContext } from '../Notifications/NotificationContext.js';
 
         

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

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.113.1
+ * @cube-dev/ui-kit v0.114.0
  * Released under the MIT license.
  */
 
@@ -9,8 +9,7 @@
 import { useEffect, useRef } from 'react';
 import { useToastContext } from './ToastProvider.js';
 import { useProgressToast } from './useProgressToast.js';
-import { getThemeIcon } from './useToast.js';
-export { ToastProvider, useToastContext } from './ToastProvider.js';
+export { useToastContext } from './ToastProvider.js';
 export { ToastItem } from './ToastItem.js';
 export { useToast, getThemeIcon } from './useToast.js';
 export { useProgressToast } from './useProgressToast.js';
@@ -30,14 +29,12 @@ export function Toast(props) {
     const { children, ...toastData } = props;
     const { addToast, removeToast, updateToast } = useToastContext();
     const toastIdRef = useRef(null);
-    // Apply theme-based icon if not loading and no icon provided
-    const icon = getThemeIcon(toastData.theme, toastData.icon, toastData.isLoading);
     useEffect(() => {
         // Add toast on mount
+        // Icon is auto-resolved by ToastItem based on theme/isLoading
         toastIdRef.current = addToast({
             ...toastData,
             title: toastData.title ?? children,
-            icon,
             duration: null, // Persistent while mounted
         }, true);
         return () => {
@@ -54,7 +51,6 @@ export function Toast(props) {
             updateToast(toastIdRef.current, {
                 ...toastData,
                 title: toastData.title ?? children,
-                icon,
             });
         }
     }, [
@@ -65,7 +61,6 @@ export function Toast(props) {
         toastData.icon,
         toastData.isLoading,
         toastData.id,
-        icon,
         // Note: itemProps is intentionally excluded - it's an object that would cause
         // unnecessary re-runs. Users needing dynamic itemProps should remount the component.
         updateToast,