@topconsultnpm/sdkui-react 6.22.0-dev3.3 → 6.22.0-dev3.31

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

@@ -29,13 +29,19 @@ interface ITMTreeViewProps {
     showLoadMoreButton?: boolean;
     enableVirtualization?: boolean;
 }
-declare const TMTreeView: ({ dataSource, focusedItem, selectedItems, allowMultipleSelection, onDataChanged, calculateItemsForNode, itemRender, onNodeUpdate, onFocusedItemChanged, onSelectionChanged, shouldDelayFocusOnEvent, onItemContextMenu, autoSelectChildren, itemsPerPage, showLoadMoreButton, enableVirtualization }: ITMTreeViewProps) => import("react/jsx-runtime").JSX.Element;
+declare const TMTreeView: ({ dataSource, focusedItem, selectedItems, allowMultipleSelection, onDataChanged, calculateItemsForNode, itemRender, onNodeUpdate, onFocusedItemChanged, onSelectionChanged, shouldDelayFocusOnEvent, onItemContextMenu, autoSelectChildren, itemsPerPage, showLoadMoreButton, enableVirtualization }: ITMTreeViewProps) => React.JSX.Element;
 export default TMTreeView;
-export declare const StyledTreeContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
-export declare const StyledItemContent: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
-export declare const StyledTreeNode: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$isSelected"> & {
+export declare const StyledTreeContainer: import("styled-components/dist/types").IStyledComponentBase<"web", Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "style"> & {
+    style?: React.CSSProperties | import("styled-components/dist/types").CSSPropertiesWithVars | undefined;
+}> & string;
+export declare const StyledItemContent: import("styled-components/dist/types").IStyledComponentBase<"web", Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "style"> & {
+    style?: React.CSSProperties | import("styled-components/dist/types").CSSPropertiesWithVars | undefined;
+}> & string;
+export declare const StyledTreeNode: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Merged<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "style"> & {
+    style?: React.CSSProperties | import("styled-components/dist/types").CSSPropertiesWithVars | undefined;
+}, {
     $isSelected?: boolean;
-}, never> & Partial<Pick<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$isSelected"> & {
-    $isSelected?: boolean;
-}, never>>> & string;
-export declare const StyledStickyPaginator: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
+}>> & string;
+export declare const StyledStickyPaginator: import("styled-components/dist/types").IStyledComponentBase<"web", Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "style"> & {
+    style?: React.CSSProperties | import("styled-components/dist/types").CSSPropertiesWithVars | undefined;
+}> & string;

package/lib/components/base/TMTreeView.js

@@ -4,6 +4,17 @@ import { List } from 'react-window';
 import styled from 'styled-components';
 import { IconArrowLeft, IconArrowRight, IconChevronDown, IconChevronRight, SDKUI_Localizator } from '../../helper';
 import TMButton from './TMButton';
+// Campi in cui frecce, +, - e spazio servono alla digitazione (checkbox e bottoni esclusi)
+const NON_TEXT_INPUT_TYPES = new Set(['checkbox', 'radio', 'button', 'submit', 'reset', 'image', 'file', 'color', 'range']);
+const isEditableElement = (el) => {
+    if (el.isContentEditable)
+        return true;
+    if (el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement)
+        return true;
+    if (el instanceof HTMLInputElement)
+        return !NON_TEXT_INPUT_TYPES.has(el.type);
+    return false;
+};
 // Componente riga virtualizzata memoizzato
 const VirtualRowComponent = memo(({ ariaAttributes, index, style, flattenedItems, focusedItemKey, selectedItemKeys, allowMultipleSelection, hasVisibleItems, handleNodeToggle, handleNodeClick, handleCheckboxChange, hasPartialChildSelection, itemRender, onItemContextMenu }) => {
     const item = flattenedItems[index];
@@ -147,15 +158,26 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
             return [];
         return flattenTreeWithDepth(dataSource);
     }, [enableVirtualization, dataSource, flattenTreeWithDepth]);
