uni-manager 0.0.79 → 0.1.1

package/fesm2022/uni-manager.mjs

@@ -1,7 +1,7 @@
 import { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';
 import { map } from 'rxjs/internal/operators/map';
 import { tap } from 'rxjs/internal/operators/tap';
-import { isHttpErrorBody, UniHttpError } from 'uni-error';
+import { UniToastManager as UniToastManager$1 } from 'uni-manager/toast';
 import isEqual from 'lodash-es/isEqual';
 import { defer } from 'rxjs/internal/observable/defer';
 import { from } from 'rxjs/internal/observable/from';
@@ -9,6 +9,7 @@ import { timer } from 'rxjs/internal/observable/timer';
 import { catchError } from 'rxjs/internal/operators/catchError';
 import { distinctUntilChanged } from 'rxjs/internal/operators/distinctUntilChanged';
 import { finalize } from 'rxjs/internal/operators/finalize';
+import { UniErrorManager as UniErrorManager$1 } from 'uni-manager/error';
 import { EMPTY } from 'rxjs/internal/observable/empty';
 import { of } from 'rxjs/internal/observable/of';
 import { throwError } from 'rxjs/internal/observable/throwError';
@@ -16,6 +17,9 @@ import { concatMap } from 'rxjs/internal/operators/concatMap';
 import { exhaustMap } from 'rxjs/internal/operators/exhaustMap';
 import { mergeMap } from 'rxjs/internal/operators/mergeMap';
 import { switchMap } from 'rxjs/internal/operators/switchMap';
+import { UniHttpError, isHttpErrorBody } from 'uni-error/http';
+import { UniTypeDateManager as UniTypeDateManager$1 } from 'uni-manager/type';
+import { UniLocaleManager as UniLocaleManager$1 } from 'uni-manager/locale';
 
 class UniErrorManager {
     /* ------------------------------------------------------------------------------- */
@@ -184,401 +188,6 @@ var EmitValueMode;
     EmitValueMode[EmitValueMode["EVERY_TIME"] = 1] = "EVERY_TIME";
 })(EmitValueMode || (EmitValueMode = {}));
 
