@topconsultnpm/sdkui-react 6.20.0-dev2.5 → 6.20.0-dev2.51

package/lib/components/base/Styled.d.ts

@@ -7,6 +7,7 @@ export declare const StyledMultiViewPanel: import("styled-components/dist/types"
 }>> & string;
 export declare const StyledParagraph: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, never>> & string;
 export declare const StyledToolbarForm: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const ReferencesContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const StyledReferenceButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
 export declare const StyledPanelPage: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
     $isOpen?: boolean;

package/lib/components/base/Styled.js

@@ -36,17 +36,25 @@ export const StyledToolbarForm = styled.div `
     gap: 2px;
     background-color: ${TMColors.toolbar_background};
 `;
+export const ReferencesContainer = styled.div `
+    display: flex;
+    justify-content: center;
+    gap: 12px;
+    flex-wrap: wrap;
+    width: 100%;
+    height: 100%;
+`;
 export const StyledReferenceButton = styled.button `
     display: flex;
     flex-direction: column;
     align-items: center;
     justify-content: center;
-    padding: 10px 16px;
+    padding: 10px 25px;
     border-radius: 20px;
     border: none;
     background-color: ${TMColors.button_floating_background};
     color: white;
-    font-size: 0.9rem;
+    font-size: 0.95rem;
     font-weight: 500;
     cursor: pointer;
     transition: all 0.2s ease;

package/lib/components/base/TMTreeView.d.ts

@@ -6,8 +6,9 @@ export interface ITMTreeItem {
     hidden?: boolean;
     isLoaded?: boolean;
     isContainer: boolean;
+    isExpandible?: boolean;
     items?: ITMTreeItem[];
-    visibleItemsCount?: number;
+    currentPage?: number;
     totalItemsCount?: number;
 }
 interface ITMTreeViewProps<T extends ITMTreeItem> {
@@ -31,3 +32,4 @@ export default TMTreeView;
 export declare const StyledTreeNode: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
     $isSelected?: boolean;
 }>> & string;
+export declare const StyledStickyPaginator: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/lib/components/base/TMTreeView.js

@@ -85,7 +85,9 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
                         let newItems = node.items;
                         // Solo se calculateItemsForNode è definito E (ctrl è premuto O non è già caricato)
                         if (calculateItemsForNode && (ctrlKey || !node.isLoaded)) {
-                            newItems = await calculateItemsForNode(node);
+                            // Se ctrl è premuto, passa un nodo con isLoaded resettato per forzare il refresh
+                            const nodeForCalculation = ctrlKey ? { ...node, isLoaded: false } : node;
+                            newItems = await calculateItemsForNode(nodeForCalculation);
                             const updatedNode = { ...node, expanded: true, items: newItems, isLoaded: true };
                             onNodeUpdate?.(updatedNode);
                             return updatedNode;
@@ -274,53 +276,62 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
         return childKeys.every(key => selectedChildKeys.includes(key));
     };
     const hasVisibleItems = (node) => {
+        // If node has explicit isExpandible value, use that
+        if (node.isExpandible !== undefined) {
+            return node.isExpandible;
+        }
+        // Fallback: check if node has visible items
         if (!node.items)
             return false;
         if (node.items.length <= 0)
             return false;
         return node.items.filter(o => !o.hidden).length > 0;
     };
-    // Gestisce il caricamento di più items per un nodo
-    const handleLoadMoreItems = useCallback((nodeKey) => {
-        const updateNodeVisibleCount = (nodes) => {
+    // Gestisce il cambio di pagina per un nodo
+    const handlePageChange = useCallback((nodeKey, newPage) => {
+        const updateNodePage = (nodes) => {
             return nodes.map(node => {
                 if (node.key === nodeKey) {
-                    const currentVisible = node.visibleItemsCount ?? itemsPerPage;
-                    const newVisible = Math.min(currentVisible + itemsPerPage, node.totalItemsCount ?? node.items?.length ?? 0);
-                    const updatedNode = { ...node, visibleItemsCount: newVisible };
+                    const updatedNode = { ...node, currentPage: newPage };
                     onNodeUpdate?.(updatedNode);
                     return updatedNode;
                 }
                 if (node.items) {
-                    return { ...node, items: updateNodeVisibleCount(node.items) };
+                    return { ...node, items: updateNodePage(node.items) };
                 }
                 return node;
             });
         };
-        const updatedData = updateNodeVisibleCount(dataSource);
+        const updatedData = updateNodePage(dataSource);
         onDataChanged?.(updatedData);
-    }, [dataSource, itemsPerPage, onDataChanged, onNodeUpdate]);
+    }, [dataSource, onDataChanged, onNodeUpdate]);
     // Filtra gli items da mostrare in base alla paginazione
     const getVisibleItems = useCallback((node) => {
         if (!node.items)
             return [];
         const totalItems = node.items.length;
-        const visibleCount = node.visibleItemsCount ?? itemsPerPage;
         // Se non c'è paginazione attiva o gli items sono pochi, mostra tutti
         if (totalItems <= itemsPerPage || !showLoadMoreButton) {
             return node.items;
         }
-        // Altrimenti mostra solo i primi N items
-        return node.items.slice(0, visibleCount);
+        // Altrimenti mostra solo gli items della pagina corrente
+        const currentPage = node.currentPage ?? 0;
+        const startIndex = currentPage * itemsPerPage;
+        const endIndex = startIndex + itemsPerPage;
+        return node.items.slice(startIndex, endIndex);
     }, [itemsPerPage, showLoadMoreButton]);
-    // Verifica se c'è bisogno del bottone "Load More"
-    const needsLoadMoreButton = useCallback((node) => {
+    // Verifica se c'è bisogno del paginatore
+    const needsPagination = useCallback((node) => {
         if (!showLoadMoreButton || !node.items)
             return false;
-        const totalItems = node.items.length;
-        const visibleCount = node.visibleItemsCount ?? itemsPerPage;
-        return totalItems > itemsPerPage && visibleCount < totalItems;
+        return node.items.length > itemsPerPage;
     }, [itemsPerPage, showLoadMoreButton]);
+    // Calcola il numero totale di pagine per un nodo
+    const getTotalPages = useCallback((node) => {
+        if (!node.items)
+            return 0;
+        return Math.ceil(node.items.length / itemsPerPage);
+    }, [itemsPerPage]);
     const renderTree = useCallback((nodes) => {
         return nodes.map(node => !node.hidden && (_jsxs("div", { style: { width: '100%', margin: 0, padding: 0 }, children: [_jsxs(StyledTreeNode, { "$isSelected": node.key === focusedItem?.key, children: [_jsx("div", { style: {
                                 display: 'flex',
@@ -339,8 +350,8 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
                                 if (input) {
                                     input.indeterminate = isIndeterminate(node);
                                 }
-                            } })), _jsx("div", { style: { display: 'flex', alignItems: 'center', flex: 1, minWidth: 0 }, onClick: (e) => { handleNodeClick(node, e); }, children: itemRender(node) })] }), node.expanded && node.items && (_jsxs("div", { style: { paddingLeft: 20, width: '100%' }, children: [renderTree(getVisibleItems(node)), needsLoadMoreButton(node) && (_jsx("div", { style: { display: 'flex', justifyContent: 'center', margin: '5px 0' }, children: _jsx(TMButton, { onClick: () => handleLoadMoreItems(node.key), showTooltip: false, caption: `Carica altri ${itemsPerPage}... (${node.visibleItemsCount ?? itemsPerPage} / ${node.items?.length ?? 0})` }) }))] }))] }, node.key)));
-    }, [handleNodeClick, handleNodeToggle, handleCheckboxChange, focusedItem, selectedItems, allowMultipleSelection, getVisibleItems, needsLoadMoreButton, handleLoadMoreItems, itemsPerPage]);
+                            } })), _jsx("div", { style: { display: 'flex', alignItems: 'center', flex: 1, minWidth: 0 }, onClick: (e) => { handleNodeClick(node, e); }, children: itemRender(node) })] }), node.expanded && node.items && (_jsxs("div", { style: { paddingLeft: 20, width: '100%' }, children: [renderTree(getVisibleItems(node)), needsPagination(node) && (_jsxs(StyledStickyPaginator, { children: [_jsx(TMButton, { onClick: () => handlePageChange(node.key, (node.currentPage ?? 0) - 1), showTooltip: false, caption: "\u25C4", disabled: (node.currentPage ?? 0) <= 0 }), _jsxs("span", { style: { fontSize: '12px', whiteSpace: 'nowrap', fontWeight: 500, overflow: 'hidden', textOverflow: 'ellipsis', minWidth: 0 }, children: ["Pagina ", (node.currentPage ?? 0) + 1, " di ", getTotalPages(node), " (", node.items?.length ?? 0, " elementi)"] }), _jsx(TMButton, { onClick: () => handlePageChange(node.key, (node.currentPage ?? 0) + 1), showTooltip: false, caption: "\u25BA", disabled: (node.currentPage ?? 0) >= getTotalPages(node) - 1 })] }))] }))] }, node.key)));
+    }, [handleNodeClick, handleNodeToggle, handleCheckboxChange, focusedItem, selectedItems, allowMultipleSelection, getVisibleItems, needsPagination, handlePageChange, getTotalPages]);
     return (_jsx("div", { style: { height: '100%', width: '100%', overflowY: 'auto', overflowX: 'hidden', padding: '0px 5px 2px 2px' }, children: renderTree(dataSource) }));
 };
 export default TMTreeView;
@@ -361,3 +372,35 @@ export const StyledTreeNode = styled.div `
         background: ${() => `oklch(from var(--dx-color-primary) l c h / .1)`};
     }
 `;
+export const StyledStickyPaginator = styled.div `
+	position: sticky;
+	bottom: 0;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	gap: 8px;
+	margin: 8px 0;
+	padding: 8px 12px;
+	background: oklch(from var(--dx-color-primary) l c h / .85);
+	border: 1px solid oklch(from var(--dx-color-primary) l c h / .9);
+	border-radius: 6px;
+	box-shadow: 0 -2px 8px oklch(from var(--dx-color-primary) l c h / .15);
+	transition: all 0.2s ease;
+	min-width: 0;
+	z-index: 10;
+
+	& > button {
+		flex-shrink: 0;
+	}
+
+	& > span {
+		flex: 1 1 auto;
+		min-width: 0;
+	}
+
+	&:hover {
+		background: oklch(from var(--dx-color-primary) l c h / .95);
+		border-color: oklch(from var(--dx-color-primary) l c h / 1);
+		box-shadow: 0 -2px 12px oklch(from var(--dx-color-primary) l c h / .2);
+	}
+`;

package/lib/components/choosers/TMDataListItemEditor.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { DataListItemDescriptor } from '@topconsultnpm/sdk-ts';
+interface TMDataListItemEditorProps {
+    isOpen: boolean;
+    item?: DataListItemDescriptor;
+    isCreating: boolean;
+    onClose: () => void;
+    onSave: (item: DataListItemDescriptor) => void;
+}
+declare const TMDataListItemEditor: React.FC<TMDataListItemEditorProps>;
+export default TMDataListItemEditor;

package/lib/components/choosers/TMDataListItemEditor.js

@@ -0,0 +1,130 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import styled from 'styled-components';
+import { DataListItemDescriptor, NamesLoc3, PlatformObjectValidator } from '@topconsultnpm/sdk-ts';
+import { IconCloseOutline, IconSave, IconUndo, SDKUI_Localizator } from '../../helper';
+import TMButton from '../base/TMButton';
+import TMModal from '../base/TMModal';
+import TMDataListItemFields from './TMDataListItemFields';
+import { TMColors } from '../../utils/theme';
+const FormContainer = styled.div `
+  display: flex;
+  flex-direction: column;
+  gap: 15px;
+  padding: 20px;
+`;
+const ButtonsContainer = styled.div `
+  display: flex;
+  justify-content: flex-end;
+  gap: 10px;
+  margin-top: 10px;
+`;
+const TMDataListItemEditor = ({ isOpen, item, isCreating, onClose, onSave }) => {
+    const [editedItem, setEditedItem] = useState(null);
+    const [editedItemOrig, setEditedItemOrig] = useState(null);
+    const [validationItems, setValidationItems] = useState([]);
+    useEffect(() => {
+        if (!editedItem)
+            return;
+        let vil = [];
+        PlatformObjectValidator.DataListItemValidator(editedItem, vil);
+        setValidationItems(vil);
+    }, [editedItem]);
+    // Funzione helper per clonare un DataListItemDescriptor
+    const cloneItem = (source) => {
+        const clone = new DataListItemDescriptor();
+        Object.assign(clone, source);
+        if (source.namesLoc) {
+            const namesLocClone = new NamesLoc3();
+            namesLocClone.init(source.namesLoc);
+            clone.namesLoc = namesLocClone;
+        }
+        return clone;
+    };
+    useEffect(() => {
+        if (isOpen) {
+            if (item) {
+                // Crea una copia dell'item per editarlo
+                const clone = cloneItem(item);
+                setEditedItem(clone);
+                // Salva anche l'originale per il confronto e l'undo
+                const original = cloneItem(item);
+                setEditedItemOrig(original);
+            }
+            else {
+                // Nuovo item vuoto
+                const newItem = new DataListItemDescriptor();
+                newItem.value = '';
+                newItem.name = '';
+                setEditedItem(newItem);
+                setEditedItemOrig(cloneItem(newItem));
+            }
+        }
+    }, [isOpen, item]);
+    // Funzione per verificare se ci sono modifiche rispetto all'originale
+    const hasChanges = () => {
+        if (!editedItem || !editedItemOrig)
+            return false;
+        // Confronta i campi principali
+        if (editedItem.value !== editedItemOrig.value)
+            return true;
+        if (editedItem.name !== editedItemOrig.name)
+            return true;
+        if (editedItem.imageID !== editedItemOrig.imageID)
+            return true;
+        // Confronta namesLoc
+        const namesLoc1 = editedItem.namesLoc;
+        const namesLoc2 = editedItemOrig.namesLoc;
+        if (!namesLoc1 && !namesLoc2)
+            return false;
+        if (!namesLoc1 || !namesLoc2)
+            return true;
+        if (namesLoc1.it_IT !== namesLoc2.it_IT)
+            return true;
+        if (namesLoc1.en_US !== namesLoc2.en_US)
+            return true;
+        if (namesLoc1.fr_FR !== namesLoc2.fr_FR)
+            return true;
+        if (namesLoc1.pt_PT !== namesLoc2.pt_PT)
+            return true;
+        if (namesLoc1.es_ES !== namesLoc2.es_ES)
+            return true;
+        if (namesLoc1.de_DE !== namesLoc2.de_DE)
+            return true;
+        return false;
+    };
+    const handleUndo = () => {
+        if (!editedItemOrig)
+            return;
+        // Ripristina l'item originale clonandolo
+        const restored = cloneItem(editedItemOrig);
+        setEditedItem(restored);
+    };
+    const handleSave = () => {
+        if (!editedItem)
+            return;
+        // Pulisci namesLoc rimuovendo valori undefined o vuoti, mantenendo l'istanza della classe
+        if (editedItem.namesLoc) {
+            const cleanedData = {};
+            Object.entries(editedItem.namesLoc).forEach(([key, value]) => {
+                if (value !== undefined && value !== '') {
+                    cleanedData[key] = value;
+                }
+            });
+            // Crea una nuova istanza di NamesLoc3 con i dati puliti
+            if (Object.keys(cleanedData).length > 0) {
+                const cleanedNamesLoc = new NamesLoc3();
+                cleanedNamesLoc.init(cleanedData);
+                editedItem.namesLoc = cleanedNamesLoc;
+            }
+            else {
+                editedItem.namesLoc = undefined;
+            }
+        }
+        onSave(editedItem);
+    };
+    if (!isOpen || !editedItem)
+        return null;
+    return (_jsx(TMModal, { title: isCreating ? SDKUI_Localizator.NewMale : SDKUI_Localizator.Update, width: "400px", height: "auto", isModal: true, onClose: onClose, children: _jsxs(FormContainer, { children: [_jsx(TMDataListItemFields, { item: editedItem, originalItem: editedItemOrig || undefined, onItemChanged: setEditedItem, validationItems: validationItems }), _jsxs(ButtonsContainer, { children: [_jsx(TMButton, { caption: SDKUI_Localizator.Save, btnStyle: 'advanced', advancedColor: TMColors.primary, icon: _jsx(IconSave, {}), showTooltip: false, onClick: handleSave }), _jsx(TMButton, { caption: SDKUI_Localizator.Undo, btnStyle: 'toolbar', color: 'primary', icon: _jsx(IconUndo, {}), showTooltip: false, disabled: !hasChanges(), onClick: handleUndo }), _jsx(TMButton, { caption: SDKUI_Localizator.Cancel, btnStyle: 'advanced', advancedColor: TMColors.primary, icon: _jsx(IconCloseOutline, {}), showTooltip: false, onClick: onClose })] })] }) }));
+};
+export default TMDataListItemEditor;

package/lib/components/choosers/TMDataListItemFields.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { DataListItemDescriptor, ValidationItem } from '@topconsultnpm/sdk-ts';
+interface TMDataListItemFieldsProps {
+    item: DataListItemDescriptor;
+    originalItem?: DataListItemDescriptor;
+    onItemChanged: (item: DataListItemDescriptor) => void;
+    validationItems?: ValidationItem[];
+    readOnly?: boolean;
+}
+declare const TMDataListItemFields: React.FC<TMDataListItemFieldsProps>;
+export default TMDataListItemFields;

package/lib/components/choosers/TMDataListItemFields.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import styled from 'styled-components';
+import { DataListItemDescriptor, CultureIDs, NamesLoc3 } from '@topconsultnpm/sdk-ts';
+import { SDKUI_Localizator } from '../../helper';
+import TMTextBox from '../editors/TMTextBox';
+import TMLocalizedTextBox from '../editors/TMLocalizedTextBox';
+import TMImageIDChooser from './TMImageIDChooser';
+const FieldsContainer = styled.div `
+  display: flex;
+  flex-direction: column;
+  gap: 15px;
+`;
+const TMDataListItemFields = ({ item, originalItem, onItemChanged, validationItems = [], readOnly = false }) => {
+    const handleLocalizedNameChange = (lang, newValue) => {
+        if (!item.namesLoc) {
+            item.namesLoc = new NamesLoc3();
+        }
+        const namesLoc = item.namesLoc; // Non-null assertion
+        switch (lang) {
+            case CultureIDs.It_IT:
+                namesLoc.it_IT = newValue;
+                break;
+            case CultureIDs.En_US:
+                namesLoc.en_US = newValue;
+                break;
+            case CultureIDs.Fr_FR:
+                namesLoc.fr_FR = newValue;
+                break;
+            case CultureIDs.Pt_PT:
+                namesLoc.pt_PT = newValue;
+                break;
+            case CultureIDs.Es_ES:
+                namesLoc.es_ES = newValue;
+                break;
+            case CultureIDs.De_DE:
+                namesLoc.de_DE = newValue;
+                break;
+            default:
+                item.name = newValue;
+                break;
+        }
+        // Forza il re-render clonando l'oggetto
+        const clone = new DataListItemDescriptor();
+        Object.assign(clone, item);
+        onItemChanged(clone);
+    };
+    const handleValueChange = (e) => {
+        item.value = e.target.value || '';
+        const clone = new DataListItemDescriptor();
+        Object.assign(clone, item);
+        onItemChanged(clone);
+    };
+    const handleImageIDChange = (imageID) => {
+        item.imageID = imageID;
+        const clone = new DataListItemDescriptor();
+        Object.assign(clone, item);
+        onItemChanged(clone);
+    };
+    return (_jsxs(FieldsContainer, { children: [_jsx(TMTextBox, { label: SDKUI_Localizator.Value, value: item.value, isModifiedWhen: (item.value || '') != (originalItem?.value || ''), validationItems: validationItems.filter(o => o.PropertyName === "value"), readOnly: readOnly, onValueChanged: handleValueChange }), _jsx(TMLocalizedTextBox, { label: SDKUI_Localizator.Description, value: item.name, isModifiedWhen: (item.name || '') != (originalItem?.name || ''), validationItems: validationItems.filter(o => o.PropertyName === "itemName"), readOnly: readOnly, value_IT: item.namesLoc?.it_IT, value_EN: item.namesLoc?.en_US, value_FR: item.namesLoc?.fr_FR, value_PT: item.namesLoc?.pt_PT, value_ES: item.namesLoc?.es_ES, value_DE: item.namesLoc?.de_DE, onValueChanged: handleLocalizedNameChange }), _jsx(TMImageIDChooser, { elementStyle: { marginBottom: '10px' }, label: "Immagine", value: item.imageID, isModifiedWhen: (item.imageID || '') != (originalItem?.imageID || ''), validationItems: validationItems.filter(o => o.PropertyName === "imageID"), readOnly: readOnly, onValueChanged: handleImageIDChange })] }));
+};
+export default TMDataListItemFields;

package/lib/components/choosers/TMDataListItemPicker.d.ts

@@ -4,6 +4,7 @@ interface TMDataListItemPickerProps {
     dataListID: number | undefined;
     selectedValue: string | undefined;
     onItemSelect: (item: DataListItemDescriptor) => void;
+    allowEdit?: boolean;
 }
 declare const TMDataListItemPicker: React.FC<TMDataListItemPickerProps>;
 export default TMDataListItemPicker;

package/lib/components/choosers/TMDataListItemPicker.js

@@ -1,8 +1,12 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import styled, { keyframes } from 'styled-components';
-import { DataListCacheService, SDK_Localizator } from '@topconsultnpm/sdk-ts';
-import { SDKUI_Localizator, TMImageLibrary } from '../../helper';
+import { DataListCacheService, SDK_Localizator, ObjectClasses, JobTypes } from '@topconsultnpm/sdk-ts';
+import { IconDelete, SDKUI_Localizator, TMImageLibrary } from '../../helper';
+import { PlatformObjectService } from '../../services/platform_services';
+import TMDataListItemEditor from './TMDataListItemEditor';
+import { ButtonNames, TMMessageBoxManager } from '../base/TMPopUp';
+import TMSpinner from '../base/TMSpinner';
 const PickerContainer = styled.div `
   display: flex;
   flex-direction: column;