+    // Chiave dell'ultimo elemento verso cui si è effettivamente scrollato.
+    // Evita di ripetere lo scroll quando cambia solo la struttura dell'albero
+    // (es. espansione di un nodo) a parità di elemento focalizzato.
+    const lastScrolledKeyRef = useRef(undefined);
     // Scroll verso l'elemento focalizzato quando cambia (navigazione con frecce)
     useEffect(() => {
-        if (!focusedItem?.key)
+        if (!focusedItem?.key) {
+            lastScrolledKeyRef.current = undefined;
+            return;
+        }
+        // Focus invariato: l'effect è stato rieseguito solo perché l'albero è cambiato
+        // (espansione/collasso di un nodo). La posizione di scroll non va toccata.
+        if (lastScrolledKeyRef.current === focusedItem.key)
             return;
         if (enableVirtualization) {
             // Lista virtualizzata: usa scrollToRow per garantire che l'elemento sia visibile
             const index = flattenedItems.findIndex(item => item.node.key === focusedItem.key);
             if (index >= 0 && listRef.current) {
                 listRef.current.scrollToRow({ index, align: 'smart' });
+                lastScrolledKeyRef.current = focusedItem.key;
             }
         }
         else {
@@ -164,6 +186,7 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
                 const element = containerRef.current.querySelector(`[data-node-key="${focusedItem.key}"]`);
                 if (element) {
                     element.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+                    lastScrolledKeyRef.current = focusedItem.key;
                 }
             }
         }
@@ -172,6 +195,9 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
         const handleKeyDown = (event) => {
             if (!focusedItem)
                 return;
+            // Non rubare i tasti ai campi editabili (es. input di un pannello sovrapposto)
+            if (event.target instanceof HTMLElement && isEditableElement(event.target))
+                return;
             let newFocusedItem = null;
             let handled = false;
             switch (event.key) {
@@ -447,6 +473,12 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
         return selectedCount > 0 && selectedCount < childKeys.length;
     }, [flattenTree]);
     const hasVisibleItems = useCallback((node) => {
+        // Nodo già caricato: conta i figli visibili (isExpandible è solo una stima a priori)
+        if (node.isLoaded) {
+            if (!node.items)
+                return false;
+            return node.items.filter(o => !o.hidden).length > 0;
+        }
         // If node has explicit isExpandible value, use that
         if (node.isExpandible !== undefined) {
             return node.isExpandible;

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

@@ -1,8 +1,9 @@
+import React from 'react';
 interface TMUserAvatarProps {
     displayName: string;
     nameForColorCalculation: string;
     tooltipName?: string;
     returnType?: 'jsx' | 'svg';
 }
-declare const TMUserAvatar: (props: TMUserAvatarProps) => string | import("react/jsx-runtime").JSX.Element;
+declare const TMUserAvatar: (props: TMUserAvatarProps) => string | React.JSX.Element;
 export default TMUserAvatar;

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

@@ -1,5 +1,6 @@
+import React from 'react';
 import { ValidationItem } from '@topconsultnpm/sdk-ts';
 declare const TMVilViewer: ({ vil }: {
     vil?: ValidationItem[];
-}) => import("react/jsx-runtime").JSX.Element | null;
+}) => React.JSX.Element | null;
 export default TMVilViewer;

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

@@ -1,3 +1,4 @@
+import React from 'react';
 import { ITMLayoutContainerProps } from './TMLayout';
 interface ITMWaitPanelProps {
     title?: string;
@@ -14,7 +15,7 @@ interface ITMWaitPanelProps {
     onAbortClick?: (abortController: AbortController | undefined) => void;
     useHighZIndex?: boolean;
 }
-export declare const TMWaitPanel: (props: ITMWaitPanelProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TMWaitPanel: (props: ITMWaitPanelProps) => React.JSX.Element;
 interface ITMLayoutWaitingContainerProps extends ITMLayoutContainerProps {
     showWaitPanel?: boolean;
     waitPanelTitle?: string;
@@ -30,5 +31,5 @@ interface ITMLayoutWaitingContainerProps extends ITMLayoutContainerProps {
     abortController?: AbortController;
     usePortal?: boolean;
 }
-export declare const TMLayoutWaitingContainer: ({ showWaitPanel, showWaitPanelPrimary, showWaitPanelSecondary, waitPanelTitle, waitPanelTextSecondary, waitPanelValueSecondary, waitPanelMaxValueSecondary, waitPanelTextPrimary, waitPanelValuePrimary, waitPanelMaxValuePrimary, isCancelable, abortController, usePortal, gap, onClick, justifyContent, alignItems, children, direction }: ITMLayoutWaitingContainerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TMLayoutWaitingContainer: ({ showWaitPanel, showWaitPanelPrimary, showWaitPanelSecondary, waitPanelTitle, waitPanelTextSecondary, waitPanelValueSecondary, waitPanelMaxValueSecondary, waitPanelTextPrimary, waitPanelValuePrimary, waitPanelMaxValuePrimary, isCancelable, abortController, usePortal, gap, onClick, justifyContent, alignItems, children, direction }: ITMLayoutWaitingContainerProps) => React.JSX.Element;
 export {};

package/lib/components/base/TMWaitPanel.js

@@ -34,7 +34,7 @@ const StyledTitle = styled.h2 ` margin: 0; font-size: 1.5em; color: #333; `;
 const StyledProgressBarContainer = styled.div ` width: 100%; height: 20px; background: #e0e0e0; border-radius: 10px; overflow: hidden; margin: 20px 0; `;
 const StyledProgressBar = styled.div ` height: 100%; background: #4caf50; transition: width 0.3s ease; `;
 const StyledProgressText = styled.p ` font-weight: bold; color: #333; margin: 0; `;
-const StyledMessage = styled.p ` color: #666; font-size: 0.9em; margin-top: 10px; `;
+const StyledMessage = styled.p ` color: #666; font-size: 0.9em; margin-top: 10px; white-space: pre-line; `;
 const StyledAbortButton = styled.button ` background: #ff4d4d; color: white; border: none; border-radius: 5px; padding: 10px 20px; font-size: 1em; cursor: pointer; margin-top: 20px; &:hover { background: #ff6666; } `;
 export const TMWaitPanel = (props) => {
     const { title, showPrimary, textPrimary, valuePrimary, maxValuePrimary, showSecondary, textSecondary, valueSecondary, maxValueSecondary, isCancelable, abortController, onAbortClick, useHighZIndex } = props;

package/lib/components/base/waitPanel/TMWaitPanelConfirm.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export interface ITMWaitPanelConfirmProps {
+    /** Deve stare sopra l'overlay del pannello: il manager passa il suo z-index + 1. */
+    zIndex?: number;
+    /** Conferma: l'operazione va interrotta. */
+    onYes?: () => void;
+    /** Annulla: l'operazione riprende. Usata anche dalla X. */
+    onNo?: () => void;
+}
+/** Il ref punta all'overlay, che il manager mostra e nasconde via `style.display`. */
+declare const TMWaitPanelConfirm: React.ForwardRefExoticComponent<ITMWaitPanelConfirmProps & React.RefAttributes<HTMLDivElement>>;
+export default TMWaitPanelConfirm;

package/lib/components/base/waitPanel/TMWaitPanelConfirm.js

@@ -0,0 +1,185 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef, useRef } from 'react';
+import styled, { keyframes } from 'styled-components';
+import toppy from '../../../assets/Toppy-generico.png';
+import { AppModules, SDK_Globals } from '@topconsultnpm/sdk-ts';
+import { getAppModuleGradient, SDKUI_Localizator } from '../../../helper';
+/** Modale di conferma dell'interruzione, sopra al wait panel: non usa TMMessageBox perche' deve stare sopra gli overlay DevExtreme. */
+/** Gradiente dell'applicazione per la barra del titolo. SDK_Globals.tmSession lancia senza sessione. */
+const getTitleBarGradient = () => {
+    let appModuleID = AppModules.SURFER;
+    try {
+        appModuleID = SDK_Globals.tmSession?.SessionDescr?.appModuleID ?? AppModules.SURFER;
+    }
+    catch { /* nessuna sessione: resta il default */ }
+    return getAppModuleGradient(appModuleID);
+};
+const fadeIn = keyframes `
+    from { opacity: 0; }
+    to   { opacity: 1; }
+`;
+const StyledConfirmOverlay = styled.div `
+    display: none;
+    position: fixed;
+    inset: 0;
+    z-index: ${props => props.$zIndex};
+    align-items: center;
+    justify-content: center;
+
+    &::before {
+        content: '';
+        position: absolute;
+        inset: 0;
+        background-color: rgba(17, 24, 39, 0.35);
+        animation: ${fadeIn} 120ms ease-out;
+    }
+`;
+const StyledConfirmCard = styled.div `
+    position: relative;
+    display: flex;
+    flex-direction: column;
+    width: 420px;
+    max-width: calc(100% - 24px);
+    max-height: calc(100% - 24px);
+    overflow-y: auto;
+    box-sizing: border-box;
+    background: #ffffff;
+    border-radius: 16px;
+    box-shadow: 0 18px 48px rgba(16, 24, 40, 0.28);
+    overflow: hidden; /* tiene la barra del titolo dentro il raggio della card */
+    font-family: inherit;
+`;
+const StyledTitleBar = styled.div `
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    padding: 6px 8px 6px 14px;
+    background: ${props => props.$gradient};
+    color: #ffffff;
+    cursor: move;
+    user-select: none;
+    touch-action: none; /* necessario perche' i pointer event di drag arrivino su touch */
+`;
+const StyledTitle = styled.div `
+    font-size: 14px;
+    font-weight: 600;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+`;
+const StyledCloseButton = styled.button `
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 26px;
+    height: 26px;
+    flex: 0 0 auto;
+    padding: 0;
+    border: none;
+    border-radius: 6px;
+    background: transparent;
+    color: inherit;
+    cursor: pointer;
+
+    &:hover { background: rgba(255, 255, 255, 0.18); }
+    &:active { background: rgba(255, 255, 255, 0.28); }
+`;
+const StyledBody = styled.div `
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 16px;
+    padding: 20px 24px 0 24px;
+`;
+const StyledToppyClip = styled.div `
+    height: 61px;
+    width: 68px;
+    overflow: hidden;
+    flex: 0 0 auto;
+`;
+const StyledToppy = styled.img `
+    display: block;
+    width: 68px;
+    height: 79px;
+    user-select: none;
+    -webkit-user-drag: none;
+`;
+const StyledQuestion = styled.div `
+    flex: 1;
+    min-width: 0;
+    font-size: 17px;
+    font-weight: 600;
+    color: #1f2937;
+    line-height: 1.3;
+    overflow-wrap: anywhere;
+`;
+const StyledFooter = styled.div `
+    display: flex;
+    flex-direction: row;
+    justify-content: flex-end;
+    gap: 10px;
+    padding: 18px 24px;
+`;
+const StyledButton = styled.button `
+    min-width: 92px;
+    padding: 9px 18px;
+    border-radius: 10px;
+    font-size: 13px;
+    font-family: inherit;
+    cursor: pointer;
+    transition: background-color 120ms ease, border-color 120ms ease;
+
+    border: 1px solid ${props => (props.$primary ? '#b3172f' : '#d5dbe5')};
+    background: ${props => (props.$primary ? '#c81e39' : '#ffffff')};
+    color: ${props => (props.$primary ? '#ffffff' : '#374151')};
+
+    &:hover { background: ${props => (props.$primary ? '#b3172f' : '#f3f5f9')}; }
+    &:active { transform: translateY(1px); }
+`;
+const IconClose = () => (_jsxs("svg", { width: '15', height: '15', viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: '2.4', strokeLinecap: 'round', children: [_jsx("line", { x1: '18', y1: '6', x2: '6', y2: '18' }), _jsx("line", { x1: '6', y1: '6', x2: '18', y2: '18' })] }));
+/** Il ref punta all'overlay, che il manager mostra e nasconde via `style.display`. */
+const TMWaitPanelConfirm = forwardRef(({ zIndex = 2147483602, onYes, onNo }, ref) => {
+    const cardRef = useRef(null);
+    // Scostamento fra il puntatore e l'angolo della card, fissato al primo pointerdown.
+    const grabRef = useRef(null);
+    const handlePointerDown = (e) => {
+        const card = cardRef.current;
+        if (!card || e.button !== 0)
+            return;
+        // Niente drag dalla X: con la pointer capture il click finirebbe sulla barra e non sul bottone.
+        if (e.target.closest('button'))
+            return;
+        // La card nasce centrata dal flex: al primo drag passo a coordinate esplicite.
+        const rect = card.getBoundingClientRect();
+        card.style.position = 'absolute';
+        card.style.margin = '0';
+        // Pixel interi: una posizione frazionaria fa ricampionare Toppy e lo sgrana.
+        card.style.left = `${Math.round(rect.left)}px`;
+        card.style.top = `${Math.round(rect.top)}px`;
+        grabRef.current = { dx: e.clientX - rect.left, dy: e.clientY - rect.top };
+        e.currentTarget.setPointerCapture(e.pointerId);
+    };
+    const handlePointerMove = (e) => {
+        const grab = grabRef.current;
+        const card = cardRef.current;
+        if (!grab || !card)
+            return;
+        // Clamp al viewport: una volta uscita non si riuscirebbe piu' ad afferrarla.
+        const maxLeft = Math.max(0, window.innerWidth - card.offsetWidth);
+        const maxTop = Math.max(0, window.innerHeight - card.offsetHeight);
+        card.style.left = `${Math.round(Math.min(Math.max(0, e.clientX - grab.dx), maxLeft))}px`;
+        card.style.top = `${Math.round(Math.min(Math.max(0, e.clientY - grab.dy), maxTop))}px`;
+    };
+    const handlePointerUp = (e) => {
+        if (!grabRef.current)
+            return;
+        grabRef.current = null;
+        if (e.currentTarget.hasPointerCapture(e.pointerId))
+            e.currentTarget.releasePointerCapture(e.pointerId);
+    };
+    return (_jsx(StyledConfirmOverlay, { ref: ref, $zIndex: zIndex, children: _jsxs(StyledConfirmCard, { ref: cardRef, role: 'alertdialog', children: [_jsxs(StyledTitleBar, { $gradient: getTitleBarGradient(), onPointerDown: handlePointerDown, onPointerMove: handlePointerMove, onPointerUp: handlePointerUp, onPointerCancel: handlePointerUp, children: [_jsx(StyledTitle, { children: SDKUI_Localizator.Abort }), _jsx(StyledCloseButton, { type: 'button', "aria-label": SDKUI_Localizator.No, onClick: onNo, children: _jsx(IconClose, {}) })] }), _jsxs(StyledBody, { children: [_jsx(StyledToppyClip, { children: _jsx(StyledToppy, { src: toppy, alt: '', draggable: false }) }), _jsx(StyledQuestion, { children: SDKUI_Localizator.Abort_Confirm })] }), _jsxs(StyledFooter, { children: [_jsx(StyledButton, { type: 'button', $primary: true, onClick: onYes, children: SDKUI_Localizator.Yes }), _jsx(StyledButton, { type: 'button', onClick: onNo, children: SDKUI_Localizator.No })] })] }) }));
+});
+TMWaitPanelConfirm.displayName = 'TMWaitPanelConfirm';
+export default TMWaitPanelConfirm;

package/lib/components/base/waitPanel/TMWaitPanelManager.d.ts

@@ -0,0 +1,169 @@
+/** Wait panel imperativo ad alte prestazioni. */
+export interface ITMWaitPanelOptions {
+    /** Titolo mostrato in alto. */
+    title?: string;
+    /** Totale degli elementi da elaborare. Puo' essere impostato dopo con `setMax()`. */
+    max?: number;
+    /** Sottotitolo statico, usato quando non e' valorizzato `subtitleTemplate`. */
+    subtitle?: string;
+    /** Template del sottotitolo: `{{0}}` = elemento corrente, `{{1}}` = totale. */
+    subtitleTemplate?: string;
+    /** Mostra il bottone di interruzione (e abilita ESC). */
+    cancelable?: boolean;
+    /** Mostra la riga "trascorsi / rimanenti". Default: true. */
+    showEta?: boolean;
+    /** Mostra le tre pill numeriche ok / warning / error, sempre visibili anche a 0. Default: true. */
+    showCounters?: boolean;
+    /** Riserva la seconda barra, quella dell'operazione di dettaglio */
+    showSecondary?: boolean;
+    /** Testo iniziale della barra secondaria. */
+    secondaryText?: string;
+    /** Didascalie fisse sopra le due barre, es. "Documenti" e "File corrente". Omesse: nessuna riga. */
+    primaryLabel?: string;
+    secondaryLabel?: string;
+    /** Invocato quando l'utente interrompe */
+    onAbort?: () => void;
+}
+export interface ITMWaitPanelCounters {
+    ok: number;
+    warning: number;
+    error: number;
+}
+export interface ITMWaitPanelUpdate {
+    title?: string;
+    subtitle?: string;
+    value?: number;
+    max?: number;
+    ok?: number;
+    warning?: number;
+    error?: number;
+}
+/** Aggiornamento della barra secondaria: i campi omessi restano invariati. */
+export interface ITMWaitPanelSecondaryUpdate {
+    value?: number;
+    max?: number;
+    text?: string;
+}
+export interface ITMWaitPanelHandle {
+    /** True quando l'utente ha interrotto l'operazione. */
+    readonly aborted: boolean;
+    /** AbortController del pannello, da passare alle chiamate annullabili. */
+    readonly abortController: AbortController;
+    readonly signal: AbortSignal;
+    readonly value: number;
+    readonly max: number;
+    readonly counters: ITMWaitPanelCounters;
+    readonly isOpen: boolean;
+    /** True mentre e' aperta la richiesta di conferma dell'interruzione. */
+    readonly paused: boolean;
+    /** Avanza il contatore (default +1). Da attendere con `await`: resta pendente durante la conferma di interruzione. */
+    step(delta?: number): Promise<void>;
+    /** Come il gate di `step()`, per chi deve attendere la pausa senza avanzare. */
+    waitWhilePaused(): Promise<void>;
+    setValue(value: number): void;
+    setMax(max: number): void;
+    setTitle(title: string): void;
+    /** Sottotitolo esplicito: sovrascrive `subtitleTemplate`. `undefined` ripristina il template. */
+    setSubtitle(subtitle: string | undefined): void;
+    /** Incrementa il contatore verde (default +1). */
+    ok(delta?: number): void;
+    /** Incrementa il contatore giallo (default +1). */
+    warning(delta?: number): void;
+    /** Incrementa il contatore rosso (default +1). */
+    error(delta?: number): void;
+    /** Aggiornamento cumulativo: i contatori qui sono valori assoluti, non incrementi. */
+    update(patch: ITMWaitPanelUpdate): void;
+    /** Aggiorna la barra secondaria. Senza `showSecondary` non ha effetto. */
+    setSecondary(patch: ITMWaitPanelSecondaryUpdate): void;
+    close(): void;
+}
+declare class TMWaitPanelInstance implements ITMWaitPanelHandle {
+    readonly abortController: AbortController;
+    private readonly options;
+    private readonly container;
+    private readonly root;
+    private nodes;
+    private closed;
+    private readonly elapsedLabel;
+    private readonly remainingLabel;
+    private _paused;
+    private pauseGate;
+    private resolvePauseGate;
+    private pausedTotalMs;
+    private pauseStartedAt;
+    private readonly startTime;
+    private rafId;
+    private tickerId;
+    private _value;
+    private _max;
+    private _ok;
+    private _warning;
+    private _error;
+    private _title;
+    private _subtitleOverride;
+    private _secondaryValue;
+    private _secondaryMax;
+    private _secondaryText;
+    private lastPercentText;
+    private lastSubtitleText;
+    private lastElapsedText;
+    private lastRemainingText;
+    private lastOk;
+    private lastWarning;
+    private lastError;
+    private lastTitleText;
+    private lastSecondaryPercentText;
+    private lastSecondaryText;
+    constructor(options: ITMWaitPanelOptions, zIndex: number);
+    get aborted(): boolean;
+    get signal(): AbortSignal;
+    get value(): number;
+    get max(): number;
+    get counters(): ITMWaitPanelCounters;
+    get isOpen(): boolean;
+    get paused(): boolean;
+    waitWhilePaused: () => Promise<void>;
+    step: (delta?: number) => Promise<void>;
+    setValue: (value: number) => void;
+    setMax: (max: number) => void;
+    setTitle: (title: string) => void;
+    setSubtitle: (subtitle: string | undefined) => void;
+    ok: (delta?: number) => void;
+    warning: (delta?: number) => void;
+    error: (delta?: number) => void;
+    setSecondary: (patch: ITMWaitPanelSecondaryUpdate) => void;
+    update: (patch: ITMWaitPanelUpdate) => void;
+    close: () => void;
+    private handleMount;
+    private handleKeyDown;
+    /** Interrompi non annulla subito: mette in pausa il loop e chiede conferma. */
+    private handleAbort;
+    /** Risposta Si: interrompe davvero e lascia ripartire il loop, che uscira' subito. */
+    private confirmAbort;
+    private pause;
+    /** Risposta No, oppure chiusura del pannello: sblocca il loop e riprende. */
+    private resume;
+    private computeSubtitle;
+    /** Programma al massimo un flush per frame. E' l'unico costo pagato da `step()`. */
+    private schedule;
+    /** Riversa sul DOM lo stato corrente (barra, percentuale, testi, contatori), saltando cio' che non e' cambiato. */
+    private flush;
+    /** Riversa sul DOM la seconda barra. Invocata solo quando la view l'ha renderizzata. */
+    private flushSecondary;
+    /** Aggiorna la riga dei tempi: trascorso al netto delle pause e stima del rimanente. */
+    private flushEta;
+}
+export declare class TMWaitPanelManager {
+    private static _panels;
+    /** Apre un wait panel e restituisce l'handle con cui pilotarlo. */
+    static show(options?: ITMWaitPanelOptions): ITMWaitPanelHandle;
+    /** Pannello aperto piu' recente, se presente. */
+    static get current(): ITMWaitPanelHandle | undefined;
+    /** True finche' almeno un wait panel e' aperto: flag "operazione massiva in corso" per i refresh periodici. */
+    static get isBusy(): boolean;
+    /** Chiude tutti i pannelli aperti (rete di sicurezza in caso di unmount della pagina). */
+    static closeAll(): void;
+    /** @internal */
+    static _unregister(panel: TMWaitPanelInstance): void;
+}
+export default TMWaitPanelManager;