@topconsultnpm/sdkui-react 6.20.0-dev1.99 → 6.20.0-dev2.1

package/lib/components/NewComponents/FloatingMenuBar/TMFloatingMenuBar.js

@@ -1,14 +1,13 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useRef, useEffect, useCallback } from 'react';
 import { ContextMenu } from '../ContextMenu';
 import ShowAlert from '../../base/TMAlert';
 import TMTooltip from '../../base/TMTooltip';
 import * as S from './styles';
-import { IconAdd, IconCloseOutline, IconMenuVertical, IconPin, IconSave, IconSeparator, IconUndo, SDKUI_Globals, SDKUI_Localizator } from '../../../helper';
-import { ButtonNames, TMMessageBoxManager } from '../../base/TMPopUp';
+import { IconDelete, IconMenuVertical, IconPin, IconRotate, IconSeparator, SDKUI_Globals } from '../../../helper';
 const Separator = (props) => (_jsx("svg", { viewBox: "0 0 24 24", fill: "currentColor", height: "1em", width: "1em", ...props, children: _jsx("path", { d: "M12 2v20", stroke: "currentColor", strokeWidth: "3", strokeLinecap: "round" }) }));
 const IconDraggableDots = (props) => (_jsx("svg", { fontSize: 18, viewBox: "0 0 24 24", fill: "currentColor", height: "1em", width: "1em", ...props, children: _jsx("path", { d: "M9 3a2 2 0 11-4 0 2 2 0 014 0zm0 9a2 2 0 11-4 0 2 2 0 014 0zm0 9a2 2 0 11-4 0 2 2 0 014 0zm10-18a2 2 0 11-4 0 2 2 0 014 0zm0 9a2 2 0 11-4 0 2 2 0 014 0zm0 9a2 2 0 11-4 0 2 2 0 014 0z" }) }));