@@ -30,6 +34,11 @@ const slideIn = keyframes `
     transform: translateX(0);
   }
 `;
+const ItemWrapper = styled.div `
+  position: relative;
+  display: flex;
+  flex-shrink: 0;
+`;
 const StatusItem = styled.div `
   display: flex;
   flex-direction: column;
@@ -58,39 +67,190 @@ const StatusItem = styled.div `
     background-color: #e6f2ff;
   `}
 `;
+const DeleteButton = styled.button `
+  position: absolute;
+  top: -8px;
+  right: -8px;
+  width: 24px;
+  height: 24px;
+  border-radius: 50%;
+  background-color: #dc3545;
+  color: white;
+  border: 2px solid white;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 14px;
+  font-weight: bold;
+  opacity: 0;
+  transition: all 0.2s ease-in-out;
+  box-shadow: 0 2px 4px rgba(0,0,0,0.2);
+  z-index: 10;
+
+  ${ItemWrapper}:hover & {
+    opacity: 1;
+  }
+
+  &:hover {
+    background-color: #c82333;
+    transform: scale(1.1);
+  }
+
+  &:active {
+    transform: scale(0.95);
+  }
+`;
+const AddButton = styled.div `
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  text-align: center;
+  font-size: 0.8em;
+  padding: 5px 10px;
+  border-radius: 8px;
+  border: 2px dashed #007bff;
+  background-color: #f8f9fa;
+  transition: all 0.2s ease-in-out;
+  flex-shrink: 0;
+  min-width: 80px;
+  color: #007bff;
+  font-weight: 500;
+
+  &:hover {
+    background-color: #e6f2ff;
+    border-color: #0056b3;
+  }
+`;
 const Label = styled.div `
   font-weight: bold;
   margin-bottom: 5px;
 `;
