uni-manager 0.0.79 → 0.1.1

package/types/uni-manager-http.d.ts

@@ -0,0 +1,126 @@
+import { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';
+import { Observable } from 'rxjs/internal/Observable';
+import { FileDatasource } from 'uni-manager/file';
+import { ToastConfig, ToastHttpConfig } from 'uni-manager/toast';
+
+declare enum MapOperator {
+    /** Cancella la precedente richiesta, mantiene solo l’ultima */
+    SWITCH_MAP = 0,
+    /** Ignora nuovi valori finché la corrente non finisce */
+    EXHAUST_MAP = 1,
+    /** Mette le richieste in coda, le esegue una alla volta */
+    CONCAT_MAP = 2,
+    /** Esegue tutte le richieste in parallelo, ordine non garantito */
+    MERGE_MAP = 3
+}
+declare enum PollingErrorMode {
+    /** Salta questa iterazione emettendo un undefined. Il polling continua al tick successivo. */
+    IGNORE = 0,
+    /** Salta questa iterazione senza emettere valori. Il polling continua al tick successivo. */
+    SKIP = 1,
+    /** Interrompe il polling propagando l'errore. */
+    STOP = 2,
+    /** Ignora l'errore, lo salva (es. per UI), e continua il polling. Emette `undefined`. */
+    IGNORE_WITH_ERROR = 3
+}
+declare enum EmitValueMode {
+    /** Aggiorna lo stato solo se arrivano dati nuovi (distinct) */
+    ON_NEW_DATA = 0,
+    /** Aggiorna lo stato ad ogni chiamata, anche se i dati sono uguali */
+    EVERY_TIME = 1
+}
+
+interface HttpRef {
+    type: 'one' | 'polling' | 'image' | 'file';
+    lineId: number | null | undefined;
+    url: URL;
+    hasError: boolean;
+    pendingCount: number;
+}
+interface HttpConfig<T> {
+    ref: string;
+    path: string;
+    pathParams?: Record<string, any>;
+    init?: RequestInit;
+    toast?: ToastConfig & ToastHttpConfig<T>;
+    hasToast?: boolean;
+    hasLoader?: boolean;
+    hasApiPrefix?: boolean;
+}
+interface HttpConfigPolling<T> {
+    interval: number;
+    ref: string;
+    path: string;
+    pathParams?: Record<string, any>;
+    init?: RequestInit;
+    operator?: MapOperator;
+    errorMode?: PollingErrorMode;
+    emitValueMode?: EmitValueMode;
+    firstIteration?: {
+        toast: NonNullable<HttpConfig<T>['toast']>;
+        hasLoader?: boolean;
+    };
+}
+type HttpBody = Record<string, any> | any[] | string | number | boolean | Date;
+
+declare class UniHttpManager {
+    /** Hostname del server (es. 'api.example.com' o 'localhost') */
+    private static hostname;
+    /** Porta del server su cui effettuare le chiamate (es. 80, 443 o 3000) */
+    private static port;
+    /** Restituisce se lo store ha chiamate in attesa di risposta o meno */
+    static get hasWaitingRequests$(): Observable<boolean>;
+    /** Store privato (Subject) */
+    static store: BehaviorSubject<Map<string, HttpRef>>;
+    /** Store pubblico (Observable) */
+    static store$: Observable<Map<string, HttpRef>>;
+    /** Ottiene lo stato attuale della Map senza dover sottoscrivere l'observable */
+    static get currentValue(): Map<string, HttpRef>;
+    /**
+     * Inizializza la configurazione di rete del manager.
+     * Deve essere chiamato prima di effettuare qualsiasi richiesta HTTP.
+     */
+    static setup(hostname: string, port: number): void;
+    static read$<T>(config: HttpConfig<T>): Observable<T | undefined>;
+    /**
+     * Esegue una richiesta HTTP POST inviando un payload JSON nel corpo della richiesta.
+     * Imposta automaticamente l'header 'Content-Type' come 'application/json'.
+     */
+    static create$<T>(config: HttpConfig<T>, body: HttpBody): Observable<T | undefined>;
+    /**
+     * Esegue una singola richiesta HTTP PUT per aggiornare una risorsa esistente.
+     */
+    static update$<T>(config: HttpConfig<T>, body?: HttpBody): Observable<T | undefined>;
+    /**
+     * 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$<T>(config: HttpConfig<T>): Observable<T | undefined>;
+    /**
+     * 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: HttpConfig<FileDatasource>): Observable<FileDatasource | undefined>;
+    /**
+     * 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: HttpConfig<FileDatasource>): Observable<FileDatasource | undefined>;
+    /**
+     * Avvia un ciclo di polling basato su richieste GET.
+     * Continua a emettere valori in base alla configurazione di intervallo definita in HttpConfigPolling.
+     */
+    static readPolling$<T>(config: HttpConfigPolling<T>): Observable<T | undefined>;
+    /**
+     * Avvia un ciclo di polling basato su richieste POST.
+     * Invia il body specificato a ogni iterazione del ciclo.
+     */
+    static createPolling$<T>(config: HttpConfigPolling<T>, body: HttpBody): Observable<T | undefined>;
+    /**
+     * Avvia un ciclo di polling basato su richieste PUT.
+     */
+    static updatePolling$<T>(config: HttpConfigPolling<T>, body?: HttpBody): Observable<T | undefined>;
+}
+
+export { EmitValueMode, MapOperator, PollingErrorMode, UniHttpManager };
+export type { HttpBody, HttpConfig, HttpConfigPolling, HttpRef };

package/types/uni-manager-locale.d.ts

@@ -0,0 +1,63 @@
+import * as rxjs_internal_Observable from 'rxjs/internal/Observable';
+import { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';
+
+declare class UniLocaleManager {
+    /** Codice lingua corrente (es. 'it-IT', 'en-US') usato per formattare date e numeri */
+    private static _locale;
+    /** Elenco dei codici lingua supportati dall'applicazione (es. ['it-IT', 'en-US']) */
+    private static _localesSupported;
+    /** Prefisso globale applicato a tutte le chiavi di traduzione (es. 'APP_') */
+    private static _prefix;
+    /** Restituisce il codice lingua corrente */
+    static get locale(): string;
+    /** Restituisce l'array contenente tutti i codici locale supportati.*/
+    static get localesSupported(): string[];
+    /** Restituisce solo la lingua (es. 'it') */
+    static get language(): string;
+    /** Restituisce solo il paese (es. 'IT') */
+    static get region(): string;
+    /** Store privato (Subject) */
+    static store: BehaviorSubject<Record<string, string>>;
+    /** Store pubblico (Observable) */
+    static store$: rxjs_internal_Observable.Observable<Record<string, string>>;
+    /** Ottiene il dizionario attuale senza sottoscrizione */
+    static get currentValue(): Record<string, string>;
+    /**
+     * Inizializza la configurazione di rete del manager.
+     * Deve essere chiamato prima di effettuare qualsiasi richiesta HTTP.
+     */
+    static setup(locale: string | null | undefined, prefix?: string): void;
+    /** Imposta l'elenco dei codici lingua supportati dall'applicazione */
+    static setLocalesSupported(locales: string[] | undefined): void;
+    /**
+     * Aggiorna lo store locale con il dizionario delle traduzioni fornito.
+     * Se viene passato undefined, lo store viene inizializzato come oggetto vuoto.
+     */
+    static setTranslations(translations: Record<string, string> | undefined): void;
+    /**
+     * Traduce una label in base al dizionario caricato.
+     * Gestisce la composizione della chiave, i parametri dinamici (interpolazione) e il fallback.
+     */
+    static translate(key: string, prefix?: string, params?: Record<string, string | number | Date>): string;
+    /**
+     * 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: string, splitChar: string): string;
+    /**
+     * 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: number, decimal: number): string;
+    /**
+     * 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: string | Date, mode?: 'date' | 'time' | 'full', force?: {
+        oldLang: string;
+        newLocale: string;
+    }): string;
+}
+
+export { UniLocaleManager };

package/types/uni-manager-toast.d.ts

@@ -0,0 +1,39 @@
+interface IToastManager {
+    success: (message: string, config?: ToastConfig) => void;
+    info: (message: string, config?: ToastConfig) => void;
+    warning: (message: string, config?: ToastConfig) => void;
+    error: (message: string, config?: ToastConfig) => void;
+}
+interface ToastConfig {
+    label: string;
+    params?: Record<string, any>;
+    type?: keyof IToastManager;
+    duration?: number;
+}
+interface ToastHttpConfig<T> {
+    resParams?: (keyof T & string)[];
+    formatters?: Partial<Record<keyof T & string, (val: any) => any>>;
+}
+
+declare class UniToastManager {
+    /** Riferimento interno all'istanza  */
+    private static manager;
+    /**
+     * Inizializza il manager con una serie di operazioni
+     */
+    static setup(operations: IToastManager): void;
+    /**
+     * Mostra un toast di successo basato su una risposta HTTP e una label di traduzione.
+     */
+    static show(config: ToastConfig & {
+        prefix?: string;
+        suffix?: string;
+    }): void;
+    /**
+     * Mostra un toast di successo basato su una risposta HTTP e una label di traduzione.
+     */
+    static showHttp<T>(config: ToastConfig & ToastHttpConfig<T>, res: T | undefined): void;
+}
+
+export { UniToastManager };
+export type { IToastManager, ToastConfig, ToastHttpConfig };

package/types/uni-manager-type.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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.
+ */
+declare class UniTypeDateManager {
+    static toYYYYMMDD(date: Date | string | null | undefined): string;
+}
+
+/**
+ * Utility per la gestione e formattazione di valori numerici.
+ */
+declare class UniTypeNumberManager {
+    /** Applica il padding a un numero o una stringa */
+    static toPad(value: number | string | null | undefined, count: number, character?: string): string;
+    /** Formatta un numero in una versione leggibile (es: 1000 -> 1K, 1000000 -> 1M) */
+    static toTruncateAndAdUdm(value: number, decimalDigits?: number, maxIntegerDigits?: number): string;
+}
+
+/**
+ * Utility per la manipolazione di stringhe
+ */
+declare class UniTypeStringManager {
+    /** Converte una stringa in formato lblPascalCase (es. "user_id" -> "lblUserId") */
+    static toLabelize(key: string | null | undefined, prefix?: string): string;
+    /** Converte una stringa in PascalCase (es. "user_id" -> "UserId") */
+    static toPascalCase(key: string | null | undefined): string;
+    /** Converte una stringa in camelCase (es. "user_id" -> "userId") */
+    static toCamelCase(key: string | null | undefined): string;
+    /** Capitalizza solo la prima lettera della stringa */
+    static toCapitalize(key: string | null | undefined): string;
+    /** Sostituisce sotto-stringhe all'interno della stringa */
+    static toReplace(key: string | null | undefined, values: {
+        searchValue: string;
+        replaceValue: string;
+    }[]): string;
+    private static splitString;
+    private static toPascalCaseParts;
+}
+
+export { UniTypeDateManager, UniTypeNumberManager, UniTypeStringManager };

package/types/uni-manager.d.ts

@@ -1,7 +1,10 @@
 import * as rxjs_internal_Observable from 'rxjs/internal/Observable';
 import { Observable } from 'rxjs/internal/Observable';
-import { IUniFeError, IUniHttpError } from 'uni-error';
+import { IUniFeError } from 'uni-error/fe';
+import { IUniHttpError } from 'uni-error/http';
 import { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';
+import { FileDatasource as FileDatasource$1 } from 'uni-manager/file';
+import { ToastConfig as ToastConfig$1, ToastHttpConfig as ToastHttpConfig$1 } from 'uni-manager/toast';
 
 declare class UniErrorManager {
     /**  Store privato (Subject) */
@@ -75,24 +78,6 @@ declare enum EmitValueMode {
     EVERY_TIME = 1
 }
 
-interface IToastManager {
-    success: (message: string, config?: ToastConfig) => void;
-    info: (message: string, config?: ToastConfig) => void;
-    warning: (message: string, config?: ToastConfig) => void;
-    error: (message: string, config?: ToastConfig) => void;
-}
-interface ToastConfig {
-    label: string;
-    interpolationParams?: Record<string, string | number | Date>;
-    type?: keyof IToastManager;
-    duration?: number;
-}
-interface ToastHttpConfig<T> {
-    resParams?: (keyof T & string)[];
-    resLengthParam?: string;
-    formatters?: Partial<Record<keyof T & string, (val: any) => any>>;
-}
-
 interface HttpRef {
     type: 'one' | 'polling' | 'image' | 'file';
     lineId: number | null | undefined;
@@ -103,17 +88,18 @@ interface HttpRef {
 interface HttpConfig<T> {
     ref: string;
     path: string;
-    params?: Record<string, any>;
+    pathParams?: Record<string, any>;
     init?: RequestInit;
-    toast?: (ToastConfig & ToastHttpConfig<T>) | null;
+    toast?: ToastConfig$1 & ToastHttpConfig$1<T>;
+    hasToast?: boolean;
     hasLoader?: boolean;
     hasApiPrefix?: boolean;
 }
 interface HttpConfigPolling<T> {
-    ref: string;
     interval: number;
+    ref: string;
     path: string;
-    params?: Record<string, any>;
+    pathParams?: Record<string, any>;
     init?: RequestInit;
     operator?: MapOperator;
     errorMode?: PollingErrorMode;
@@ -143,10 +129,6 @@ declare class UniHttpManager {
      * Deve essere chiamato prima di effettuare qualsiasi richiesta HTTP.
      */
     static setup(hostname: string, port: number): void;
-    /**
-     * Imposta o resetta lo stato di errore per una specifica reference.
-     */
-    static updateHasError(id: string, hasError: boolean): void;
     static read$<T>(config: HttpConfig<T>): Observable<T | undefined>;
     /**
      * Esegue una richiesta HTTP POST inviando un payload JSON nel corpo della richiesta.
@@ -166,18 +148,12 @@ declare class UniHttpManager {
      * 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: HttpConfig<{
-        url: string;
-        name: string;
-    }>): Observable<{
-        url: string;
-        name: string;
-    } | undefined>;
+    static readImage$(config: HttpConfig<FileDatasource$1>): Observable<FileDatasource$1 | undefined>;
     /**
      * 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: HttpConfig<FileDatasource>): Observable<FileDatasource | undefined>;
+    static readFile$(config: HttpConfig<FileDatasource$1>): Observable<FileDatasource$1 | undefined>;
     /**
      * Avvia un ciclo di polling basato su richieste GET.
      * Continua a emettere valori in base alla configurazione di intervallo definita in HttpConfigPolling.
@@ -231,7 +207,7 @@ declare class UniLocaleManager {
      * Traduce una label in base al dizionario caricato.
      * Gestisce la composizione della chiave, i parametri dinamici (interpolazione) e il fallback.
      */
-    static translate(key: string, prefix?: string, interpolationParams?: Record<string, string | number | Date>): string;
+    static translate(key: string, prefix?: string, params?: Record<string, string | number | Date>): string;
     /**
      * Traduce una stringa che contiene parametri separati da un carattere specifico.
      * Supporta ora un numero arbitrario di parametri in formato "label/param1/param2"
@@ -253,6 +229,23 @@ declare class UniLocaleManager {
     }): string;
 }
 
+interface IToastManager {
+    success: (message: string, config?: ToastConfig) => void;
+    info: (message: string, config?: ToastConfig) => void;
+    warning: (message: string, config?: ToastConfig) => void;
+    error: (message: string, config?: ToastConfig) => void;
+}
+interface ToastConfig {
+    label: string;
+    params?: Record<string, any>;
+    type?: keyof IToastManager;
+    duration?: number;
+}
+interface ToastHttpConfig<T> {
+    resParams?: (keyof T & string)[];
+    formatters?: Partial<Record<keyof T & string, (val: any) => any>>;
+}
+
 declare class UniToastManager {
     /** Riferimento interno all'istanza  */
     private static manager;
@@ -263,8 +256,7 @@ declare class UniToastManager {
     /**
      * Mostra un toast di successo basato su una risposta HTTP e una label di traduzione.
      */
-    static show(config: Omit<ToastConfig, 'interpolationParams'> & {
-        params?: Record<string, any>;
+    static show(config: ToastConfig & {
         prefix?: string;
         suffix?: string;
     }): void;
@@ -314,4 +306,4 @@ declare class UniTypeStringManager {
 }
 
 export { EmitValueMode, MapOperator, PollingErrorMode, UniErrorManager, UniFileManager, UniHttpManager, UniLocaleManager, UniToastManager, UniTypeDateManager, UniTypeNumberManager, UniTypeStringManager };
-export type { FileDatasource, HttpBody, HttpConfig, HttpConfigPolling, HttpRef, IToastManager, ToastConfig };
+export type { FileDatasource, HttpBody, HttpConfig, HttpConfigPolling, HttpRef, IToastManager, ToastConfig, ToastHttpConfig };