-const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained = false, defaultPosition = { x: 1, y: 90 }, defaultOrientation = 'horizontal', maxItems = 100, contextMenuDefaultPinnedIds = [], defaultItems = [], disbaleConfigMode = false, bgColor = undefined, }) => {
+const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained = false, defaultPosition = { x: 1, y: 90 }, defaultOrientation = 'horizontal', maxItems = 100, defaultPinnedItems = [], fixedItems = [], enableConfigMode = true, bgColor = undefined, hasContextMenu = true, pinnedItemIds: externalPinnedItemIds, onPinChange, }) => {
     const percentToPixels = (percent, containerSize) => {
         return (percent / 100) * containerSize;
     };
@@ -29,7 +28,7 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
     };
     const getDefaultConfig = () => ({
         orientation: defaultOrientation,
-        savedItemIds: contextMenuDefaultPinnedIds,
+        savedItemIds: defaultPinnedItems,
         position: defaultPosition,
     });
     const resetFloatingBarSettings = () => {
@@ -42,17 +41,17 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
     };
     const loadConfig = () => {
         // If config mode is disabled, use default position and orientation
-        if (disbaleConfigMode) {
+        if (!enableConfigMode) {
             return {
                 orientation: defaultOrientation,
-                savedItemIds: contextMenuDefaultPinnedIds,
+                savedItemIds: defaultPinnedItems,
                 position: defaultPosition,
             };
         }
         try {
             const settings = SDKUI_Globals.userSettings.searchSettings.floatingMenuBar;
-            // If localStorage is empty (first time), use props as defaults
-            if (!settings || !settings.position || !settings.itemIds) {
+            // If localStorage is empty (first time) or itemIds is empty array, use props as defaults
+            if (!settings || !settings.position || !settings.itemIds || settings.itemIds.length === 0) {
                 return getDefaultConfig();
             }
             // Validate position
@@ -129,8 +128,8 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
     const [state, setState] = useState({
         position: initialConfig.position, // Stored as percentage
         isDragging: false,
-        isConfigMode: false,
         orientation: initialConfig.orientation,
+        verticalDirection: 'down',
         items: [],
         draggedItemIndex: null,
     });
@@ -138,10 +137,15 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
     const dragOffset = useRef({ x: 0, y: 0 });
     const [dragOverIndex, setDragOverIndex] = useState(null);
     const [pixelPosition, setPixelPosition] = useState({ x: 0, y: 0 }); // Calculated pixel position
+    const [isOrientationChanging, setIsOrientationChanging] = useState(false); // Hide bar during orientation transition
     const containerSizeRef = useRef({ width: 0, height: 0 });
-    const stateSnapshot = useRef(null);
+    const positionBeforeOrientationChange = useRef(null);
     const floatingBarItemIds = useRef(new Set());
     const floatingBarItemNames = useRef(new Set());
+    const isSyncingFromExternal = useRef(false);
+    const isLocalChange = useRef(false);
+    const dragStartPosition = useRef(null);
+    const isItemsInitialized = useRef(false);
     useEffect(() => {
         floatingBarItemIds.current = new Set(state.items.map(i => i.id));
         floatingBarItemNames.current = new Set(state.items.map(i => i.name));
@@ -201,49 +205,93 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
         });
         return result;
     }, [state.items]);
-    // Restore items on mount from savedItemIds
+    // Restore items on mount (and when contextMenuItems become available) from savedItemIds
     useEffect(() => {
-        if (contextMenuItems.length > 0 || initialConfig.savedItemIds.length > 0 || defaultItems.length > 0) {
-            const flatItems = flattenMenuItems(contextMenuItems);
-            let itemsToSet = [];
-            // If disbaleConfigMode is true and defaultItems provided, use only defaultItems
-            if (disbaleConfigMode && defaultItems.length > 0) {
-                itemsToSet = defaultItems;
+        // For enableConfigMode=false: always sync with fixedItems
+        if (!enableConfigMode) {
+            if (fixedItems.length > 0) {
+                setState(s => ({ ...s, items: fixedItems }));
             }
-            else if (!disbaleConfigMode && initialConfig.savedItemIds.length > 0) {
-                // Restore items in the saved order from localStorage (only if config mode is enabled)
-                const restoredItems = initialConfig.savedItemIds
-                    .map((id) => {
-                    if (id.startsWith('separator-')) {
-                        return {
-                            id,
-                            name: 'Separator',
-                            icon: _jsx(Separator, {}),
-                            onClick: () => { },
-                            isSeparator: true,
-                        };
-                    }
-                    return flatItems.find(item => item.id === id);
-                })
-                    .filter((item) => item !== undefined);
-                itemsToSet = restoredItems;
-            }
-            else if (contextMenuDefaultPinnedIds.length > 0) {
-                // First time: Use contextMenuDefaultPinnedIds from props to find items by ID
-                const defaultPinnedItems = contextMenuDefaultPinnedIds
-                    .map((id) => flatItems.find(item => item.id === id))
-                    .filter((item) => item !== undefined);
-                itemsToSet = defaultPinnedItems;
-            }
-            else if (defaultItems.length > 0) {
-                // Use defaultItems as fallback
-                itemsToSet = defaultItems;
-            }
-            if (itemsToSet.length > 0) {
-                setState(s => ({ ...s, items: itemsToSet }));
+            return;
+        }
+        // For enableConfigMode=true: only initialize once
+        if (isItemsInitialized.current)
+            return;
+        // Wait until contextMenuItems is populated
+        if (contextMenuItems.length === 0)
+            return;
+        const flatItems = flattenMenuItems(contextMenuItems);
+        if (flatItems.length === 0)
+            return;
+        let itemsToSet = [];
+        if (initialConfig.savedItemIds.length > 0) {
+            // Restore items in the saved order from localStorage
+            const restoredItems = initialConfig.savedItemIds
+                .map((id) => {
+                if (id.startsWith('separator-')) {
+                    return {
+                        id,
+                        name: 'Separator',
+                        icon: _jsx(Separator, {}),
+                        onClick: () => { },
+                        isSeparator: true,
+                    };
+                }
+                return flatItems.find(item => item.id === id);
+            })
+                .filter((item) => item !== undefined);
+            itemsToSet = restoredItems;
+        }
+        // If still empty, try defaultPinnedItems
+        if (itemsToSet.length === 0 && defaultPinnedItems.length > 0) {
+            const resolvedDefaultItems = defaultPinnedItems
+                .map((id) => flatItems.find(item => item.id === id))
+                .filter((item) => item !== undefined);
+            itemsToSet = resolvedDefaultItems;
+        }
+        if (itemsToSet.length > 0) {
+            isItemsInitialized.current = true;
+            setState(s => ({ ...s, items: itemsToSet }));
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [contextMenuItems, fixedItems, enableConfigMode]);
+    // Sync with external pinnedItemIds when they change (from parent component)
+    useEffect(() => {
+        // Skip sync if a local change was just made (e.g. right-click remove/add separator)
+        if (isLocalChange.current) {
+            isLocalChange.current = false;
+            return;
+        }
+        if (externalPinnedItemIds === undefined || !enableConfigMode)
+            return;
+        // Skip sync if external is empty but we have initialized items (first login case)
+        // The parent hook starts with [] but we've initialized with defaults
+        if (externalPinnedItemIds.length === 0 && state.items.length > 0)
+            return;
+        const flatItems = flattenMenuItems(contextMenuItems);
+        // Build items from external pinned IDs
+        const itemsFromExternal = externalPinnedItemIds
+            .map((id) => {
+            if (id.startsWith('separator-')) {
+                return {
+                    id,
+                    name: 'Separator',
+                    icon: _jsx(Separator, {}),
+                    onClick: () => { },
+                    isSeparator: true,
+                };
             }
+            return flatItems.find(item => item.id === id);
+        })
+            .filter((item) => item !== undefined);
+        // Only update if different
+        const currentIds = state.items.map(i => i.id).join(',');
+        const newIds = itemsFromExternal.map(i => i.id).join(',');
+        if (currentIds !== newIds) {
+            isSyncingFromExternal.current = true; // Mark that we're syncing from external
+            setState(s => ({ ...s, items: itemsFromExternal }));
         }
-    }, disbaleConfigMode ? [defaultItems] : []); // Update when defaultItems change if config mode is disabled
+    }, [externalPinnedItemIds, contextMenuItems, enableConfigMode, flattenMenuItems]);
     const togglePin = useCallback((item) => {
         setState(s => {
             const isInFloatingBar = s.items.some(i => i.id === item.id);
@@ -323,40 +371,6 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
         const separator = createSeparator();
         setState(s => ({ ...s, items: [...s.items, separator] }));
     }, [state.items.length, maxItems, createSeparator]);
-    const getPinContextMenuItems = useCallback(() => {
-        const flatItems = flattenMenuItems(contextMenuItems);
-        const currentItemIds = new Set(state.items.map(i => i.id));
-        const createPinItems = (items) => {
-            return items.map(item => {
-                const flatItem = flatItems.find(fi => fi.id === item.id);
-                const itemId = flatItem?.id || item.id || '';
-                const isAlreadyPinned = currentItemIds.has(itemId);
-                const pinItem = {
-                    ...item,
-                    onClick: item.onClick && !item.submenu ? () => {
-                        if (flatItem && !isAlreadyPinned) {
-                            togglePin(flatItem);
-                        }
-                    } : undefined,
-                    disabled: isAlreadyPinned,
-                };
-                if (item.submenu) {
-                    pinItem.submenu = createPinItems(item.submenu);
-                }
-                return pinItem;
-            });
-        };
-        const pinItems = createPinItems(contextMenuItems);
-        // Add separator option at the end
-        pinItems.push({
-            id: 'add-separator',
-            name: SDKUI_Localizator.Add + ' separatore',
-            icon: _jsx(IconSeparator, {}),
-            onClick: addSeparator,
-            beginGroup: true
-        });
-        return pinItems;
-    }, [contextMenuItems, flattenMenuItems, togglePin, state.items, addSeparator]);
     const getContextMenuItemsWithPinIcons = useCallback(() => {
         const flatItems = flattenMenuItems(contextMenuItems);
         const currentItemIds = new Set(state.items.map(i => i.id));
@@ -367,9 +381,12 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
                 const isPinned = currentItemIds.has(itemId);
                 const itemWithPin = {
                     ...item,
-                    rightIcon: flatItem ? _jsx(IconPin, { color: isPinned ? 'red' : 'black' }) : undefined,
-                    onRightIconClick: flatItem ? () => {
-                        togglePin(flatItem);
+                    rightIconProps: flatItem ? {
+                        icon: _jsx(IconPin, {}),
+                        activeColor: 'red',
+                        inactiveColor: 'black',
+                        isActive: isPinned,
+                        onClick: () => togglePin(flatItem),
                     } : undefined,
                 };
                 if (item.submenu) {
@@ -381,8 +398,6 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
         return addPinIcons(contextMenuItems);
     }, [contextMenuItems, flattenMenuItems, togglePin, state.items]);
     const handleMouseDown = (e) => {
-        if (state.isConfigMode)
-            return;
         const containerRect = containerRef.current?.getBoundingClientRect();
         if (containerRect) {
             // Calculate drag offset based on positioning mode
@@ -401,11 +416,11 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
                 };
             }
         }
+        // Save starting position to detect if user actually moved the bar
+        dragStartPosition.current = { ...pixelPosition };
         setState(s => ({ ...s, isDragging: true }));
     };
     const handleGripDoubleClick = () => {
-        if (state.isConfigMode)
-            return;
         toggleOrientation();
     };
     const handleMouseMove = useCallback((e) => {
@@ -440,6 +455,15 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
                 x: pixelsToPercent(pixelPosition.x, containerSizeRef.current.width),
                 y: pixelsToPercent(pixelPosition.y, containerSizeRef.current.height),
             };
+            // Only clear saved position if user actually moved the bar significantly (more than 5 pixels)
+            if (dragStartPosition.current) {
+                const dx = Math.abs(pixelPosition.x - dragStartPosition.current.x);
+                const dy = Math.abs(pixelPosition.y - dragStartPosition.current.y);
+                if (dx > 5 || dy > 5) {
+                    positionBeforeOrientationChange.current = null;
+                }
+            }
+            dragStartPosition.current = null;
             setState(s => ({
                 ...s,
                 isDragging: false,
@@ -452,8 +476,6 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
     }, [state.isDragging, pixelPosition]);
     // Touch event handlers for tablet support
     const handleTouchStart = (e) => {
-        if (state.isConfigMode)
-            return;
         const touch = e.touches[0];
         const containerRect = containerRef.current?.getBoundingClientRect();
         if (containerRect) {
@@ -470,6 +492,8 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
                 };
             }
         }
+        // Save starting position to detect if user actually moved the bar
+        dragStartPosition.current = { ...pixelPosition };
         setState(s => ({ ...s, isDragging: true }));
     };
     const handleTouchMove = useCallback((e) => {
@@ -499,6 +523,15 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
                 x: pixelsToPercent(pixelPosition.x, containerSizeRef.current.width),
                 y: pixelsToPercent(pixelPosition.y, containerSizeRef.current.height),
             };
+            // Only clear saved position if user actually moved the bar significantly (more than 5 pixels)
+            if (dragStartPosition.current) {
+                const dx = Math.abs(pixelPosition.x - dragStartPosition.current.x);
+                const dy = Math.abs(pixelPosition.y - dragStartPosition.current.y);
+                if (dx > 5 || dy > 5) {
+                    positionBeforeOrientationChange.current = null;
+                }
+            }
+            dragStartPosition.current = null;
             setState(s => ({
                 ...s,
                 isDragging: false,
@@ -524,17 +557,16 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
         }
         return undefined;
     }, [state.isDragging, handleMouseMove, handleMouseUp, handleTouchMove, handleTouchEnd]);
-    // Save to SDKUI_Globals.userSettings only when NOT in config mode (when applying changes)
+    // Save to SDKUI_Globals.userSettings
     useEffect(() => {
-        if (state.isConfigMode)
-            return; // Don't save during edit mode
-        if (disbaleConfigMode)
+        if (!enableConfigMode)
             return; // Don't save if config mode is disabled
+        const pinnedIds = state.items.map(item => item.id);
         try {
             // Replace the entire object to trigger the Proxy
             SDKUI_Globals.userSettings.searchSettings.floatingMenuBar = {
                 orientation: state.orientation,
-                itemIds: state.items.map(item => item.id),
+                itemIds: pinnedIds,
                 position: state.position,
                 positionFormat: 'percentage',
             };
@@ -542,154 +574,100 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
         catch (error) {
             console.error('Failed to save FloatingMenuBar config:', error);
         }
-    }, [state.orientation, state.items, state.position, state.isConfigMode, disbaleConfigMode]);
-    const toggleConfigMode = () => {
-        setState(s => {
-            if (!s.isConfigMode) {
-                stateSnapshot.current = {
-                    items: [...s.items],
-                    orientation: s.orientation,
-                    position: { ...s.position },
-                };
-                return { ...s, isConfigMode: true };
-            }
-            else {
-                // Exiting edit mode (applying changes) - clean up trailing separators and clear snapshot
-                stateSnapshot.current = null;
-                const cleanedItems = removeTrailingSeparators(s.items);
-                return { ...s, isConfigMode: false, items: cleanedItems };
-            }
-        });
-    };
-    // Auto-reposition when entering edit mode to ensure Apply/Undo buttons are visible
-    useEffect(() => {
-        if (!state.isConfigMode || !floatingRef.current)
-            return;
-        // Use double requestAnimationFrame to ensure the DOM has fully updated with new buttons
-        requestAnimationFrame(() => {
-            requestAnimationFrame(() => {
-                if (!floatingRef.current)
-                    return;
-                const floating = floatingRef.current.getBoundingClientRect();
-                const containerWidth = isConstrained && containerRef.current
-                    ? containerRef.current.getBoundingClientRect().width
-                    : window.innerWidth;
-                const containerHeight = isConstrained && containerRef.current
-                    ? containerRef.current.getBoundingClientRect().height
-                    : window.innerHeight;
-                // Use current pixel position
-                let newPixelX = pixelPosition.x;
-                let newPixelY = pixelPosition.y;
-                let needsUpdate = false;
-                // Check horizontal overflow
-                if (newPixelX + floating.width > containerWidth) {
-                    newPixelX = Math.max(0, containerWidth - floating.width);
-                    needsUpdate = true;
-                }
-                // Check vertical overflow
-                if (newPixelY + floating.height > containerHeight) {
-                    newPixelY = Math.max(0, containerHeight - floating.height);
-                    needsUpdate = true;
-                }
-                if (needsUpdate) {
-                    // Update pixel position immediately
-                    setPixelPosition({ x: newPixelX, y: newPixelY });
-                    // Convert to percentage for state
-                    const newPercentagePosition = {
-                        x: pixelsToPercent(newPixelX, containerWidth),
-                        y: pixelsToPercent(newPixelY, containerHeight),
-                    };
-                    setState(s => ({
-                        ...s,
-                        position: newPercentagePosition,
-                    }));
-                    // Update snapshot position to the corrected position so Undo restores to visible position
-                    if (stateSnapshot.current) {
-                        stateSnapshot.current.position = newPercentagePosition;
-                    }
-                }
-            });
-        });
-    }, [state.isConfigMode, state.orientation, isConstrained, state.items, pixelPosition.x, pixelPosition.y]);
-    const handleUndo = () => {
-        if (stateSnapshot.current) {
-            setState(s => ({
-                ...s,
-                items: [...stateSnapshot.current.items],
-                orientation: stateSnapshot.current.orientation,
-                position: { ...stateSnapshot.current.position },
-                isConfigMode: true,
-            }));
-        }
-    };
-    // Check if current state has changed from snapshot
-    const hasChanges = () => {
-        if (!stateSnapshot.current)
-            return false;
-        // Check if items have changed (different IDs or different order)
-        const currentIds = state.items.map(i => i.id).join(',');
-        const snapshotIds = stateSnapshot.current.items.map(i => i.id).join(',');
-        return currentIds !== snapshotIds;
-    };
-    const handleClose = () => {
-        // If all items removed, exit without asking and restore last items
-        if (state.items.length === 0 && stateSnapshot.current) {
-            setState(s => ({
-                ...s,
-                items: [...stateSnapshot.current.items],
-                orientation: stateSnapshot.current.orientation,
-                position: { ...stateSnapshot.current.position },
-                isConfigMode: false,
-            }));
-            stateSnapshot.current = null;
-            return;
-        }
-        // If no changes, simply exit config mode
-        if (!hasChanges()) {
-            stateSnapshot.current = null;
-            const cleanedItems = removeTrailingSeparators(state.items);
-            setState(s => ({ ...s, isConfigMode: false, items: cleanedItems }));
-            return;
+        // Notify parent about pin changes only if not syncing from external
+        // This prevents infinite loop: external change -> sync -> save -> onPinChange -> external change
+        if (!isSyncingFromExternal.current) {
+            onPinChange?.(pinnedIds);
         }
-        // If there are changes, ask for confirmation
-        TMMessageBoxManager.show({
-            message: 'Perderai le tue modifiche, sei sicuro?',
-            buttons: [ButtonNames.YES, ButtonNames.NO],
-            onButtonClick: (buttonName) => {
-                if (buttonName === ButtonNames.YES && stateSnapshot.current) {
-                    // Restore snapshot and exit config mode
-                    setState(s => ({
-                        ...s,
-                        items: [...stateSnapshot.current.items],
-                        orientation: stateSnapshot.current.orientation,
-                        position: { ...stateSnapshot.current.position },
-                        isConfigMode: false,
-                    }));
-                    stateSnapshot.current = null;
-                }
-            },
-        });
-    };
+        isSyncingFromExternal.current = false; // Reset the flag
+    }, [state.orientation, state.items, state.position, enableConfigMode, onPinChange]);
     const toggleOrientation = () => {
         const newOrientation = state.orientation === 'horizontal' ? 'vertical' : 'horizontal';
+        // When switching from vertical back to horizontal, restore the original position
+        // Use visibility hiding only for this case to prevent flicker during position restoration
+        if (state.orientation === 'vertical' && newOrientation === 'horizontal') {
+            if (positionBeforeOrientationChange.current) {
+                setIsOrientationChanging(true); // Hide only when restoring position
+                const savedPosition = positionBeforeOrientationChange.current.position;
+                const savedPixelPosition = positionBeforeOrientationChange.current.pixelPosition;
+                setPixelPosition(savedPixelPosition);
+                setState(s => ({
+                    ...s,
+                    orientation: newOrientation,
+                    verticalDirection: 'down',
+                    position: savedPosition,
+                }));
+                positionBeforeOrientationChange.current = null;
+                // Show the bar after the state has been applied
+                requestAnimationFrame(() => {
+                    setIsOrientationChanging(false);
+                });
+                return;
+            }
+        }
+        // When switching to vertical, save current position and check if we need to expand upward
+        // Use opacity hiding (doesn't affect focus unlike visibility:hidden)
         if (state.orientation === 'horizontal' && newOrientation === 'vertical') {
+            setIsOrientationChanging(true);
+            // Save the current position before changing orientation
+            positionBeforeOrientationChange.current = {
+                position: { ...state.position },
+                pixelPosition: { ...pixelPosition },
+            };
             if (floatingRef.current) {
                 const floating = floatingRef.current.getBoundingClientRect();
-                const screenHeight = window.innerHeight;
-                if (floating.width > screenHeight - 70) {
+                const containerHeight = isConstrained && containerRef.current
+                    ? containerRef.current.getBoundingClientRect().height
+                    : window.innerHeight;
+                // Estimate vertical height (horizontal width becomes vertical height)
+                const estimatedVerticalHeight = floating.width;
+                if (estimatedVerticalHeight > containerHeight - 70) {
                     ShowAlert({
                         mode: 'warning',
                         title: 'Troppi elementi',
                         message: 'Ci sono troppi elementi nella barra mobile per la modalità verticale.',
                         duration: 4000,
                     });
+                    positionBeforeOrientationChange.current = null; // Clear saved position since we're not changing
+                    setIsOrientationChanging(false); // Show bar again since we're not changing
+                    return;
+                }
+                // Check if we're in the bottom part of the screen and don't have enough space below
+                const spaceBelow = containerHeight - floating.bottom;
+                const spaceAbove = floating.top;
+                const needsVerticalSpace = estimatedVerticalHeight - floating.height; // Additional space needed
+                // If not enough space below but enough space above, expand upward
+                if (spaceBelow < needsVerticalSpace && spaceAbove >= needsVerticalSpace) {
+                    // Calculate the new Y position so the bottom of the bar stays at the same place
+                    const currentBottom = pixelPosition.y + floating.height;
+                    const newPixelY = currentBottom - estimatedVerticalHeight;
+                    setState(s => ({
+                        ...s,
+                        orientation: newOrientation,
+                        verticalDirection: 'up',
+                    }));
+                    // Update pixel position and percentage after orientation change
+                    requestAnimationFrame(() => {
+                        requestAnimationFrame(() => {
+                            const newY = Math.max(0, newPixelY);
+                            setPixelPosition(prev => ({ ...prev, y: newY }));
+                            const newPercentY = pixelsToPercent(newY, containerHeight);
+                            setState(s => ({
+                                ...s,
+                                position: { ...s.position, y: newPercentY },
+                            }));
+                            setIsOrientationChanging(false);
+                        });
+                    });
                     return;
                 }
             }
         }
+        // Default case: just change orientation without special positioning
         setState(s => ({
             ...s,
             orientation: newOrientation,
+            verticalDirection: 'down',
         }));
         requestAnimationFrame(() => {
             requestAnimationFrame(() => {
@@ -715,25 +693,97 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
                         }));
                     }
                 }
+                setIsOrientationChanging(false);
             });
         });
     };
     const removeItem = (itemId) => {
+        isLocalChange.current = true;
         setState(s => ({
             ...s,
             items: s.items.filter(item => item.id !== itemId),
         }));
     };
+    const getItemRightClickMenuItems = useCallback((item, index) => {
+        const hasSeparatorOnRight = index < state.items.length - 1 && state.items[index + 1]?.isSeparator;
+        const hasSeparatorOnLeft = index > 0 && state.items[index - 1]?.isSeparator;
+        return [
+            {
+                name: 'Rimuovi',
+                icon: _jsx(IconDelete, { fontSize: 16 }),
+                onClick: () => removeItem(item.id),
+            },
+            {
+                name: 'Aggiungi separatore a sinistra',
+                icon: _jsx(IconSeparator, { fontSize: 16 }),
+                disabled: hasSeparatorOnLeft,
+                onClick: () => {
+                    isLocalChange.current = true;
+                    const separator = createSeparator();
+                    setState(s => {
+                        const newItems = [...s.items];
+                        newItems.splice(index, 0, separator);
+                        return { ...s, items: newItems };
+                    });
+                },
+            },
+            {
+                name: 'Aggiungi separatore a destra',
+                icon: _jsx(IconSeparator, { style: { transform: 'rotate(-90deg)' }, fontSize: 16 }),
+                disabled: hasSeparatorOnRight,
+                onClick: () => {
+                    isLocalChange.current = true;
+                    const separator = createSeparator();
+                    setState(s => {
+                        const newItems = [...s.items];
+                        newItems.splice(index + 1, 0, separator);
+                        return { ...s, items: newItems };
+                    });
+                },
+            },
+            {
+                beginGroup: true,
+                name: state.orientation === 'horizontal' ? 'Floating bar verticale' : 'Floating bar orizzontale',
+                icon: _jsx(IconRotate, { fontSize: 16 }),
+                onClick: toggleOrientation,
+            },
+        ];
+    }, [state.items, state.orientation, removeItem, createSeparator, toggleOrientation]);
+    const getSeparatorRightClickMenuItems = useCallback((index) => {
+        return [
+            {
+                name: 'Rimuovi',
+                icon: _jsx(IconDelete, { fontSize: 16 }),
+                onClick: () => removeItem(state.items[index].id),
+            },
+            {
+                name: 'Aggiungi separatore a sinistra',
+                icon: _jsx(IconSeparator, { fontSize: 16 }),
+                disabled: true,
+            },
+            {
+                name: 'Aggiungi separatore a destra',
+                icon: _jsx(IconSeparator, { style: { transform: 'rotate(-90deg)' }, fontSize: 16 }),
+                disabled: true,
+            },
+            {
+                beginGroup: true,
+                name: state.orientation === 'horizontal' ? 'Floating bar verticale' : 'Floating bar orizzontale',
+                icon: _jsx(IconRotate, { fontSize: 16 }),
+                onClick: toggleOrientation,
+            },
+        ];
+    }, [state.items, state.orientation, removeItem, toggleOrientation]);
     // Drag and drop for reordering
     const handleDragStart = (e, index) => {
-        if (!state.isConfigMode)
+        if (!enableConfigMode)
             return;
         e.dataTransfer.effectAllowed = 'move';
         e.dataTransfer.setData('text/plain', index.toString());
         setState(s => ({ ...s, draggedItemIndex: index }));
     };
     const handleDragEnter = (e, index) => {
-        if (!state.isConfigMode)
+        if (!enableConfigMode)
             return;
         e.preventDefault();
         if (state.draggedItemIndex !== index) {
@@ -741,13 +791,13 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
         }
     };
     const handleDragOver = (e) => {
-        if (!state.isConfigMode)
+        if (!enableConfigMode)
             return;
         e.preventDefault();
         e.dataTransfer.dropEffect = 'move';
     };
     const handleDragLeave = (_e, index) => {
-        if (!state.isConfigMode)
+        if (!enableConfigMode)
             return;
         // Only clear if we're actually leaving this specific item
         if (dragOverIndex === index) {
@@ -755,7 +805,7 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
         }
     };
     const handleDrop = (e, dropIndex) => {
-        if (!state.isConfigMode || state.draggedItemIndex === null)
+        if (!enableConfigMode || state.draggedItemIndex === null)
             return;
         e.preventDefault();
         e.stopPropagation();
@@ -764,6 +814,7 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
             setDragOverIndex(null);
             return;
         }
+        isLocalChange.current = true;
         const newItems = [...state.items];
         const [draggedItem] = newItems.splice(dragIndex, 1);
         newItems.splice(dropIndex, 0, draggedItem);
@@ -778,44 +829,37 @@ const TMFloatingMenuBar = ({ containerRef, contextMenuItems = [], isConstrained
         setState(s => ({ ...s, draggedItemIndex: null }));
         setDragOverIndex(null);
     };
-    return (_jsxs(_Fragment, { children: [_jsx(S.Overlay, { "$visible": state.isConfigMode }), _jsxs(S.FloatingContainer, { ref: floatingRef, "$x": pixelPosition.x, "$y": pixelPosition.y, "$orientation": state.orientation, "$isDragging": state.isDragging, "$isConfigMode": state.isConfigMode, "$isConstrained": isConstrained, "$bgColor": bgColor, onContextMenu: (e) => e.preventDefault(), children: [!state.isConfigMode ? (_jsx(ContextMenu, { items: [
-                            ...(!disbaleConfigMode ? [{
-                                    name: SDKUI_Localizator.Configure,
-                                    onClick: () => {
-                                        if (!state.isConfigMode) {
-                                            toggleConfigMode();
-                                        }
-                                    },
-                                }] : []),
-                            {
-                                name: state.orientation === 'horizontal' ? 'Floating bar verticale' : 'Floating bar orizzontale',
-                                onClick: toggleOrientation,
-                            },
-                        ], trigger: "right", children: _jsx(S.GripHandle, { "$orientation": state.orientation, onMouseDown: handleMouseDown, onTouchStart: handleTouchStart, onDoubleClick: handleGripDoubleClick, children: _jsx(IconDraggableDots, {}) }) })) : (_jsx(S.GripHandle, { "$orientation": state.orientation, onMouseDown: handleMouseDown, onTouchStart: handleTouchStart, onDoubleClick: handleGripDoubleClick, children: _jsx(IconDraggableDots, {}) })), _jsx(S.Separator, { "$orientation": state.orientation }), state.items.map((item, index) => {
-                        // Handle separator items
-                        if (item.isSeparator) {
-                            return (_jsxs(S.DraggableItem, { "$isDragging": state.draggedItemIndex === index, "$isDragOver": dragOverIndex === index && state.draggedItemIndex !== index, draggable: state.isConfigMode, onDragStart: (e) => handleDragStart(e, index), onDragEnter: (e) => handleDragEnter(e, index), onDragOver: handleDragOver, onDragLeave: (e) => handleDragLeave(e, index), onDrop: (e) => handleDrop(e, index), onDragEnd: handleDragEnd, children: [_jsx(S.ItemSeparator, { "$orientation": state.orientation, "$isConfigMode": state.isConfigMode }), state.isConfigMode && (_jsx(S.RemoveButton, { onClick: () => removeItem(item.id), children: "\u00D7" }))] }, item.id));
-                        }
-                        // Get current state (disabled and onClick) from contextMenuItems
-                        const currentState = getCurrentItemState(item.id);
-                        // Prefer currentState.disabled if contextMenuItems has items, otherwise use item.disabled
-                        const isDisabled = (contextMenuItems.length > 0 && currentState.disabled !== undefined)
-                            ? currentState.disabled === true
-                            : item.disabled === true;
-                        const currentOnClick = currentState.onClick || item.onClick; // Fallback to stored onClick if not found
-                        return (_jsx(S.DraggableItem, { "$isDragging": state.draggedItemIndex === index, "$isDragOver": dragOverIndex === index && state.draggedItemIndex !== index, draggable: state.isConfigMode, onDragStart: (e) => handleDragStart(e, index), onDragEnter: (e) => handleDragEnter(e, index), onDragOver: handleDragOver, onDragLeave: (e) => handleDragLeave(e, index), onDrop: (e) => handleDrop(e, index), onDragEnd: handleDragEnd, children: item.staticItem ? (
-                            // Visualizza l'elemento statico personalizzato
-                            _jsxs(_Fragment, { children: [item.staticItem, state.isConfigMode && (_jsx(S.RemoveButton, { onClick: () => removeItem(item.id), children: "\u00D7" }))] })) : (
-                            // Visualizza il pulsante standard
-                            _jsxs(_Fragment, { children: [_jsx(TMTooltip, { content: item.name, position: "bottom", children: _jsx(S.MenuButton, { onClick: () => {
-                                                if (state.isConfigMode || isDisabled)
-                                                    return;
-                                                if (currentOnClick) {
-                                                    currentOnClick();
-                                                }
-                                            }, disabled: isDisabled, "$isActive": item.isToggle, children: item.icon }) }), state.isConfigMode && (_jsx(S.RemoveButton, { onClick: () => removeItem(item.id), children: "\u00D7" }))] })) }, item.id));
-                    }), !state.isConfigMode && !disbaleConfigMode && contextMenuItems.length > 0 && (_jsx(ContextMenu, { items: getContextMenuItemsWithPinIcons(), trigger: "left", keepOpenOnClick: false, children: _jsx(S.ContextMenuButton, { children: _jsx(IconMenuVertical, {}) }) })), state.isConfigMode && state.items.length < maxItems && contextMenuItems.length > 0 && (_jsx(ContextMenu, { items: getPinContextMenuItems(), trigger: "left", keepOpenOnClick: true, children: _jsx(TMTooltip, { content: SDKUI_Localizator.Add, children: _jsx(S.AddButton, { children: _jsx(IconAdd, {}) }) }) })), state.isConfigMode && (_jsxs(_Fragment, { children: [_jsx(S.Separator, { "$orientation": state.orientation }), _jsxs(S.ButtonGroup, { "$orientation": state.orientation, children: [_jsx(TMTooltip, { content: SDKUI_Localizator.Undo, position: state.orientation === 'horizontal' ? 'right' : 'top', children: _jsx(S.UndoButton, { onClick: handleUndo, disabled: !hasChanges(), children: _jsx(IconUndo, { fontSize: 18 }) }) }), _jsx(TMTooltip, { content: state.items.length === 0
-                                            ? 'Devi aggiungere almeno un item'
-                                            : SDKUI_Localizator.Save, position: state.orientation === 'horizontal' ? 'right' : 'top', children: _jsx(S.ApplyButton, { onClick: toggleConfigMode, disabled: state.items.length === 0 || !hasChanges(), children: _jsx(IconSave, { fontSize: 20 }) }) }), _jsx(TMTooltip, { content: SDKUI_Localizator.Close, position: state.orientation === 'horizontal' ? 'right' : 'top', children: _jsx(S.CloseButton, { onClick: handleClose, children: _jsx(IconCloseOutline, { fontSize: 20 }) }) })] })] }))] })] }));
+    return (_jsxs(S.FloatingContainer, { ref: floatingRef, "$x": pixelPosition.x, "$y": pixelPosition.y, "$orientation": state.orientation, "$verticalDirection": state.verticalDirection, "$isDragging": state.isDragging, "$isConfigMode": false, "$isConstrained": isConstrained, "$isHidden": isOrientationChanging, "$bgColor": bgColor, onContextMenu: undefined, children: [_jsx(ContextMenu, { items: [
+                    {
+                        name: state.orientation === 'horizontal' ? 'Floating bar verticale' : 'Floating bar orizzontale',
+                        icon: _jsx(IconRotate, { fontSize: 16, style: { transform: state.orientation === 'horizontal' ? 'rotate(90deg)' : 'rotate(0deg)' } }),
+                        onClick: toggleOrientation,
+                    },
+                ], trigger: "right", children: _jsx(S.GripHandle, { "$orientation": state.orientation, onMouseDown: handleMouseDown, onTouchStart: handleTouchStart, onDoubleClick: handleGripDoubleClick, children: _jsx(IconDraggableDots, {}) }) }), _jsx(S.Separator, { "$orientation": state.orientation }), state.items.map((item, index) => {
+                // Handle separator items
+                if (item.isSeparator) {
+                    return (_jsx(S.DraggableItem, { "$isDragging": state.draggedItemIndex === index, "$isDragOver": dragOverIndex === index && state.draggedItemIndex !== index, draggable: enableConfigMode, onDragStart: (e) => handleDragStart(e, index), onDragEnter: (e) => handleDragEnter(e, index), onDragOver: handleDragOver, onDragLeave: (e) => handleDragLeave(e, index), onDrop: (e) => handleDrop(e, index), onDragEnd: handleDragEnd, children: enableConfigMode ? (_jsx(ContextMenu, { items: getSeparatorRightClickMenuItems(index), trigger: "right", children: _jsx(S.ItemSeparator, { "$orientation": state.orientation, "$isConfigMode": false }) })) : (_jsx(S.ItemSeparator, { "$orientation": state.orientation, "$isConfigMode": false })) }, item.id));
+                }
+                // Get current state (disabled and onClick) from contextMenuItems
+                const currentState = getCurrentItemState(item.id);
+                // Prefer currentState.disabled if contextMenuItems has items, otherwise use item.disabled
+                const isDisabled = (contextMenuItems.length > 0 && currentState.disabled !== undefined)
+                    ? currentState.disabled === true
+                    : item.disabled === true;
+                const currentOnClick = currentState.onClick || item.onClick; // Fallback to stored onClick if not found
+                return (_jsx(S.DraggableItem, { "$isDragging": state.draggedItemIndex === index, "$isDragOver": dragOverIndex === index && state.draggedItemIndex !== index, draggable: enableConfigMode, onDragStart: (e) => handleDragStart(e, index), onDragEnter: (e) => handleDragEnter(e, index), onDragOver: handleDragOver, onDragLeave: (e) => handleDragLeave(e, index), onDrop: (e) => handleDrop(e, index), onDragEnd: handleDragEnd, children: enableConfigMode ? (_jsx(ContextMenu, { items: getItemRightClickMenuItems(item, index), trigger: "right", children: item.staticItem ? (_jsx("div", { children: item.staticItem })) : (_jsx(TMTooltip, { content: item.name, position: "bottom", children: _jsx(S.MenuButton, { onClick: () => {
+                                    if (isDisabled)
+                                        return;
+                                    if (currentOnClick) {
+                                        currentOnClick();
+                                    }
+                                }, disabled: isDisabled, "$isActive": item.isToggle, children: item.icon }) })) })) : (item.staticItem ? (_jsx("div", { children: item.staticItem })) : (_jsx(TMTooltip, { content: item.name, position: "bottom", children: _jsx(S.MenuButton, { onClick: () => {
+                                if (isDisabled)
+                                    return;
+                                if (currentOnClick) {
+                                    currentOnClick();
+                                }
+                            }, disabled: isDisabled, "$isActive": item.isToggle, children: item.icon }) }))) }, item.id));
+            }), enableConfigMode && hasContextMenu && contextMenuItems.length > 0 && (_jsx(ContextMenu, { items: getContextMenuItemsWithPinIcons(), trigger: "left", keepOpenOnClick: false, children: _jsx(S.ContextMenuButton, { children: _jsx(IconMenuVertical, {}) }) }))] }));
 };
 export default TMFloatingMenuBar;