uni-manager 0.1.10 → 0.1.11

package/fesm2022/uni-manager.mjs

@@ -1,1184 +1,11 @@
-import { map, distinctUntilChanged, BehaviorSubject, switchMap, mergeMap, concatMap, exhaustMap, throwError, of, EMPTY, defer, from, tap, catchError, finalize, timer } from 'rxjs';
-import { UniToastManager as UniToastManager$1 } from 'uni-manager/toast';
-import isEqual from 'lodash-es/isEqual';
-import { UniErrorManager as UniErrorManager$1 } from 'uni-manager/error';
-import { UniHttpError, isHttpException } from 'uni-error/http';
-import { UniTypeDateManager as UniTypeDateManager$1 } from 'uni-manager/type';
-import { UniLocaleManager as UniLocaleManager$1 } from 'uni-manager/locale';
-
-class UniErrorManager {
-    /* ------------------------------------------------------------------------------- */
-    /* --------------------------------- Metodi: get --------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /** Restituisce se lo store ha chiamate in attesa di risposta o meno */
-    static get errors$() {
-        return UniErrorManager.store$.pipe(map((x) => Array.from(x.entries(), ([id, error]) => ({ ...error, id }))), distinctUntilChanged((prev, curr) => {
-            if (prev.length !== curr.length)
-                return false;
-            return prev.every((err, index) => err.id === curr[index].id && err.count === curr[index].count);
-        }));
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* ------------------------------------ Store ------------------------------------ */
-    /* ------------------------------------------------------------------------------- */
-    /** Store privato (Subject) */
-    static { this.store = new BehaviorSubject(new Map()); }
-    /** Store pubblico (Observable) */
-    static { this.store$ = UniErrorManager.store.asObservable(); }
-    /** Ottiene lo stato attuale della Map senza dover sottoscrivere l'observable */
-    static get currentValue() {
-        return UniErrorManager.store.getValue();
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* -------------------------------- Metodi: store -------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /**
-     * Aggiunge o aggiorna un errore nello store.
-     * Se l'errore esiste già (stesso ID), incrementa il contatore 'count' e aggiorna il timestamp.
-     */
-    static add(id, error) {
-        // Recupera l'ultimo stato (Map)
-        const oldMap = UniErrorManager.currentValue;
-        // Tenta di recuperare l'oggetto corrente
-        const oldItem = oldMap.get(id);
-        // Crea il nuovo oggetto aggiornando contatore e portando il timestamp al momento attuale
-        const newItemMap = {
-            ...error,
-            count: oldItem ? oldItem.count + 1 : 1,
-            timestamp: new Date(),
-        };
-        // Crea una nuova istanza della Map
-        const newMap = new Map(oldMap);
-        newMap.set(id, newItemMap);
-        // Aggiorna il nuovo stato notificando l'observer
-        UniErrorManager.store.next(newMap);
-    }
-    /**
-     * Rimuove un errore tramite ID
-     */
-    static remove(id) {
-        // Recupera l'ultimo stato (Map)
-        const oldMap = UniErrorManager.currentValue;
-        // Controllo: se non è presente l'item allora termina
-        if (!oldMap.has(id))
-            return;
-        // Crea una nuova istanza della Map
-        const newMap = new Map(oldMap);
-        newMap.delete(id);
-        // Aggiorna il nuovo stato notificando l'observer
-        UniErrorManager.store.next(newMap);
-    }
-    /**
-     * Svuota completamente la lista degli errori
-     */
-    static removeAll() {
-        // Crea una nuova istanza della Map
-        const newMap = new Map();
-        // Aggiorna il nuovo stato notificando l'observer
-        UniErrorManager.store.next(newMap);
-    }
-}
-
-class UniFileManager {
-    /**
-     * Apre un file (es. PDF, immagine) in una nuova scheda del browser
-     * Il contenuto viene caricato all'interno di un iframe per garantire compatibilità di visualizzazione
-     */
-    static openInNewTab(data) {
-        if (!data || !data.url)
-            return;
-        const newWindow = window.open('', '_blank');
-        if (!newWindow)
-            return;
-        newWindow.document.title = data.name;
-        // Crea l'iframe e lo aggiunge al body della nuova finestra
-        const iframe = UniFileManager.createIframe(newWindow.document, data.url, '100%', '100%');
-        newWindow.document.body.style.margin = '0';
-        newWindow.document.body.append(iframe);
-        // Rimuove l'oggetto URL dalla memoria dopo un tempo congruo per il caricamento
-        setTimeout(() => URL.revokeObjectURL(data.url), 3000);
-    }
-    /**
-     * Stampa un file aprendo il dialogo di stampa nativo del sistema
-     * Utilizza un iframe invisibile per non interrompere la navigazione
-     */
-    static openInPrintPreview(data) {
-        if (!data || !data.url)
-            return;
-        // Crea l'iframe come elemento fisso e nascosto (dimensioni zero)
-        const iframe = UniFileManager.createIframe(document, data.url, '0', '0');
-        iframe.style.position = 'fixed';
-        iframe.style.bottom = '0';
-        document.body.append(iframe);
-        // Attende il completamento del caricamento del file nell'iframe
-        iframe.addEventListener('load', () => {
-            // Attesa supplementare per consentire il rendering del PDF
-            setTimeout(() => {
-                iframe.contentWindow?.focus();
-                iframe.contentWindow?.print();
-                // Rimozione dell'iframe dal DOM e pulizia della memoria
-                setTimeout(() => {
-                    iframe.remove();
-                    URL.revokeObjectURL(data.url);
-                }, 1000);
-            }, 1000);
-        });
-    }
-    /**
-     * Scarica un file localmente sul dispositivo dell'utente
-     */
-    static download(data) {
-        if (!data || !data.url)
-            return;
-        const link = document.createElement('a');
-        link.href = data.url;
-        // Specifica il nome con cui il file verrà salvato
-        link.download = data.name;
-        // Opzionale: assicura che il link non sia visibile
-        link.style.display = 'none';
-        document.body.append(link);
-        link.click();
-        // Pulizia: rimuove l'elemento e revoca l'URL
-        setTimeout(() => {
-            link.remove();
-            URL.revokeObjectURL(data.url);
-        }, 100);
-    }
-    /* ----------------------------- Utils ----------------------------- */
-    static createIframe(doc, url, width, height) {
-        const iframe = doc.createElement('iframe');
-        iframe.src = url;
-        iframe.style.width = width;
-        iframe.style.height = height;
-        iframe.style.border = 'none';
-        return iframe;
-    }
-}
-
-var MapOperator;
-(function (MapOperator) {
-    /** Cancella la precedente richiesta, mantiene solo l’ultima */
-    MapOperator[MapOperator["SWITCH_MAP"] = 0] = "SWITCH_MAP";
-    /** Ignora nuovi valori finché la corrente non finisce */
-    MapOperator[MapOperator["EXHAUST_MAP"] = 1] = "EXHAUST_MAP";
-    /** Mette le richieste in coda, le esegue una alla volta */
-    MapOperator[MapOperator["CONCAT_MAP"] = 2] = "CONCAT_MAP";
-    /** Esegue tutte le richieste in parallelo, ordine non garantito */
-    MapOperator[MapOperator["MERGE_MAP"] = 3] = "MERGE_MAP";
-})(MapOperator || (MapOperator = {}));
-var PollingErrorMode;
-(function (PollingErrorMode) {
-    /** Salta questa iterazione emettendo un undefined. Il polling continua al tick successivo. */
-    PollingErrorMode[PollingErrorMode["IGNORE"] = 0] = "IGNORE";
-    /** Salta questa iterazione senza emettere valori. Il polling continua al tick successivo. */
-    PollingErrorMode[PollingErrorMode["SKIP"] = 1] = "SKIP";
-    /** Interrompe il polling propagando l'errore. */
-    PollingErrorMode[PollingErrorMode["STOP"] = 2] = "STOP";
-    /** Ignora l'errore, lo salva (es. per UI), e continua il polling. Emette `undefined`. */
-    PollingErrorMode[PollingErrorMode["IGNORE_WITH_ERROR"] = 3] = "IGNORE_WITH_ERROR";
-})(PollingErrorMode || (PollingErrorMode = {}));
-var EmitValueMode;
-(function (EmitValueMode) {
-    /** Aggiorna lo stato solo se arrivano dati nuovi (distinct) */
-    EmitValueMode[EmitValueMode["ON_NEW_DATA"] = 0] = "ON_NEW_DATA";
-    /** Aggiorna lo stato ad ogni chiamata, anche se i dati sono uguali */
-    EmitValueMode[EmitValueMode["EVERY_TIME"] = 1] = "EVERY_TIME";
-})(EmitValueMode || (EmitValueMode = {}));
-
-function operatorHandler(operator) {
-    // Gestione della concorrenza in base al parametro
-    switch (operator) {
-        case MapOperator.EXHAUST_MAP: {
-            return (project) => exhaustMap(project);
-        }
-        case MapOperator.CONCAT_MAP: {
-            return (project) => concatMap(project);
-        }
-        case MapOperator.MERGE_MAP: {
-            return (project) => mergeMap(project);
-        }
-        case MapOperator.SWITCH_MAP: {
-            return (project) => switchMap(project);
-        }
-    }
-}
-function errorHandler(ref, err, errorMode) {
-    // Controllo: sia effettivamente un errore di tipo 'UniHttpError'
-    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);
-            }
-        }
-    }
-    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;
-    return defer(() => {
-        const http$ = from(promiseFactory());
-        return http$.pipe(tap({
-            subscribe: () => {
-                /* Creazione reference */
-                add(ref, url, refType);
-                /* Incrementa per il loader */
-                if (hasLoader !== false) {
-                    updateIsLoading(ref, 1);
-                }
-            },
-            unsubscribe: () => {
-                /* Rimozione reference */
-                remove(ref);
-            },
-            next: (res) => {
-                /* Mostra toast (se presente) */
-                if (toast) {
-                    UniToastManager$1.showHttp(toast, res);
-                }
-            },
-        }), catchError((err) => {
-            // Aggiorna la ref nella map
-            updateHasError(ref, true);
-            /* Gestione errore */
-            return errorHandler(ref, err, PollingErrorMode.STOP);
-        }), finalize(() => {
-            /* Decrementa per il loader */
-            if (hasLoader !== false) {
-                updateIsLoading(ref, -1);
-            }
-        }));
-    });
-}
-/**
- * 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;
-    const timer$ = timer(0, interval);
-    const source$ = timer$.pipe(tap({
-        subscribe: () => {
-            /* Creazione reference */
-            add(ref, url, 'polling');
-        },
-        unsubscribe: () => {
-            /* Rimozione reference */
-            remove(ref);
-        },
-    }), operatorHandler(operator)((index) => {
-        /* Incrementa per il loader */
-        if (index === 0 && firstIteration?.hasLoader !== false) {
-            updateIsLoading(ref, 1);
-        }
-        return defer(() => {
-            const http$ = from(promiseFactory());
-            return http$.pipe(tap((res) => {
-                /* 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$1.remove(ref);
-                }
-                /* Prima risposta */
-                if (index === 0 && firstIteration?.toast) {
-                    UniToastManager$1.showHttp(firstIteration.toast, res);
-                }
-            }), catchError((err) => {
-                // Aggiorna la ref nella map
-                updateHasError(ref, true);
-                /* Gestione errore */
-                return errorHandler(ref, err, errorMode);
-            }), finalize(() => {
-                /* Decrementa per il loader */
-                if (index === 0 && firstIteration?.hasLoader !== false) {
-                    updateIsLoading(ref, -1);
-                }
-            }));
-        });
-    }));
-    return emitValueMode === EmitValueMode.ON_NEW_DATA
-        ? source$.pipe(distinctUntilChanged((prev, cur) => isEqual(prev, cur)))
-        : source$;
-}
-/* ------------------------------------------------------------------------------- */
-/* ------------------------------------ Utils ------------------------------------ */
-/* ------------------------------------------------------------------------------- */
-/**
- * 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);
-}
-
-async function execute(url, init) {
-    try {
-        /* Esecuzione della richiesta HTTP nativa */
-        const res = await fetch(url, init);
-        /* Gestione dello stato 204: assenza di contenuto legittima */
-        if (res.status === 204) {
-            return undefined;
-        }
-        /*Gestione ok HTTP: risposta ricevuta dal server con stato valido */
-        if (res.ok) {
-            return res;
-        }
-        /* Gestione Errore HTTP: risposta ricevuta dal server ma con stato non valido */
-        let httpErrorPayload;
-        try {
-            /* Clonazione della risposta per l'ispezione del payload senza consumare lo stream originale */
-            const resClone = res.clone();
-            /* Recupero se è un json */
-            const contentType = res.headers.get('content-type') ?? '';
-            const isJson = contentType.startsWith('application/json');
-            /* Estrazione del corpo dell'errore in base al formato rilevato */
-            httpErrorPayload = isJson ? await resClone.json() : await resClone.text();
-        }
-        catch {
-            /* Fallback in caso di fallimento della clonazione o del parsing del testo */
-            httpErrorPayload = `Failed to parse error response body (Status: ${res.status})`;
-        }
-        // Controllo: se il payload estratto è di tipo HttpException (.NET)
-        if (isHttpException(httpErrorPayload)) {
-            // const type = httpErrorPayload.isBe ? 'be' : 'ice';
-            throw new UniHttpError('be', res.status, url, httpErrorPayload);
-        }
-        // Fallback per errori di infrastruttura (es. pagine HTML di IIS/Nginx, 404, 502)
-        const errorTracker = new Error(res.statusText || `HTTP Error ${res.status}`);
-        const fallbackException = {
-            message: typeof httpErrorPayload === 'string' && httpErrorPayload
-                ? httpErrorPayload
-                : errorTracker.message,
-            type: 'InfrastructureError',
-            stackTrace: errorTracker.stack ?? '',
-            isBe: true,
-        };
-        throw new UniHttpError('server', res.status, url, fallbackException);
-    }
-    catch (error) {
-        // Fallback per errori di rete locale (es. assenza di linea, DNS fallito)
-        if (error instanceof TypeError) {
-            const fallbackNetworkException = {
-                message: error.message,
-                type: error.name || 'NetworkError',
-                stackTrace: error.stack ?? '',
-                isBe: true,
-            };
-            throw new UniHttpError('network', -1, url, fallbackNetworkException);
-        }
-        // Rilancio diretto per istanze di UniHttpError o eccezioni già gestite
-        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 };
-}
-
-/**
- * Costruisce un URL completo per l'API partendo dai parametri di configurazione.
- */
-function getUrl(hostname, port, config) {
-    const { pathParams, path, hasApiPrefix } = config;
-    // Costruzione url
-    const cleanPath = path.replaceAll(/^\/+|\/+$/g, '');
-    const segments = [hasApiPrefix === false ? '' : 'api', cleanPath].filter(Boolean);
-    const pathFixed = '/' + segments.join('/');
-    const url = new URL(pathFixed, `http://${hostname}:${port}`);
-    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(pathParams)) {
-            if (rawValue === undefined || rawValue === null) {
-                continue;
-            }
-            // Conversione in array per usare un solo ciclo
-            const valuesArray = Array.isArray(rawValue) ? rawValue : [rawValue];
-            for (const item of valuesArray) {
-                if (item === undefined || item === null) {
-                    continue;
-                }
-                let formattedValue;
-                // Caso: Date nativo
-                if (item instanceof Date) {
-                    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$1.toYYYYMMDD(parsedDate);
-                }
-                // Default
-                else {
-                    formattedValue = String(item);
-                }
-                url.searchParams.append(key, formattedValue);
-            }
-        }
-    }
-    return url;
-}
-/**
- * Normalizza i valori del body cosi da sistemare le incongruenze tra ui e db
- */
-function normalizeHttpBody(body, isRoot = true) {
-    // PRIMITIVI GENERICI
-    // Tipi gestiti: null, undefined, number, boolean, symbol, bigint, string
-    if (body === null || typeof body !== 'object') {
-        // Sotto-gestione specifica per il tipo: string
-        if (typeof body === 'string') {
-            return body.trim();
-        }
-        return body;
-    }
-    // DATE
-    // Tipi gestiti: Date
-    // Formattazione esplicita manuale in YYYY-MM-DD
-    if (body instanceof Date) {
-        const year = body.getFullYear();
-        const month = String(body.getMonth() + 1).padStart(2, '0');
-        const day = String(body.getDate()).padStart(2, '0');
-        return `${year}-${month}-${day}`;
-    }
-    // STRUTTURE DATI ITERABILI
-    // Tipi gestiti: Array (qualsiasi array, es. string[], number[], Object[])
-    // Se è un array, viene mappato ricorsivamente ogni singolo elemento al suo interno (passando isRoot = false perché gli elementi dell'array non sono l'oggetto root principale)
-    if (Array.isArray(body)) {
-        return body.map((item) => normalizeHttpBody(item, false));
-    }
-    // OGGETTI
-    // Tipi gestiti: Record<string, any>, generici oggetti JavaScript ({ })
-    // Rimuove chiave 'id' al primo livello e prosegue ricorsivamente
-    const entries = Object.entries(body)
-        .filter(([key]) => !(isRoot && key.toLowerCase() === 'id'))
-        .map(([key, value]) => [key, normalizeHttpBody(value, false)]);
-    // Ricostruisce l'oggetto normalizzato
-    return Object.fromEntries(entries);
-}
-
-const CONFIG_TOAST_DEFAULT = {
-    type: 'success',
-    label: 'OperationCompleted',
-};
-class UniHttpManager {
-    /* ------------------------------------------------------------------------------- */
-    /* --------------------------------- Metodi: get --------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /** Restituisce se lo store ha chiamate in attesa di risposta o meno */
-    static get hasWaitingRequests$() {
-        return UniHttpManager.store$.pipe(map((requestMap) => {
-            for (const request of requestMap.values()) {
-                if (request.pendingCount > 0)
-                    return true;
-            }
-            return false;
-        }), distinctUntilChanged());
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* ------------------------------------ Store ------------------------------------ */
-    /* ------------------------------------------------------------------------------- */
-    /** Store privato (Subject) */
-    static { this.store = new BehaviorSubject(new Map()); }
-    /** Store pubblico (Observable) */
-    static { this.store$ = UniHttpManager.store.asObservable(); }
-    /** Ottiene lo stato attuale della Map senza dover sottoscrivere l'observable */
-    static get currentValue() {
-        return UniHttpManager.store.getValue();
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* -------------------------------- Metodi: setup -------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /**
-     * Inizializza la configurazione di rete del manager.
-     * Deve essere chiamato prima di effettuare qualsiasi richiesta HTTP.
-     */
-    static setup(hostname, port) {
-        UniHttpManager.hostname = hostname;
-        UniHttpManager.port = port;
-        console.log(UniHttpManager.hostname, UniHttpManager.port);
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* -------------------------------- Metodi: CRUD --------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /*
-     * Esegue una singola richiesta HTTP GET.
-     * Utilizza il path configurato per costruire l'URL completo e restituisce un Observable del risultato.
-     */
-    static read$(config) {
-        /* Config */
-        const initCustom = {
-            ...config.init,
-            method: 'GET',
-        };
-        /* API */
-        console.log('read$', UniHttpManager.hostname, UniHttpManager.port);
-        const url = getUrl(UniHttpManager.hostname, UniHttpManager.port, config);
-        return http$(url, 'one', config, () => executeHttp(url, initCustom)).pipe(tap((res) => {
-            if (Array.isArray(res) && config.toast === undefined) {
-                UniToastManager$1.show({
-                    label: 'ItemsFound',
-                    params: { count: res.length },
-                });
-            }
-        }));
-    }
-    /**
-     * Esegue una richiesta HTTP POST inviando un payload JSON nel corpo della richiesta.
-     * Imposta automaticamente l'header 'Content-Type' come 'application/json'.
-     */
-    static create$(config, body) {
-        /* Config */
-        const initCustom = {
-            ...config.init,
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...config.init?.headers,
-            },
-            body: JSON.stringify(normalizeHttpBody(body)),
-        };
-        /* Config custom (toast di default) */
-        const configCustom = {
-            ...config,
-            toast: config.hasToast === false ? undefined : (config.toast ?? CONFIG_TOAST_DEFAULT),
-        };
-        /* API */
-        console.log('create$', UniHttpManager.hostname, UniHttpManager.port);
-        const url = getUrl(UniHttpManager.hostname, UniHttpManager.port, config);
-        return http$(url, 'one', configCustom, () => executeHttp(url, initCustom));
-    }
-    /**
-     * Esegue una singola richiesta HTTP PUT per aggiornare una risorsa esistente.
-     */
-    static update$(config, body) {
-        /* Config */
-        const initCustom = { ...config.init, method: 'PUT' };
-        if (body !== undefined) {
-            initCustom.headers = {
-                'Content-Type': 'application/json',
-                ...config.init?.headers,
-            };
-            initCustom.body = JSON.stringify(normalizeHttpBody(body));
-        }
-        /* Config custom (toast di default) */
-        const configCustom = {
-            ...config,
-            toast: config.hasToast === false ? undefined : (config.toast ?? CONFIG_TOAST_DEFAULT),
-        };
-        /* API */
-        const url = getUrl(UniHttpManager.hostname, UniHttpManager.port, config);
-        return http$(url, 'one', configCustom, () => executeHttp(url, initCustom));
-    }
-    /**
-     * Esegue una richiesta HTTP DELETE per rimuovere una risorsa.
-     * Utilizza il path configurato per costruire l'URL completo e restituisce un Observable del risultato.
-     */
-    static delete$(config) {
-        /* Config */
-        const initCustom = {
-            ...config.init,
-            method: 'DELETE',
-        };
-        /* Config custom (toast di default) */
-        const configCustom = {
-            ...config,
-            toast: config.hasToast === false ? undefined : (config.toast ?? CONFIG_TOAST_DEFAULT),
-        };
-        /* API */
-        const url = getUrl(UniHttpManager.hostname, UniHttpManager.port, config);
-        return http$(url, 'one', configCustom, () => executeHttp(url, initCustom));
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* -------------------------- 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(UniHttpManager.hostname, UniHttpManager.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(UniHttpManager.hostname, UniHttpManager.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(UniHttpManager.hostname, UniHttpManager.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(UniHttpManager.hostname, UniHttpManager.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(UniHttpManager.hostname, UniHttpManager.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 UniLocaleManager._locale;
-    }
-    /** Restituisce l'array contenente tutti i codici locale supportati.*/
-    static get localesSupported() {
-        return UniLocaleManager._localesSupported;
-    }
-    /** Restituisce solo la lingua (es. 'it') */
-    static get language() {
-        return UniLocaleManager._locale.split('-')[0];
-    }
-    /** Restituisce solo il paese (es. 'IT') */
-    static get region() {
-        const parts = UniLocaleManager._locale.split('-');
-        return parts.length > 1 ? parts[1] : '';
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* ------------------------------------ Store ------------------------------------ */
-    /* ------------------------------------------------------------------------------- */
-    /** Store privato (Subject) */
-    static { this.store = new BehaviorSubject({}); }
-    /** Store pubblico (Observable) */
-    static { this.store$ = UniLocaleManager.store.asObservable(); }
-    /** Ottiene il dizionario attuale senza sottoscrizione */
-    static get currentValue() {
-        return UniLocaleManager.store.getValue();
-    }
-    /* ------------------------------------------------------------------------------- */
-    /* -------------------------------- Metodi: setup -------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /**
-     * Inizializza la configurazione di rete del manager.
-     * Deve essere chiamato prima di effettuare qualsiasi richiesta HTTP.
-     */
-    static setup(locale, prefix) {
-        UniLocaleManager._locale = locale ?? 'en-US';
-        UniLocaleManager._prefix = prefix;
-    }
-    /** Imposta l'elenco dei codici lingua supportati dall'applicazione */
-    static setLocalesSupported(locales) {
-        UniLocaleManager._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) {
-        UniLocaleManager.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 = `${UniLocaleManager._prefix ?? ''}${prefix}${capitalizedKey}`;
-        // Cerca la chiave in minuscolo (standardizzazione)
-        let translation = UniLocaleManager.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(UniLocaleManager._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 UniLocaleManager.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 UniLocaleManager.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(UniLocaleManager._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 && UniLocaleManager._locale.startsWith(force.oldLang)
-            ? force.newLocale
-            : UniLocaleManager._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) {
-        UniToastManager.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$1.translate(config.label, 'toast', config.params);
-        const msgFixed = `${config.prefix ?? ''}${msg}${config.suffix ?? ''}`;
-        UniToastManager.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 { 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 */
-        UniToastManager.show({ ...config, params: allParams });
-    }
-}
-
-/**
- * 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);
-        }
-        // 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);
-    }
-}
-
-/**
- * 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 + UniTypeStringManager.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 = UniTypeStringManager.splitString(fixedKey);
-        if (parts.length === 0)
-            return '';
-        // Converte in PascalCase
-        const pascalCased = UniTypeStringManager.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 = UniTypeStringManager.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 + UniTypeStringManager.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
  */
+const libraryName = 'uni-manager';
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { EmitValueMode, MapOperator, PollingErrorMode, UniErrorManager, UniFileManager, UniHttpManager, UniLocaleManager, UniToastManager, UniTypeDateManager, UniTypeNumberManager, UniTypeStringManager };
+export { libraryName };
 //# sourceMappingURL=uni-manager.mjs.map