-const TMDataListItemPicker = ({ dataListID, selectedValue, onItemSelect }) => {
+const TMDataListItemPicker = ({ dataListID, selectedValue, onItemSelect, allowEdit = false }) => {
     const [dataList, setDataList] = useState(undefined);
+    const [items, setItems] = useState([]);
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState(undefined);
-    useEffect(() => {
-        if (dataListID) {
-            setLoading(true);
+    const [showEditDialog, setShowEditDialog] = useState(false);
+    const [editingItem, setEditingItem] = useState(undefined);
+    const [isCreating, setIsCreating] = useState(false);
+    const loadDataList = async (showLoading = true) => {
+        if (!dataListID)
+            return;
+        try {
+            if (showLoading)
+                setLoading(true);
             setError(undefined);
-            DataListCacheService.GetAsync(dataListID)
-                .then(dl => {
-                setDataList(dl);
-                setLoading(false);
-            })
-                .catch(err => {
-                console.error("Failed to fetch data list:", err);
-                setError("Failed to load statuses.");
+            const dl = await PlatformObjectService.retrieveAdminAsync(ObjectClasses.DataList, JobTypes.None, dataListID);
+            setDataList(dl);
+            setItems(dl?.items ?? []);
+        }
+        catch (err) {
+            console.error("Failed to fetch data list:", err);
+            setError("Failed to load data list.");
+        }
+        finally {
+            if (showLoading)
                 setLoading(false);
-            });
         }
+    };
+    useEffect(() => {
+        loadDataList(true);
     }, [dataListID]);
+    const handleCreateNew = () => {
+        setIsCreating(true);
+        setEditingItem(undefined);
+        setShowEditDialog(true);
+    };
+    const handleEdit = (item) => {
+        setIsCreating(false);
+        setEditingItem(item);
+        setShowEditDialog(true);
+    };
+    const handleSave = async (newItem) => {
+        if (!dataList || !dataListID)
+            return;
+        try {
+            let updatedItems;
+            TMSpinner.show({ description: 'Salvataggio in corso...' });
+            if (isCreating) {
+                // Aggiungi nuovo item
+                updatedItems = [...items, newItem];
+            }
+            else if (editingItem) {
+                // Modifica item esistente
+                updatedItems = items.map(item => item.value === editingItem.value ? newItem : item);
+            }
+            else {
+                return;
+            }
+            // Modifica direttamente la dataList invece di usare spread operator
+            dataList.items = updatedItems;
+            // Salva sul server usando l'API corretta
+            await PlatformObjectService.updateAsync(ObjectClasses.DataList, JobTypes.None, dataList);
+            // Invalida la cache per garantire la sincronizzazione
+            DataListCacheService.Remove();
+            // Ricarica i dati dalla cache (che richiamerà il server)
+            await loadDataList(false);
+            handleCloseDialog();
+        }
+        catch (error) {
+            console.error('Failed to save DataList item:', error);
+            setError('Failed to save changes.');
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    };
+    const handleCloseDialog = () => {
+        setShowEditDialog(false);
+        setEditingItem(undefined);
+        setIsCreating(false);
+    };
+    const handleDelete = async (item, event) => {
+        event.stopPropagation(); // Previeni la selezione dell'item quando si clicca delete
+        const confirmMessage = SDKUI_Localizator.Delete_ConfirmFor1.replaceParams(item.name);
+        TMMessageBoxManager.show({
+            title: SDKUI_Localizator.Delete, message: confirmMessage, buttons: [ButtonNames.YES, ButtonNames.NO],
+            onButtonClick: async (e) => {
+                if (e !== ButtonNames.YES)
+                    return;
+                if (!dataList || !dataListID)
+                    return;
+                try {
+                    TMSpinner.show({ description: 'Eliminazione in corso...' });
+                    // Rimuovi l'item dalla lista
+                    const updatedItems = items.filter(i => i.value !== item.value);
+                    // Modifica direttamente la dataList
+                    dataList.items = updatedItems;
+                    // Salva sul server usando l'API corretta
+                    await PlatformObjectService.updateAsync(ObjectClasses.DataList, JobTypes.None, dataList);
+                    // Invalida la cache per garantire la sincronizzazione
+                    DataListCacheService.Remove();
+                    // Ricarica i dati dalla cache (che richiamerà il server)
+                    await loadDataList(false);
+                }
+                catch (error) {
+                    console.error('Failed to delete DataList item:', error);
+                    setError('Failed to delete item.');
+                }
+                finally {
+                    TMSpinner.hide();
+                }
+            }
+        });
+    };
     if (loading) {
         return _jsxs("p", { children: [SDKUI_Localizator.Loading, "..."] });
     }
     if (error) {
         return _jsx("p", { children: error });
     }
-    if (!dataList || !dataList.items || dataList.items.length === 0) {
-        return _jsx("p", { children: SDKUI_Localizator.NoDataToDisplay });
+    if (!dataList || !items || items.length === 0) {
+        return (_jsxs(PickerContainer, { children: [_jsx(Label, { children: dataList ? `${SDK_Localizator.DataList}: ${dataList.name}` : SDKUI_Localizator.NoDataToDisplay }), _jsx(ItemsContainer, { children: allowEdit && (_jsxs(AddButton, { onClick: handleCreateNew, children: ["+ ", SDKUI_Localizator.NewMale] })) }), !allowEdit && _jsx("p", { children: SDKUI_Localizator.NoDataToDisplay })] }));
     }
-    return (_jsxs(PickerContainer, { children: [_jsx(Label, { children: `${SDK_Localizator.DataList}: ${dataList.name}` }), _jsx(ItemsContainer, { children: dataList.items.map((item, index) => (_jsxs(StatusItem, { "$isSelected": item.value === selectedValue, "$index": index, onClick: () => onItemSelect(item), children: [item.imageID && _jsx(TMImageLibrary, { imageID: item.imageID }), _jsx("span", { children: item.name })] }, item.value))) })] }));
+    return (_jsxs(PickerContainer, { children: [_jsx(Label, { children: `${SDK_Localizator.DataList}: ${dataList.name}` }), _jsxs(ItemsContainer, { children: [items.map((item, index) => (_jsxs(ItemWrapper, { children: [_jsxs(StatusItem, { "$isSelected": item.value === selectedValue, "$index": index, onClick: () => onItemSelect(item), onDoubleClick: () => allowEdit && handleEdit(item), children: [item.imageID && _jsx(TMImageLibrary, { imageID: item.imageID }), _jsx("span", { children: item.name })] }), allowEdit && (_jsx(DeleteButton, { onClick: (e) => handleDelete(item, e), title: SDKUI_Localizator.Delete || 'Delete', "aria-label": "Delete item", children: _jsx(IconDelete, { fontSize: 16 }) }))] }, item.value))), allowEdit && (_jsxs(AddButton, { onClick: handleCreateNew, children: ["+ ", SDKUI_Localizator.NewMale] }))] }), _jsx(TMDataListItemEditor, { isOpen: showEditDialog, item: editingItem, isCreating: isCreating, onClose: handleCloseDialog, onSave: handleSave })] }));
 };
 export default TMDataListItemPicker;