-class UniLocaleManager {
-    /* ------------------------------------------------------------------------------- */
-    /* ----------------------------------- Config ------------------------------------ */
-    /* ------------------------------------------------------------------------------- */
-    /** Codice lingua corrente (es. 'it-IT', 'en-US') usato per formattare date e numeri */
-    static { this._locale = navigator.language ?? 'en-US'; }
-    /** Elenco dei codici lingua supportati dall'applicazione (es. ['it-IT', 'en-US']) */
-    static { this._localesSupported = []; }
-    /** Prefisso globale applicato a tutte le chiavi di traduzione (es. 'APP_') */
-    static { this._prefix = undefined; }
-    /* ------------------------------------------------------------------------------- */
-    /* --------------------------------- Metodi: get --------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /** Restituisce il codice lingua corrente */
-    static get locale() {
-        return this._locale;
-    }
-    /** Restituisce l'array contenente tutti i codici locale supportati.*/
-    static get localesSupported() {
-        return this._localesSupported;
-    }
-    /** Restituisce solo la lingua (es. 'it') */
-    static get language() {
-        return this._locale.split('-')[0];
-    }
-    /** Restituisce solo il paese (es. 'IT') */
-    static get region() {
-        const parts = this._locale.split('-');
-        return parts.length > 1 ? parts[1] : '';
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* ------------------------------------ Store ------------------------------------ */
-    /* ------------------------------------------------------------------------------- */
-    /** Store privato (Subject) */
-    static { this.store = new BehaviorSubject({}); }
-    /** Store pubblico (Observable) */
-    static { this.store$ = this.store.asObservable(); }
-    /** Ottiene il dizionario attuale senza sottoscrizione */
-    static get currentValue() {
-        return this.store.getValue();
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* -------------------------------- Metodi: setup -------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /**
-     * Inizializza la configurazione di rete del manager.
-     * Deve essere chiamato prima di effettuare qualsiasi richiesta HTTP.
-     */
-    static setup(locale, prefix) {
-        this._locale = locale ?? 'en-US';
-        this._prefix = prefix;
-    }
-    /** Imposta l'elenco dei codici lingua supportati dall'applicazione */
-    static setLocalesSupported(locales) {
-        this._localesSupported = locales ?? [];
-    }
-    /**
-     * Aggiorna lo store locale con il dizionario delle traduzioni fornito.
-     * Se viene passato undefined, lo store viene inizializzato come oggetto vuoto.
-     */
-    static setTranslations(translations) {
-        this.store.next(translations ?? {});
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* ----------------------------- Metodi: traduzioni ------------------------------ */
-    /* ------------------------------------------------------------------------------- */
-    /**
-     * Traduce una label in base al dizionario caricato.
-     * Gestisce la composizione della chiave, i parametri dinamici (interpolazione) e il fallback.
-     */
-    static translate(key, prefix = 'lbl', interpolationParams) {
-        if (!key)
-            return '-';
-        // Costruzione chiave: prefissoGlobale + prefissoLocale + LabelConInizialeMaiuscola
-        const keyParts = key.trim().split(/(?=[A-Z])/);
-        const rootKeyParts = keyParts.filter((p) => p.toLowerCase() !== prefix.toLowerCase());
-        const cleanKey = rootKeyParts.length > 0 ? rootKeyParts.join('') : undefined;
-        const capitalizedKey = cleanKey ? cleanKey.charAt(0).toUpperCase() + cleanKey.slice(1) : '';
-        const finalKey = `${this._prefix ?? ''}${prefix}${capitalizedKey}`;
-        // Cerca la chiave in minuscolo (standardizzazione)
-        let translation = this.currentValue?.[finalKey.toLowerCase()];
-        // Log e fallback se la traduzione manca
-        if (!translation) {
-            console.warn(`Translation missing for key: ${finalKey}`);
-            return `🔑 ${finalKey}`;
-        }
-        // Interpolazione variabili
-        if (interpolationParams) {
-            for (const [key, value] of Object.entries(interpolationParams)) {
-                const displayValue = value instanceof Date ? value.toLocaleDateString(this._locale) : String(value);
-                translation = translation.replaceAll(`{{${key}}}`, displayValue);
-            }
-        }
-        return translation;
-    }
-    /**
-     * Traduce una stringa che contiene parametri separati da un carattere specifico.
-     * Supporta ora un numero arbitrario di parametri in formato "label/param1/param2"
-     * o semplicemente "label".
-     */
-    static translateInlineParams(keyWithParams, splitChar) {
-        if (!keyWithParams)
-            return '-';
-        const [label, ...params] = keyWithParams.split(splitChar);
-        // Se non ci sono parametri, esegui una traduzione semplice
-        if (params.length === 0) {
-            return this.translate(label);
-        }
-        // Mappa i parametri in un oggetto di interpolazione: { inlineParam0: val, inlineParam1: val, ... }
-        const interpolationParameters = {};
-        for (const [index, val] of params.entries()) {
-            interpolationParameters[`param${index}`] = val;
-        }
-        return this.translate(label, 'lbl', interpolationParameters);
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* ------------------------------- Metodi: numeri -------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /**
-     * Converte un valore numerico in una stringa formattata secondo il locale impostato.
-     * Disabilita i separatori delle migliaia e forza un numero fisso di decimali.
-     */
-    static toStringNumber(value, decimal) {
-        return new Intl.NumberFormat(this._locale, {
-            useGrouping: true,
-            minimumFractionDigits: decimal,
-            maximumFractionDigits: decimal,
-            numberingSystem: 'latn',
-        }).format(value);
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* -------------------------------- Metodi: date --------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /**
-     * Formatta una data o una stringa in base al locale corrente.
-     * Gestisce tre modalità predefinite (date, time, full) e accetta opzioni personalizzate Intl.
-     */
-    static toDate(date, mode = 'full', force) {
-        const dt = new Date(date);
-        // Controllo: validità data
-        if (Number.isNaN(dt.getTime())) {
-            console.error(`[UniLocaleManager] Data non valida fornita a formatDateTime:`, date);
-            return '';
-        }
-        // Controllo: locale da forzare
-        const locale = force && this._locale.startsWith(force.oldLang) ? force.newLocale : this._locale;
-        switch (mode) {
-            case 'date': {
-                return dt.toLocaleDateString(locale);
-            }
-            case 'time': {
-                return dt.toLocaleTimeString(locale);
-            }
-            case 'full': {
-                return dt.toLocaleString(locale);
-            }
-        }
-    }
-}
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-class UniToastManager {
-    /* ------------------------------------------------------------------------------- */
-    /* -------------------------------- Metodi: setup -------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /**
-     * Inizializza il manager con una serie di operazioni
-     */
-    static setup(operations) {
-        this.manager = operations;
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* -------------------------------- Metodi: show --------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /**
-     * Mostra un toast di successo basato su una risposta HTTP e una label di traduzione.
-     */
-    static show(config) {
-        /* Messaggio tradotto */
-        const msg = UniLocaleManager.translate(config.label, 'toast', config.params);
-        const msgFixed = `${config.prefix ?? ''}${msg}${config.suffix ?? ''}`;
-        this.manager[config.type ?? 'info'](msgFixed, config);
-    }
-    /**
-     * Mostra un toast di successo basato su una risposta HTTP e una label di traduzione.
-     */
-    static showHttp(config, res) {
-        const { interpolationParams, resParams, resLengthParam, formatters } = config;
-        /* Parametri statici di base */
-        const allParams = { ...interpolationParams };
-        /* Config parametri risposta: estrazione parametri dalla risposta (se esiste ed è un oggetto) */
-        if (resParams?.length && res && typeof res === 'object') {
-            for (const param of resParams ?? []) {
-                if (param in res)
-                    continue;
-                // Se esiste un formatter per questa chiave lo si usa, altrimenti valore grezzo
-                const rawValue = res[param];
-                allParams[param] = formatters?.[param] ? formatters[param](rawValue) : rawValue;
-            }
-        }
-        /* Config parametro lunghezza risposta: conteggio array */
-        if (resLengthParam && Array.isArray(res)) {
-            allParams[resLengthParam] = res.length;
-        }
-        /* Messaggio tradotto */
-        this.show({ ...config, params: allParams });
-    }
-}
-
-async function execute(url, init) {
-    try {
-        /* Esegue chiamata http */
-        const res = await fetch(url, init);
-        /* Nessun contenuto cons status 204 */
-        if (res.status === 204) {
-            return undefined;
-        }
-        /* Recupero se è un json */
-        const contentType = res.headers.get('content-type') ?? '';
-        const isJson = contentType.startsWith('application/json');
-        /* Errore HTTP (quindi risposta ricevuta ma non ok) */
-        if (!res.ok) {
-            let errorBody;
-            try {
-                /* Clona risposta solo se c'è errore, per leggerla senza consumare la originale */
-                const resClone = res.clone();
-                /* Aggiorna body con struttura errore */
-                errorBody = isJson ? await resClone.json() : await resClone.text();
-            }
-            catch {
-                errorBody = await res.text();
-            }
-            if (isHttpErrorBody(errorBody)) {
-                const type = errorBody.exceptionType.includes('HttpRequestException') ? 'be' : 'ice';
-                throw new UniHttpError(type, res.status, url, errorBody);
-            }
-            else {
-                const error = new Error(`HTTP ${res.statusText}`);
-                throw new UniHttpError('base', res.status, url, {
-                    exceptionMessage: error.message,
-                    exceptionType: 'ErrorBase',
-                    message: error.message,
-                    stackTrace: error.stack ?? '',
-                });
-            }
-        }
-        /* Risposta ok */
-        return res;
-    }
-    catch (error) {
-        if (error instanceof TypeError) {
-            throw new UniHttpError('network', -1, url, {
-                exceptionMessage: `${error.name}: ${error.message}\n${error.stack}`,
-                exceptionType: error.name,
-                message: error.message,
-                stackTrace: error.stack ?? '',
-            });
-        }
-        // Fallback
-        throw error;
-    }
-}
-async function executeHttp(url, init) {
-    /* Esegue la chiamata HTTP e restituisce il corpo decodificato come JSON */
-    const res = await execute(url, init);
-    if (!res)
-        return undefined;
-    /* Estrae il contenuto come testo */
-    const text = await res.text();
-    /* Controllo: se il testo è vuoto (''), ritorna undefined */
-    if (!text || text.trim().length === 0) {
-        return undefined;
-    }
-    /* Parsa manualmente il testo, dato che lo stream è stato già letto */
-    return JSON.parse(text);
-}
-async function executeBlob(url, init) {
-    /* Esegue la chiamata HTTP */
-    const res = await execute(url, init);
-    if (!res)
-        return undefined;
-    /* Estrae il contenuto come Blob direttamente */
-    const blob = await res.blob();
-    /* Controllo: se il blob è vuoto (0 byte), ritorna undefined */
-    if (blob.size === 0) {
-        return undefined;
-    }
-    /* Estrae il nome del file dall'header */
-    const disposition = res.headers.get('Content-Disposition');
-    let fileName = 'download.pdf'; // Fallback di default
-    if (disposition) {
-        const matches = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/.exec(disposition);
-        if (!!matches && matches[1]) {
-            fileName = matches[1].replaceAll(/['"]/g, '');
-        }
-    }
-    /* Genera l'URL temporaneo dal blob */
-    const fileUrl = URL.createObjectURL(blob);
-    return { url: fileUrl, name: fileName };
-}
-
-/**
- * Aggiunge una nuova ref nello store solo se non è già presente.
- * Se l'ID esiste già, l'operazione viene interrotta per preservare il dato originale.
- */
-function add(id, url, type) {
-    // Recupera l'ultimo stato (Map)
-    const oldMap = UniHttpManager.currentValue;
-    // Controllo: se è presente l'item allora termina
-    if (oldMap.get(id))
-        return;
-    // Crea il nuovo oggetto
-    const newItemMap = {
-        type,
-        lineId: undefined,
-        url,
-        hasError: false,
-        pendingCount: 0,
-    };
-    // Crea una nuova istanza della Map
-    const newMap = new Map(oldMap);
-    newMap.set(id, newItemMap);
-    // Aggiorna il nuovo stato notificando l'observer
-    UniHttpManager.store.next(newMap);
-}
-/**
- * Rimuove un http ref tramite ID
- */
-function remove(id) {
-    // Recupera l'ultimo stato (Map)
-    const oldMap = UniHttpManager.currentValue;
-    // Controllo: se non è presente l'item allora termina
-    if (!oldMap.has(id))
-        return;
-    // Aggiorna store
-    const newMap = new Map(oldMap);
-    newMap.delete(id);
-    UniHttpManager.store.next(newMap);
-}
-/**
- * Aggiorna il contatore delle chiamate pendenti per una specifica ref.
- * Incrementa o decrementa 'pendingCount' garantendo che non scenda mai sotto lo zero.
- * Se la ref non esiste, l'operazione viene ignorata.
- */
-function updateIsLoading(id, delta) {
-    // Recupera l'ultimo stato (Map)
-    const oldMap = UniHttpManager.currentValue;
-    // Controllo: se non è presente l'item allora termina
-    const oldItem = oldMap.get(id);
-    if (!oldItem)
-        return;
-    // Aggiorna l'oggetto
-    const newItemMap = {
-        ...oldItem,
-        pendingCount: Math.max(0, oldItem.pendingCount + delta),
-    };
-    // Crea una nuova istanza della Map
-    const newMap = new Map(oldMap);
-    newMap.set(id, newItemMap);
-    // Aggiorna il nuovo stato notificando l'observer
-    UniHttpManager.store.next(newMap);
-}
-/**
- * Aggiorna lo stato di errore per una specifica ref.
- * Se il valore di 'hasError' è identico a quello attuale o se la ref non esiste,
- * l'operazione viene interrotta per evitare aggiornamenti inutili.
- */
-function updateHasError(id, hasError) {
-    // Recupera l'ultimo stato (Map)
-    const oldMap = UniHttpManager.currentValue;
-    // Controllo: se non è presente l'item allora termina
-    const oldItem = oldMap.get(id);
-    if (!oldItem)
-        return;
-    // Controllo: se con lo stesso valore, salta
-    if (oldItem.hasError === hasError)
-        return;
-    // Aggiorna l'oggetto
-    const newItemMap = { ...oldItem, hasError };
-    // Crea una nuova istanza della Map
-    const newMap = new Map(oldMap);
-    newMap.set(id, newItemMap);
-    // Aggiorna il nuovo stato notificando l'observer
-    UniHttpManager.store.next(newMap);
-}
-/**
- * Svuota completamente la lista delle refs
- */
-function removeAll() {
-    // Crea una nuova istanza della Map
-    const newMap = new Map();
-    // Aggiorna il nuovo stato notificando l'observer
-    UniHttpManager.store.next(newMap);
-}
-
 function operatorHandler(operator) {
     // Gestione della concorrenza in base al parametro
     switch (operator) {
@@ -598,32 +207,36 @@ function operatorHandler(operator) {
 }
 function errorHandler(err, errorMode, ref) {
     // Controllo: sia effettivamente un errore di tipo 'UniHttpError'
-    if (!(err instanceof UniHttpError)) {
-        return throwError(() => err);
-    }
-    // Aggiorna la ref nella map
-    updateHasError(ref, true);
-    // Gestione dell'errore in base al parametro
-    switch (errorMode) {
-        case PollingErrorMode.IGNORE: {
-            return of();
-        }
-        case PollingErrorMode.SKIP: {
-            return EMPTY;
-        }
-        case PollingErrorMode.IGNORE_WITH_ERROR: {
-            {
-                UniErrorManager.add(ref, err);
+    if (err instanceof UniHttpError) {
+        switch (errorMode) {
+            case PollingErrorMode.IGNORE: {
                 return of();
             }
+            case PollingErrorMode.SKIP: {
+                return EMPTY;
+            }
+            case PollingErrorMode.IGNORE_WITH_ERROR: {
+                UniErrorManager$1.add(ref, err);
+                return of();
+            }
+            case PollingErrorMode.STOP: {
+                UniErrorManager$1.add(ref, err);
+                return throwError(() => err);
+            }
         }
-        case PollingErrorMode.STOP: {
-            UniErrorManager.add(ref, err);
-            return throwError(() => err);
-        }
+    }
+    else {
+        return throwError(() => err);
     }
 }
 
+/* ------------------------------------------------------------------------------- */
+/* -------------------------------- Funzioni Core RxJS  -------------------------- */
+/* ------------------------------------------------------------------------------- */
+/**
+ * Gestisce l'esecuzione e il ciclo di vita di una singola richiesta HTTP.
+ * Si occupa della registrazione della reference, della gestione dei loader, dei toast di successo e dell'intercettazione degli errori.
+ */
 function http$(url, refType, config, promiseFactory) {
     /* Recupero configurazione */
     const { ref, toast, hasLoader } = config;
@@ -645,10 +258,12 @@ function http$(url, refType, config, promiseFactory) {
             next: (res) => {
                 /* Mostra toast (se presente) */
                 if (toast) {
-                    UniToastManager.showHttp(toast, res);
+                    UniToastManager$1.showHttp(toast, res);
                 }
             },
         }), catchError((err) => {
+            // Aggiorna la ref nella map
+            updateHasError(ref, true);
             /* Gestione errore */
             return errorHandler(err, PollingErrorMode.STOP, ref);
         }), finalize(() => {
@@ -659,6 +274,10 @@ function http$(url, refType, config, promiseFactory) {
         }));
     });
 }
+/**
+ * Avvia e coordina un ciclo di polling a intervalli regolari.
+ * Gestisce la concorrenza tramite operatori RxJS configurabili, la rimozione dei popup, di errore nelle iterazioni successive e i comportamenti custom al primo avvio.
+ */
 function httpPolling$(url, config, promiseFactory) {
     /* Recupero configurazione */
     const { interval, ref, operator = MapOperator.SWITCH_MAP, errorMode = PollingErrorMode.STOP, emitValueMode = EmitValueMode.ON_NEW_DATA, firstIteration, } = config;
@@ -680,16 +299,18 @@ function httpPolling$(url, config, promiseFactory) {
         return defer(() => {
             const http$ = from(promiseFactory());
             return http$.pipe(tap((res) => {
-                /* Rimozione popup di errore nel caso di errorMode = 'IGNORE_WITH_ERROR' */
+                /* Meccanismo di ripristino automatico: se il polling torna in salute, cancella l'errore dallo store e nasconde i relativi messaggi a schermo */
                 if (errorMode === PollingErrorMode.IGNORE_WITH_ERROR) {
                     updateHasError(ref, false);
-                    UniErrorManager.remove(ref);
+                    UniErrorManager$1.remove(ref);
                 }
                 /* Prima risposta */
                 if (index === 0 && firstIteration?.toast) {
-                    UniToastManager.showHttp(firstIteration.toast, res);
+                    UniToastManager$1.showHttp(firstIteration.toast, res);
                 }
             }), catchError((err) => {
+                // Aggiorna la ref nella map
+                updateHasError(ref, true);
                 /* Gestione errore */
                 return errorHandler(err, errorMode, ref);
             }), finalize(() => {
@@ -704,164 +325,205 @@ function httpPolling$(url, config, promiseFactory) {
         ? source$.pipe(distinctUntilChanged((prev, cur) => isEqual(prev, cur)))
         : source$;
 }
-
+/* ------------------------------------------------------------------------------- */
+/* ------------------------------------ Utils ------------------------------------ */
+/* ------------------------------------------------------------------------------- */
 /**
- * Classe di utilità per la gestione e formattazione delle date.
- * Fornisce metodi per convertire in modo sicuro valori di tipo Date, stringa o null in formati standardizzati.
+ * Aggiunge una nuova ref nello store solo se non è già presente.
+ * Se l'ID esiste già, l'operazione viene interrotta per preservare il dato originale.
  */
-class UniTypeDateManager {
-    static toYYYYMMDD(date) {
-        if (!date)
-            return '';
-        const d = new Date(date);
-        if (Number.isNaN(d.getTime()))
-            return '';
-        const year = d.getFullYear();
-        const month = String(d.getMonth() + 1).padStart(2, '0');
-        const day = String(d.getDate()).padStart(2, '0');
-        return `${year}-${month}-${day}`;
-    }
+function add(id, url, type) {
+    // Recupera l'ultimo stato (Map)
+    const oldMap = UniHttpManager.currentValue;
+    // Controllo: se è presente l'item allora termina
+    if (oldMap.get(id))
+        return;
+    // Crea il nuovo oggetto
+    const newItemMap = {
+        type,
+        lineId: undefined,
+        url,
+        hasError: false,
+        pendingCount: 0,
+    };
+    // Crea una nuova istanza della Map
+    const newMap = new Map(oldMap);
+    newMap.set(id, newItemMap);
+    // Aggiorna il nuovo stato notificando l'observer
+    UniHttpManager.store.next(newMap);
 }
-
 /**
- * Utility per la gestione e formattazione di valori numerici.
+ * Rimuove un http ref tramite ID
  */
-class UniTypeNumberManager {
-    /** Applica il padding a un numero o una stringa */
-    static toPad(value, count, character = '0') {
-        // Se il valore è null/undefined, riempiamo l'intero campo con il carattere scelto
-        if (value === null || value === undefined) {
-            return ''.padStart(count, character);
+function remove(id) {
+    // Recupera l'ultimo stato (Map)
+    const oldMap = UniHttpManager.currentValue;
+    // Controllo: se non è presente l'item allora termina
+    if (!oldMap.has(id))
+        return;
+    // Aggiorna store
+    const newMap = new Map(oldMap);
+    newMap.delete(id);
+    UniHttpManager.store.next(newMap);
+}
+/**
+ * Aggiorna il contatore delle chiamate pendenti per una specifica ref.
+ * Incrementa o decrementa 'pendingCount' garantendo che non scenda mai sotto lo zero.
+ * Se la ref non esiste, l'operazione viene ignorata.
+ */
+function updateIsLoading(id, delta) {
+    // Recupera l'ultimo stato (Map)
+    const oldMap = UniHttpManager.currentValue;
+    // Controllo: se non è presente l'item allora termina
+    const oldItem = oldMap.get(id);
+    if (!oldItem)
+        return;
+    // Aggiorna l'oggetto
+    const newItemMap = {
+        ...oldItem,
+        pendingCount: Math.max(0, oldItem.pendingCount + delta),
+    };
+    // Crea una nuova istanza della Map
+    const newMap = new Map(oldMap);
+    newMap.set(id, newItemMap);
+    // Aggiorna il nuovo stato notificando l'observer
+    UniHttpManager.store.next(newMap);
+}
+/**
+ * Aggiorna lo stato di errore per una specifica ref.
+ * Se il valore di 'hasError' è identico a quello attuale o se la ref non esiste,
+ * l'operazione viene interrotta per evitare aggiornamenti inutili.
+ */
+function updateHasError(id, hasError) {
+    // Recupera l'ultimo stato (Map)
+    const oldMap = UniHttpManager.currentValue;
+    // Controllo: se non è presente l'item allora termina
+    const oldItem = oldMap.get(id);
+    if (!oldItem)
+        return;
+    // Controllo: se con lo stesso valore, salta
+    if (oldItem.hasError === hasError)
+        return;
+    // Aggiorna l'oggetto
+    const newItemMap = { ...oldItem, hasError };
+    // Crea una nuova istanza della Map
+    const newMap = new Map(oldMap);
+    newMap.set(id, newItemMap);
+    // Aggiorna il nuovo stato notificando l'observer
+    UniHttpManager.store.next(newMap);
+}
+
+async function execute(url, init) {
+    try {
+        /* Esegue chiamata http */
+        const res = await fetch(url, init);
+        /* Nessun contenuto cons status 204 */
+        if (res.status === 204) {
+            return undefined;
+        }
+        /* Risposta ok */
+        if (res.ok) {
+            return res;
+        }
+        /* Errore HTTP (quindi risposta ricevuta ma non ok) */
+        let errorBody;
+        try {
+            /* Clona risposta per leggerla senza consumare la originale */
+            const resClone = res.clone();
+            /* Recupero se è un json */
+            const contentType = res.headers.get('content-type') ?? '';
+            const isJson = contentType.startsWith('application/json');
+            /* Aggiorna body con struttura errore */
+            errorBody = isJson ? await resClone.json() : await resClone.text();
+        }
+        catch {
+            // Se il clone o il parsing falliscono, si usa una stringa di fallback sicura
+            errorBody = `Failed to parse error response body (Status: ${res.status})`;
+        }
+        if (isHttpErrorBody(errorBody)) {
+            const type = errorBody.exceptionType.includes('HttpRequestException') ? 'be' : 'ice';
+            throw new UniHttpError(type, res.status, url, errorBody);
+        }
+        else {
+            const error = new Error(`HTTP ${res.statusText}`);
+            throw new UniHttpError('base', res.status, url, {
+                exceptionMessage: error.message,
+                exceptionType: 'ErrorBase',
+                message: error.message,
+                stackTrace: error.stack ?? '',
+            });
         }
-        // Convertiamo in stringa e applichiamo il padding
-        return value.toString().padStart(count, character);
     }
-    /** Formatta un numero in una versione leggibile (es: 1000 -> 1K, 1000000 -> 1M) */
-    static toTruncateAndAdUdm(value, decimalDigits = 0, maxIntegerDigits = 3) {
-        // Nessun limite impostato o numero inferiore alla soglia definita
-        if (Math.abs(value) < Math.pow(10, maxIntegerDigits)) {
-            return value.toFixed(decimalDigits);
+    catch (error) {
+        // Se l'errore è già un UniHttpError (lanciato sopra) bypassa tutto il resto
+        if (error instanceof UniHttpError) {
+            throw error;
         }
-        // Definizione delle scale di riduzione per grandi numeri
-        const scales = [
-            { threshold: 1e12, suffix: 'T' }, // Trilioni
-            { threshold: 1e9, suffix: 'B' }, // Miliardi
-            { threshold: 1e6, suffix: 'M' }, // Milioni
-            { threshold: 1e3, suffix: 'K' }, // Migliaia
-        ];
-        // Itera dalla scala più grande alla più piccola per trovare la soglia corretta
-        for (const { threshold, suffix } of scales) {
-            if (Math.abs(value) >= threshold) {
-                const reduced = value / threshold;
-                // parseFloat(toFixed()) rimuove gli zeri decimali superflui (es: 1.50 -> 1.5)
-                // aggiungendo poi il relativo suffisso (K, M, B, T)
-                return Number.parseFloat(reduced.toFixed(decimalDigits)).toString() + suffix;
-            }
+        if (error instanceof TypeError) {
+            throw new UniHttpError('network', -1, url, {
+                exceptionMessage: `${error.name}: ${error.message}\n${error.stack}`,
+                exceptionType: error.name,
+                message: error.message,
+                stackTrace: error.stack ?? '',
+            });
         }
-        // Fallback: se il numero è grande ma non rientra nelle scale (caso raro con la logica attuale)
-        return value.toFixed(decimalDigits);
+        // Fallback per qualsiasi altro tipo di errore sconosciuto
+        throw error;
     }
 }
-
-/**
- * Utility per la manipolazione di stringhe
- */
-class UniTypeStringManager {
-    /** Converte una stringa in formato lblPascalCase (es. "user_id" -> "lblUserId") */
-    static toLabelize(key, prefix = 'lbl') {
-        // Se vuoto restituisce vuoto
-        if (!key)
-            return '';
-        // Pulizia chiave
-        const fixedKey = key.trim();
-        // Unisce il prefisso
-        return prefix + this.toPascalCase(fixedKey);
-    }
-    /** Converte una stringa in PascalCase (es. "user_id" -> "UserId") */
-    static toPascalCase(key) {
-        // Se vuoto restituisce vuoto
-        if (!key)
-            return '';
-        // Pulizia chiave
-        const fixedKey = key.trim();
-        // Normalizza e pulisce
-        const parts = this.splitString(fixedKey);
-        if (parts.length === 0)
-            return '';
-        // Converte in PascalCase
-        const pascalCased = this.toPascalCaseParts(parts);
-        return pascalCased;
-    }
-    /** Converte una stringa in camelCase (es. "user_id" -> "userId") */
-    static toCamelCase(key) {
-        // Se vuoto restituisce vuoto
-        if (!key)
-            return '';
-        // Pulizia chiave
-        const fixedKey = key.trim();
-        // Normalizza e pulisce
-        const parts = this.splitString(fixedKey);
-        if (parts.length === 0)
-            return '';
-        // La prima parola resta minuscola, le successive PascalCase
-        const first = parts[0].toLowerCase();
-        const rest = parts.slice(1);
-        return first + this.toPascalCaseParts(rest);
-    }
-    /** Capitalizza solo la prima lettera della stringa */
-    static toCapitalize(key) {
-        // Se vuoto restituisce vuoto
-        if (!key)
-            return '';
-        // Pulizia chiave
-        const fixedKey = key.trim();
-        return fixedKey.charAt(0).toUpperCase() + fixedKey.slice(1);
-    }
-    /** Sostituisce sotto-stringhe all'interno della stringa */
-    static toReplace(key, values) {
-        // Se vuoto restituisce vuoto
-        if (!key)
-            return '';
-        // Pulizia chiave
-        let fixedKey = key.trim();
-        for (const value of values) {
-            fixedKey = fixedKey.replaceAll(value.searchValue, value.replaceValue);
-        }
-        return fixedKey;
+async function executeHttp(url, init) {
+    /* Esegue la chiamata HTTP e restituisce il corpo decodificato come JSON */
+    const res = await execute(url, init);
+    if (!res)
+        return undefined;
+    /* Estrae il contenuto come testo */
+    const text = await res.text();
+    /* Controllo: se il testo è vuoto (''), ritorna undefined */
+    if (!text || text.trim().length === 0) {
+        return undefined;
     }
-    /* ----------------- Utils  ----------------- */
-    static splitString(key) {
-        return (key
-            // Pulisce eventuali caratteri di separazione rimasti in testa (es. "_tab_name" -> "tab_name")
-            .replace(/^[-_\s]+/, '')
-            // Isola il CamelCase inserendo un underscore tra minuscole e maiuscole (es. "userId" -> "user_Id")
-            .replaceAll(/([a-z])([A-Z])/g, '$1_$2')
-            // Isola gli acronimi attaccati a parole Normali (es. "VARAna" -> "VAR_Ana" grazie alla minuscola "na")
-            .replaceAll(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
-            // Applica il taglio definitivo usando come riferimento i trattini, gli underscore e gli spazi
-            .split(/[-_\s]+/)
-            // Rimuove dall'array finale eventuali stringhe vuote generate da separatori consecutivi
-            .filter(Boolean));
+    /* Parsa manualmente il testo, dato che lo stream è stato già letto */
+    return JSON.parse(text);
+}
+async function executeBlob(url, init) {
+    /* Esegue la chiamata HTTP */
+    const res = await execute(url, init);
+    if (!res)
+        return undefined;
+    /* Estrae il contenuto come Blob direttamente */
+    const blob = await res.blob();
+    /* Controllo: se il blob è vuoto (0 byte), ritorna undefined */
+    if (blob.size === 0) {
+        return undefined;
     }
-    static toPascalCaseParts(parts) {
-        return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+    /* Estrae il nome del file dall'header */
+    const disposition = res.headers.get('Content-Disposition');
+    let fileName = 'download.pdf'; // Fallback di default
+    if (disposition) {
+        const matches = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/.exec(disposition);
+        if (!!matches && matches[1]) {
+            fileName = matches[1].replaceAll(/['"]/g, '');
+        }
     }
+    /* Genera l'URL temporaneo dal blob */
+    const fileUrl = URL.createObjectURL(blob);
+    return { url: fileUrl, name: fileName };
 }
 
 /**
  * Costruisce un URL completo per l'API partendo dai parametri di configurazione.
  */
 function getUrl(hostname, port, config) {
-    const { params, path, hasApiPrefix = true } = config;
+    const { pathParams, path, hasApiPrefix } = config;
     // Costruzione url
-    const prefix = hasApiPrefix ? 'api' : '';
+    const prefix = hasApiPrefix === false ? '' : 'api';
     const cleanPath = path.startsWith('/') ? path.slice(1) : path;
     const pathFixed = prefix ? `${prefix}/${cleanPath}` : cleanPath;
     const url = new URL(pathFixed, `http://${hostname}:${port}`);
-    if (params) {
+    if (pathParams) {
         // Regex per intercettare stringhe in formato ISO string
         const isoDateRegex = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?$/;
-        for (const [key, rawValue] of Object.entries(params)) {
+        for (const [key, rawValue] of Object.entries(pathParams)) {
             if (rawValue === undefined || rawValue === null) {
                 continue;
             }
@@ -874,14 +536,14 @@ function getUrl(hostname, port, config) {
                 let formattedValue;
                 // Caso: Date nativo
                 if (item instanceof Date) {
-                    formattedValue = UniTypeDateManager.toYYYYMMDD(item);
+                    formattedValue = UniTypeDateManager$1.toYYYYMMDD(item);
                 }
                 // Caso: Date formato ISO string
                 else if (typeof item === 'string' && isoDateRegex.test(item)) {
                     const parsedDate = new Date(item);
                     formattedValue = Number.isNaN(parsedDate.getTime())
                         ? item
-                        : UniTypeDateManager.toYYYYMMDD(parsedDate);
+                        : UniTypeDateManager$1.toYYYYMMDD(parsedDate);
                 }
                 // Default
                 else {
@@ -931,7 +593,10 @@ function normalizeHttpBody(body, isRoot = true) {
     return Object.fromEntries(entries);
 }
 
-const CONFIG_TOAST_DEFAULT = { type: 'success', label: 'OperationCompleted' };
+const CONFIG_TOAST_DEFAULT = {
+    type: 'success',
+    label: 'OperationCompleted',
+};
 class UniHttpManager {
     /* ------------------------------------------------------------------------------- */
     /* --------------------------------- Metodi: get --------------------------------- */
@@ -962,12 +627,6 @@ class UniHttpManager {
         this.hostname = hostname;
         this.port = port;
     }
-    /**
-     * Imposta o resetta lo stato di errore per una specifica reference.
-     */
-    static updateHasError(id, hasError) {
-        updateHasError(id, hasError);
-    }
     /* ------------------------------------------------------------------------------- */
     /* -------------------------------- Metodi: CRUD --------------------------------- */
     /* ------------------------------------------------------------------------------- */
@@ -981,11 +640,11 @@ class UniHttpManager {
             ...config.init,
             method: 'GET',
         };
-        /* Chiama API */
+        /* API */
         const url = getUrl(this.hostname, this.port, config);
         return http$(url, 'one', config, () => executeHttp(url, initCustom)).pipe(tap((res) => {
             if (Array.isArray(res) && config.toast === undefined) {
-                UniToastManager.show({
+                UniToastManager$1.show({
                     label: 'ItemsFound',
                     params: { count: res.length },
                 });
@@ -1007,12 +666,12 @@ class UniHttpManager {
             },
             body: JSON.stringify(normalizeHttpBody(body)),
         };
-        /* Toast di default */
+        /* Config custom (toast di default) */
         const configCustom = {
             ...config,
-            toast: config.toast === null ? undefined : (config.toast ?? CONFIG_TOAST_DEFAULT),
+            toast: config.hasToast === false ? undefined : (config.toast ?? CONFIG_TOAST_DEFAULT),
         };
-        /* Chiama API */
+        /* API */
         const url = getUrl(this.hostname, this.port, config);
         return http$(url, 'one', configCustom, () => executeHttp(url, initCustom));
     }
@@ -1029,12 +688,12 @@ class UniHttpManager {
             };
             initCustom.body = JSON.stringify(normalizeHttpBody(body));
         }
-        /* Toast di default */
+        /* Config custom (toast di default) */
         const configCustom = {
             ...config,
-            toast: config.toast === null ? undefined : (config.toast ?? CONFIG_TOAST_DEFAULT),
+            toast: config.hasToast === false ? undefined : (config.toast ?? CONFIG_TOAST_DEFAULT),
         };
-        /* Chiama API */
+        /* API */
         const url = getUrl(this.hostname, this.port, config);
         return http$(url, 'one', configCustom, () => executeHttp(url, initCustom));
     }
@@ -1048,107 +707,459 @@ class UniHttpManager {
             ...config.init,
             method: 'DELETE',
         };
-        /* Toast di default */
+        /* Config custom (toast di default) */
         const configCustom = {
             ...config,
-            toast: config.toast === null ? undefined : (config.toast ?? CONFIG_TOAST_DEFAULT),
+            toast: config.hasToast === false ? undefined : (config.toast ?? CONFIG_TOAST_DEFAULT),
         };
-        /* Chiama API */
+        /* API */
         const url = getUrl(this.hostname, this.port, config);
         return http$(url, 'one', configCustom, () => executeHttp(url, initCustom));
     }
     /* ------------------------------------------------------------------------------- */
-    /* -------------------------- Metodi: CRUD file/image ---------------------------- */
+    /* -------------------------- Metodi: CRUD file/image ---------------------------- */
+    /* ------------------------------------------------------------------------------- */
+    /**
+     * Recupera un'immagine tramite una richiesta GET e la trasforma in un formato gestibile (es. Blob o Base64).
+     * Delega la logica di conversione alla funzione executeImage.
+     */
+    static readImage$(config) {
+        /* Config */
+        const initCustom = {
+            ...config.init,
+            method: 'GET',
+        };
+        /* API */
+        const url = getUrl(this.hostname, this.port, config);
+        return http$(url, 'image', config, () => executeBlob(url, initCustom));
+    }
+    /**
+     * Recupera un file (es. PDF) tramite una richiesta GET e restituisce un Object URL temporaneo.
+     * Delega la logica di conversione alla funzione executeFile.
+     */
+    static readFile$(config) {
+        /* Config */
+        const initCustom = {
+            ...config.init,
+            method: 'GET',
+        };
+        /* Config custom (toast di default) */
+        const configCustom = {
+            ...config,
+            toast: config.hasToast === false ? undefined : (config.toast ?? CONFIG_TOAST_DEFAULT),
+        };
+        /* API */
+        const url = getUrl(this.hostname, this.port, config);
+        return http$(url, 'file', configCustom, () => executeBlob(url, initCustom));
+    }
+    /* ------------------------------------------------------------------------------- */
+    /* ---------------------------- Metodi: CRUD polling ----------------------------- */
+    /* ------------------------------------------------------------------------------- */
+    /**
+     * Avvia un ciclo di polling basato su richieste GET.
+     * Continua a emettere valori in base alla configurazione di intervallo definita in HttpConfigPolling.
+     */
+    static readPolling$(config) {
+        /* Config */
+        const initCustom = {
+            ...config.init,
+            method: 'GET',
+        };
+        /* API */
+        const url = getUrl(this.hostname, this.port, config);
+        return httpPolling$(url, config, () => executeHttp(url, initCustom));
+    }
+    /**
+     * Avvia un ciclo di polling basato su richieste POST.
+     * Invia il body specificato a ogni iterazione del ciclo.
+     */
+    static createPolling$(config, body) {
+        /* Config */
+        const initCustom = {
+            ...config.init,
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        };
+        /* API */
+        const url = getUrl(this.hostname, this.port, config);
+        return httpPolling$(url, config, () => executeHttp(url, initCustom));
+    }
+    /**
+     * Avvia un ciclo di polling basato su richieste PUT.
+     */
+    static updatePolling$(config, body) {
+        /* Config */
+        const initCustom = {
+            ...config.init,
+            method: 'PUT',
+        };
+        if (body !== undefined) {
+            initCustom.headers = {
+                ...initCustom.headers,
+                'Content-Type': 'application/json',
+            };
+            initCustom.body = JSON.stringify(body);
+        }
+        /* API */
+        const url = getUrl(this.hostname, this.port, config);
+        return httpPolling$(url, config, () => executeHttp(url, initCustom));
+    }
+}
+
+class UniLocaleManager {
+    /* ------------------------------------------------------------------------------- */
+    /* ----------------------------------- Config ------------------------------------ */
+    /* ------------------------------------------------------------------------------- */
+    /** Codice lingua corrente (es. 'it-IT', 'en-US') usato per formattare date e numeri */
+    static { this._locale = navigator.language ?? 'en-US'; }
+    /** Elenco dei codici lingua supportati dall'applicazione (es. ['it-IT', 'en-US']) */
+    static { this._localesSupported = []; }
+    /** Prefisso globale applicato a tutte le chiavi di traduzione (es. 'APP_') */
+    static { this._prefix = undefined; }
+    /* ------------------------------------------------------------------------------- */
+    /* --------------------------------- Metodi: get --------------------------------- */
+    /* ------------------------------------------------------------------------------- */
+    /** Restituisce il codice lingua corrente */
+    static get locale() {
+        return this._locale;
+    }
+    /** Restituisce l'array contenente tutti i codici locale supportati.*/
+    static get localesSupported() {
+        return this._localesSupported;
+    }
+    /** Restituisce solo la lingua (es. 'it') */
+    static get language() {
+        return this._locale.split('-')[0];
+    }
+    /** Restituisce solo il paese (es. 'IT') */
+    static get region() {
+        const parts = this._locale.split('-');
+        return parts.length > 1 ? parts[1] : '';
+    }
+    /* ------------------------------------------------------------------------------- */
+    /* ------------------------------------ Store ------------------------------------ */
+    /* ------------------------------------------------------------------------------- */
+    /** Store privato (Subject) */
+    static { this.store = new BehaviorSubject({}); }
+    /** Store pubblico (Observable) */
+    static { this.store$ = this.store.asObservable(); }
+    /** Ottiene il dizionario attuale senza sottoscrizione */
+    static get currentValue() {
+        return this.store.getValue();
+    }
+    /* ------------------------------------------------------------------------------- */
+    /* -------------------------------- Metodi: setup -------------------------------- */
+    /* ------------------------------------------------------------------------------- */
+    /**
+     * Inizializza la configurazione di rete del manager.
+     * Deve essere chiamato prima di effettuare qualsiasi richiesta HTTP.
+     */
+    static setup(locale, prefix) {
+        this._locale = locale ?? 'en-US';
+        this._prefix = prefix;
+    }
+    /** Imposta l'elenco dei codici lingua supportati dall'applicazione */
+    static setLocalesSupported(locales) {
+        this._localesSupported = locales ?? [];
+    }
+    /**
+     * Aggiorna lo store locale con il dizionario delle traduzioni fornito.
+     * Se viene passato undefined, lo store viene inizializzato come oggetto vuoto.
+     */
+    static setTranslations(translations) {
+        this.store.next(translations ?? {});
+    }
+    /* ------------------------------------------------------------------------------- */
+    /* ----------------------------- Metodi: traduzioni ------------------------------ */
+    /* ------------------------------------------------------------------------------- */
+    /**
+     * Traduce una label in base al dizionario caricato.
+     * Gestisce la composizione della chiave, i parametri dinamici (interpolazione) e il fallback.
+     */
+    static translate(key, prefix = 'lbl', params) {
+        if (!key)
+            return '-';
+        // Costruzione chiave: prefissoGlobale + prefissoLocale + LabelConInizialeMaiuscola
+        const keyParts = key.trim().split(/(?=[A-Z])/);
+        const rootKeyParts = keyParts.filter((p) => p.toLowerCase() !== prefix.toLowerCase());
+        const cleanKey = rootKeyParts.length > 0 ? rootKeyParts.join('') : undefined;
+        const capitalizedKey = cleanKey ? cleanKey.charAt(0).toUpperCase() + cleanKey.slice(1) : '';
+        const finalKey = `${this._prefix ?? ''}${prefix}${capitalizedKey}`;
+        // Cerca la chiave in minuscolo (standardizzazione)
+        let translation = this.currentValue?.[finalKey.toLowerCase()];
+        // Log e fallback se la traduzione manca
+        if (!translation) {
+            console.warn(`Translation missing for key: ${finalKey}`);
+            return `🔑 ${finalKey}`;
+        }
+        // Interpolazione variabili
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                const displayValue = value instanceof Date ? value.toLocaleDateString(this._locale) : String(value);
+                translation = translation.replaceAll(`{{${key}}}`, displayValue);
+            }
+        }
+        return translation;
+    }
+    /**
+     * Traduce una stringa che contiene parametri separati da un carattere specifico.
+     * Supporta ora un numero arbitrario di parametri in formato "label/param1/param2"
+     * o semplicemente "label".
+     */
+    static translateInlineParams(keyWithParams, splitChar) {
+        if (!keyWithParams)
+            return '-';
+        const [label, ...params] = keyWithParams.split(splitChar);
+        // Se non ci sono parametri, esegui una traduzione semplice
+        if (params.length === 0) {
+            return this.translate(label);
+        }
+        // Mappa i parametri in un oggetto di interpolazione: { inlineParam0: val, inlineParam1: val, ... }
+        const interpolationParameters = {};
+        for (const [index, val] of params.entries()) {
+            interpolationParameters[`param${index}`] = val;
+        }
+        return this.translate(label, 'lbl', interpolationParameters);
+    }
+    /* ------------------------------------------------------------------------------- */
+    /* ------------------------------- Metodi: numeri -------------------------------- */
+    /* ------------------------------------------------------------------------------- */
+    /**
+     * Converte un valore numerico in una stringa formattata secondo il locale impostato.
+     * Disabilita i separatori delle migliaia e forza un numero fisso di decimali.
+     */
+    static toStringNumber(value, decimal) {
+        return new Intl.NumberFormat(this._locale, {
+            useGrouping: true,
+            minimumFractionDigits: decimal,
+            maximumFractionDigits: decimal,
+            numberingSystem: 'latn',
+        }).format(value);
+    }
+    /* ------------------------------------------------------------------------------- */
+    /* -------------------------------- Metodi: date --------------------------------- */
     /* ------------------------------------------------------------------------------- */
     /**
-     * Recupera un'immagine tramite una richiesta GET e la trasforma in un formato gestibile (es. Blob o Base64).
-     * Delega la logica di conversione alla funzione executeImage.
+     * Formatta una data o una stringa in base al locale corrente.
+     * Gestisce tre modalità predefinite (date, time, full) e accetta opzioni personalizzate Intl.
      */
-    static readImage$(config) {
-        /* Config */
-        const initCustom = {
-            ...config.init,
-            method: 'GET',
-        };
-        /* Chiama API */
-        const url = getUrl(this.hostname, this.port, config);
-        return http$(url, 'one', config, () => executeBlob(url, initCustom));
+    static toDate(date, mode = 'full', force) {
+        const dt = new Date(date);
+        // Controllo: validità data
+        if (Number.isNaN(dt.getTime())) {
+            console.error(`[UniLocaleManager] Data non valida fornita a formatDateTime:`, date);
+            return '';
+        }
+        // Controllo: locale da forzare
+        const locale = force && this._locale.startsWith(force.oldLang) ? force.newLocale : this._locale;
+        switch (mode) {
+            case 'date': {
+                return dt.toLocaleDateString(locale);
+            }
+            case 'time': {
+                return dt.toLocaleTimeString(locale);
+            }
+            case 'full': {
+                return dt.toLocaleString(locale);
+            }
+        }
     }
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+class UniToastManager {
+    /* ------------------------------------------------------------------------------- */
+    /* -------------------------------- Metodi: setup -------------------------------- */
+    /* ------------------------------------------------------------------------------- */
     /**
-     * Recupera un file (es. PDF) tramite una richiesta GET e restituisce un Object URL temporaneo.
-     * Delega la logica di conversione alla funzione executeFile.
+     * Inizializza il manager con una serie di operazioni
      */
-    static readFile$(config) {
-        /* Config */
-        const initCustom = {
-            ...config.init,
-            method: 'GET',
-        };
-        /* Toast di default */
-        const configCustom = {
-            ...config,
-            toast: config.toast === null ? undefined : (config.toast ?? CONFIG_TOAST_DEFAULT),
-        };
-        /* Chiama API */
-        const url = getUrl(this.hostname, this.port, config);
-        return http$(url, 'file', configCustom, () => executeBlob(url, initCustom));
+    static setup(operations) {
+        this.manager = operations;
     }
     /* ------------------------------------------------------------------------------- */
-    /* ---------------------------- Metodi: CRUD polling ----------------------------- */
+    /* -------------------------------- Metodi: show --------------------------------- */
     /* ------------------------------------------------------------------------------- */
     /**
-     * Avvia un ciclo di polling basato su richieste GET.
-     * Continua a emettere valori in base alla configurazione di intervallo definita in HttpConfigPolling.
+     * Mostra un toast di successo basato su una risposta HTTP e una label di traduzione.
      */
-    static readPolling$(config) {
-        /* Config */
-        const initCustom = {
-            ...config.init,
-            method: 'GET',
-        };
-        /* Chiama API */
-        const url = getUrl(this.hostname, this.port, config);
-        return httpPolling$(url, config, () => executeHttp(url, initCustom));
+    static show(config) {
+        /* Messaggio tradotto */
+        const msg = UniLocaleManager$1.translate(config.label, 'toast', config.params);
+        const msgFixed = `${config.prefix ?? ''}${msg}${config.suffix ?? ''}`;
+        this.manager[config.type ?? 'info'](msgFixed, config);
     }
     /**
-     * Avvia un ciclo di polling basato su richieste POST.
-     * Invia il body specificato a ogni iterazione del ciclo.
+     * Mostra un toast di successo basato su una risposta HTTP e una label di traduzione.
      */
-    static createPolling$(config, body) {
-        /* Config */
-        const initCustom = {
-            ...config.init,
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(body),
-        };
-        /* Chiama API */
-        const url = getUrl(this.hostname, this.port, config);
-        return httpPolling$(url, config, () => executeHttp(url, initCustom));
+    static showHttp(config, res) {
+        const { params, resParams, formatters } = config;
+        /* Parametri statici di base */
+        const allParams = { ...params };
+        if (res !== undefined && res !== null) {
+            /* Se è un array aggiunge il parametro 'count' con la lunghezza dell'array */
+            if (Array.isArray(res)) {
+                allParams['count'] = res.length;
+            }
+            else if (typeof res === 'object' && resParams?.length) {
+                // Se la proprietà NON esiste nella risposta, allora salta
+                for (const resParam of resParams ?? []) {
+                    if (!(resParam in res))
+                        continue;
+                    // Se esiste un formatter per questa chiave lo si usa, altrimenti valore grezzo
+                    const rawValue = res[resParam];
+                    allParams[resParam] = formatters?.[resParam] ? formatters[resParam](rawValue) : rawValue;
+                }
+            }
+        }
+        /* Messaggio tradotto */
+        this.show({ ...config, params: allParams });
     }
-    /**
-     * Avvia un ciclo di polling basato su richieste PUT.
-     */
-    static updatePolling$(config, body) {
-        /* Config */
-        const initCustom = {
-            ...config.init,
-            method: 'PUT',
-        };
-        if (body !== undefined) {
-            initCustom.headers = {
-                ...initCustom.headers,
-                'Content-Type': 'application/json',
-            };
-            initCustom.body = JSON.stringify(body);
+}
+
+/**
+ * Classe di utilità per la gestione e formattazione delle date.
+ * Fornisce metodi per convertire in modo sicuro valori di tipo Date, stringa o null in formati standardizzati.
+ */
+class UniTypeDateManager {
+    static toYYYYMMDD(date) {
+        if (!date)
+            return '';
+        const d = new Date(date);
+        if (Number.isNaN(d.getTime()))
+            return '';
+        const year = d.getFullYear();
+        const month = String(d.getMonth() + 1).padStart(2, '0');
+        const day = String(d.getDate()).padStart(2, '0');
+        return `${year}-${month}-${day}`;
+    }
+}
+
+/**
+ * Utility per la gestione e formattazione di valori numerici.
+ */
+class UniTypeNumberManager {
+    /** Applica il padding a un numero o una stringa */
+    static toPad(value, count, character = '0') {
+        // Se il valore è null/undefined, riempiamo l'intero campo con il carattere scelto
+        if (value === null || value === undefined) {
+            return ''.padStart(count, character);
         }
-        /* Chiama API */
-        const url = getUrl(this.hostname, this.port, config);
-        return httpPolling$(url, config, () => executeHttp(url, initCustom));
+        // Convertiamo in stringa e applichiamo il padding
+        return value.toString().padStart(count, character);
+    }
+    /** Formatta un numero in una versione leggibile (es: 1000 -> 1K, 1000000 -> 1M) */
+    static toTruncateAndAdUdm(value, decimalDigits = 0, maxIntegerDigits = 3) {
+        // Nessun limite impostato o numero inferiore alla soglia definita
+        if (Math.abs(value) < Math.pow(10, maxIntegerDigits)) {
+            return value.toFixed(decimalDigits);
+        }
+        // Definizione delle scale di riduzione per grandi numeri
+        const scales = [
+            { threshold: 1e12, suffix: 'T' }, // Trilioni
+            { threshold: 1e9, suffix: 'B' }, // Miliardi
+            { threshold: 1e6, suffix: 'M' }, // Milioni
+            { threshold: 1e3, suffix: 'K' }, // Migliaia
+        ];
+        // Itera dalla scala più grande alla più piccola per trovare la soglia corretta
+        for (const { threshold, suffix } of scales) {
+            if (Math.abs(value) >= threshold) {
+                const reduced = value / threshold;
+                // parseFloat(toFixed()) rimuove gli zeri decimali superflui (es: 1.50 -> 1.5)
+                // aggiungendo poi il relativo suffisso (K, M, B, T)
+                return Number.parseFloat(reduced.toFixed(decimalDigits)).toString() + suffix;
+            }
+        }
+        // Fallback: se il numero è grande ma non rientra nelle scale (caso raro con la logica attuale)
+        return value.toFixed(decimalDigits);
     }
 }
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Utility per la manipolazione di stringhe
+ */
+class UniTypeStringManager {
+    /** Converte una stringa in formato lblPascalCase (es. "user_id" -> "lblUserId") */
+    static toLabelize(key, prefix = 'lbl') {
+        // Se vuoto restituisce vuoto
+        if (!key)
+            return '';
+        // Pulizia chiave
+        const fixedKey = key.trim();
+        // Unisce il prefisso
+        return prefix + this.toPascalCase(fixedKey);
+    }
+    /** Converte una stringa in PascalCase (es. "user_id" -> "UserId") */
+    static toPascalCase(key) {
+        // Se vuoto restituisce vuoto
+        if (!key)
+            return '';
+        // Pulizia chiave
+        const fixedKey = key.trim();
+        // Normalizza e pulisce
+        const parts = this.splitString(fixedKey);
+        if (parts.length === 0)
+            return '';
+        // Converte in PascalCase
+        const pascalCased = this.toPascalCaseParts(parts);
+        return pascalCased;
+    }
+    /** Converte una stringa in camelCase (es. "user_id" -> "userId") */
+    static toCamelCase(key) {
+        // Se vuoto restituisce vuoto
+        if (!key)
+            return '';
+        // Pulizia chiave
+        const fixedKey = key.trim();
+        // Normalizza e pulisce
+        const parts = this.splitString(fixedKey);
+        if (parts.length === 0)
+            return '';
+        // La prima parola resta minuscola, le successive PascalCase
+        const first = parts[0].toLowerCase();
+        const rest = parts.slice(1);
+        return first + this.toPascalCaseParts(rest);
+    }
+    /** Capitalizza solo la prima lettera della stringa */
+    static toCapitalize(key) {
+        // Se vuoto restituisce vuoto
+        if (!key)
+            return '';
+        // Pulizia chiave
+        const fixedKey = key.trim();
+        return fixedKey.charAt(0).toUpperCase() + fixedKey.slice(1);
+    }
+    /** Sostituisce sotto-stringhe all'interno della stringa */
+    static toReplace(key, values) {
+        // Se vuoto restituisce vuoto
+        if (!key)
+            return '';
+        // Pulizia chiave
+        let fixedKey = key.trim();
+        for (const value of values) {
+            fixedKey = fixedKey.replaceAll(value.searchValue, value.replaceValue);
+        }
+        return fixedKey;
+    }
+    /* ----------------- Utils  ----------------- */
+    static splitString(key) {
+        return (key
+            // Pulisce eventuali caratteri di separazione rimasti in testa (es. "_tab_name" -> "tab_name")
+            .replace(/^[-_\s]+/, '')
+            // Isola il CamelCase inserendo un underscore tra minuscole e maiuscole (es. "userId" -> "user_Id")
+            .replaceAll(/([a-z])([A-Z])/g, '$1_$2')
+            // Isola gli acronimi attaccati a parole Normali (es. "VARAna" -> "VAR_Ana" grazie alla minuscola "na")
+            .replaceAll(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+            // Applica il taglio definitivo usando come riferimento i trattini, gli underscore e gli spazi
+            .split(/[-_\s]+/)
+            // Rimuove dall'array finale eventuali stringhe vuote generate da separatori consecutivi
+            .filter(Boolean));
+    }
+    static toPascalCaseParts(parts) {
+        return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join('');
+    }
+}
 
 /*
  * Public API Surface of uni-manager