uni-manager 0.0.79 → 0.1.1

package/fesm2022/uni-manager-http.mjs

@@ -0,0 +1,677 @@
+import { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';
+import { map } from 'rxjs/internal/operators/map';
+import { tap } from 'rxjs/internal/operators/tap';
+import { UniToastManager } from 'uni-manager/toast';
+import isEqual from 'lodash-es/isEqual';
+import { defer } from 'rxjs/internal/observable/defer';
+import { from } from 'rxjs/internal/observable/from';
+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 } 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';
+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 } from 'uni-manager/type';
+
+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(err, errorMode, ref) {
+    // 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.add(ref, err);
+                return of();
+            }
+            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;
+    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.showHttp(toast, res);
+                }
+            },
+        }), catchError((err) => {
+            // Aggiorna la ref nella map
+            updateHasError(ref, true);
+            /* Gestione errore */
+            return errorHandler(err, PollingErrorMode.STOP, ref);
+        }), 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.remove(ref);
+                }
+                /* Prima risposta */
+                if (index === 0 && firstIteration?.toast) {
+                    UniToastManager.showHttp(firstIteration.toast, res);
+                }
+            }), catchError((err) => {
+                // Aggiorna la ref nella map
+                updateHasError(ref, true);
+                /* Gestione errore */
+                return errorHandler(err, errorMode, ref);
+            }), 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 {
+        /* 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 ?? '',
+            });
+        }
+    }
+    catch (error) {
+        // Se l'errore è già un UniHttpError (lanciato sopra) bypassa tutto il resto
+        if (error instanceof UniHttpError) {
+            throw 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 per qualsiasi altro tipo di errore sconosciuto
+        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 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 (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.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);
+                }
+                // 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 this.store$.pipe(map((x) => [...x.values()].some((y) => y.pendingCount > 0)));
+    }
+    /* ------------------------------------------------------------------------------- */
+    /* ------------------------------------ Store ------------------------------------ */
+    /* ------------------------------------------------------------------------------- */
+    /** Store privato (Subject) */
+    static { this.store = new BehaviorSubject(new Map()); }
+    /** Store pubblico (Observable) */
+    static { this.store$ = this.store.asObservable(); }
+    /** Ottiene lo stato attuale della Map senza dover sottoscrivere l'observable */
+    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(hostname, port) {
+        this.hostname = hostname;
+        this.port = 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 */
+        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({
+                    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 */
+        const url = getUrl(this.hostname, this.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(this.hostname, this.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(this.hostname, this.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(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));
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { EmitValueMode, MapOperator, PollingErrorMode, UniHttpManager };
+//# sourceMappingURL=uni-manager-http.mjs.map