@gnggln/ng-ui-system 1.0.0-alpha.2 → 1.0.0-alpha.21

package/esm2022/http/lib/components/http/http.service.mjs

@@ -0,0 +1,228 @@
+/**
+ * @module ng-ui-system/http
+ * Central HTTP orchestration service.
+ *
+ * Wraps Angular's `HttpClient` with an automatic pipeline:
+ * - Loader activation via `UiLayoutService`
+ * - Success / error toasts via `UiToastService`
+ * - Debounced toast messages to prevent spam
+ * - Optional BlackBox tracking of every call
+ * - Pluggable custom headers via `UiHeadersProvider`
+ *
+ * @usageNotes
+ * ### Basic GET
+ * ```typescript
+ * const http = inject(UiHttpService);
+ * const endpoint: UiEndpoint = {
+ *   url: '/api/users',
+ *   id: 'users_list',
+ * };
+ * http.get<User[]>(endpoint).subscribe(users => { ... });
+ * ```
+ *
+ * ### POST with success toast
+ * ```typescript
+ * const endpoint: UiEndpoint = {
+ *   url: '/api/users',
+ *   id: 'users_create',
+ *   showSuccess: true,
+ *   messages: { success: 'Utente creato!' },
+ * };
+ * http.post<User>(endpoint, payload).subscribe();
+ * ```
+ *
+ * ### Custom headers provider
+ * ```typescript
+ * // app.config.ts
+ * { provide: UI_HEADERS_PROVIDER, useClass: MyAuthHeaders }
+ * ```
+ */
+import { Injectable, inject } from '@angular/core';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { throwError } from 'rxjs';
+import { catchError, finalize, map } from 'rxjs/operators';
+import { UiHttpMessageHandler } from './http-message.handler';
+import { UI_HTTP_CONFIG, UI_HEADERS_PROVIDER } from './http.tokens';
+import { UiBlackboxService } from '../blackbox/blackbox.service';
+import * as i0 from "@angular/core";
+/**
+ * Central HTTP service with automatic loader, toast, and error handling.
+ *
+ * All toast flags default to `false` — enable them per-endpoint via
+ * `showSuccess: true` and/or `showError: true`.
+ */
+export class UiHttpService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.messageHandler = inject(UiHttpMessageHandler);
+        this.config = inject(UI_HTTP_CONFIG, { optional: true });
+        this.headersProvider = inject(UI_HEADERS_PROVIDER, { optional: true });
+        this.blackbox = inject(UiBlackboxService, { optional: true });
+    }
+    /** Resolved base URL from config token. */
+    get baseUrl() {
+        return this.config?.baseUrl ?? '';
+    }
+    // ── HTTP Methods ───────────────────────────────────────────────────
+    /** Execute a **GET** request. */
+    get(endpoint, options = {}) {
+        return this._request('GET', endpoint, null, options);
+    }
+    /** Execute a **POST** request. */
+    post(endpoint, body, options = {}) {
+        return this._request('POST', endpoint, body, options);
+    }
+    /** Execute a **PUT** request. */
+    put(endpoint, body, options = {}) {
+        return this._request('PUT', endpoint, body, options);
+    }
+    /** Execute a **PATCH** request. */
+    patch(endpoint, body, options = {}) {
+        return this._request('PATCH', endpoint, body, options);
+    }
+    /** Execute a **DELETE** request. */
+    delete(endpoint, body, options = {}) {
+        return this._request('DELETE', endpoint, body ?? null, options);
+    }
+    /**
+     * Download a **binary file** (Blob).
+     *
+     * Applies the same loader / toast pipeline as JSON requests.
+     */
+    download(endpoint, options = {}) {
+        const headers = this.buildHeaders(options.headers);
+        const requestOptions = {
+            headers,
+            params: options.params,
+            observe: 'body',
+            responseType: 'blob',
+        };
+        const url = this.baseUrl + endpoint.url;
+        const startTime = Date.now();
+        const observable = this.http.get(url, requestOptions);
+        return this._handleRequest(observable, endpoint, 'GET', url, startTime);
+    }
+    // ── Manual controls ────────────────────────────────────────────────
+    /** Show a custom success toast (not tied to an endpoint). */
+    showCustomSuccess(message) {
+        this.messageHandler.showCustomSuccess(message);
+    }
+    /** Show a custom error toast (not tied to an endpoint). */
+    showCustomError(message) {
+        this.messageHandler.showCustomError(message);
+    }
+    /** Manually control the loader state. */
+    setLoading(loading) {
+        if (loading) {
+            this.messageHandler.startLoading();
+        }
+        else {
+            this.messageHandler.stopLoading();
+        }
+    }
+    /** Show a success toast for a specific endpoint (manual trigger). */
+    showEndpointSuccess(endpoint) {
+        this.messageHandler.showSuccess(endpoint);
+    }
+    /** Show an error toast for a specific endpoint (manual trigger). */
+    showEndpointError(endpoint, error, fallbackMessage) {
+        this.messageHandler.showError(endpoint, error, fallbackMessage);
+    }
+    /** Cancel all pending debounce timeouts. */
+    clearAllToastTimeouts() {
+        this.messageHandler.clearAllTimeouts();
+    }
+    // ── Internals ──────────────────────────────────────────────────────
+    /**
+     * Generic JSON request handler.
+     * Builds headers, serialises body, and pipes through the common pipeline.
+     */
+    _request(method, endpoint, body, options) {
+        const headers = this.buildHeaders(options.headers);
+        const url = this.baseUrl + endpoint.url;
+        const startTime = Date.now();
+        const requestOptions = {
+            headers,
+            params: options.params,
+            body: body != null ? JSON.stringify(body) : undefined,
+            observe: 'body',
+        };
+        const observable = this.http.request(method, url, requestOptions);
+        return this._handleRequest(observable, endpoint, method, url, startTime);
+    }
+    /**
+     * Common pipeline applied to every HTTP request:
+     * 1. Start loader
+     * 2. On success → show success toast
+     * 3. On error → show error toast, log, re-throw
+     * 4. Always stop loader
+     * 5. Track in BlackBox (if available and endpoint is trackable)
+     */
+    _handleRequest(observable, endpoint, method, url, startTime) {
+        this.messageHandler.startLoading();
+        return observable.pipe(map((response) => {
+            this.messageHandler.showSuccess(endpoint);
+            this.trackBlackbox(method, url, startTime, 200, endpoint);
+            return response;
+        }), catchError((error) => {
+            this.handleErrors(error, endpoint);
+            this.trackBlackbox(method, url, startTime, error.status ?? 0, endpoint);
+            return throwError(() => error);
+        }), finalize(() => this.messageHandler.stopLoading()));
+    }
+    /**
+     * Build the final HttpHeaders by merging:
+     * 1. Default headers from config
+     * 2. Custom headers from UiHeadersProvider
+     * 3. Per-request headers
+     */
+    buildHeaders(requestHeaders) {
+        const defaults = {
+            'Content-Type': 'application/json; charset=utf-8',
+            ...(this.config?.defaultHeaders ?? {}),
+        };
+        // Apply custom headers from provider
+        const custom = this.headersProvider?.getHeaders() ?? {};
+        let headers = new HttpHeaders({ ...defaults, ...custom });
+        // Merge per-request headers
+        if (requestHeaders) {
+            requestHeaders.keys().forEach(key => {
+                const value = requestHeaders.get(key);
+                if (value !== null) {
+                    headers = headers.set(key, value);
+                }
+            });
+        }
+        return headers;
+    }
+    /**
+     * Centralised error handling.
+     * Logs the error and delegates toast display to the message handler.
+     */
+    handleErrors(error, endpoint) {
+        console.error(`[UiHttpService] API Error (${error.status}):`, error.url, error);
+        this.messageHandler.showError(endpoint, error, 'Si è verificato un errore imprevisto');
+    }
+    /**
+     * Track the HTTP call in BlackBox if the service is available
+     * and the endpoint hasn't opted out.
+     */
+    trackBlackbox(method, url, startTime, status, endpoint) {
+        if (!this.blackbox || endpoint.trackable === false)
+            return;
+        this.blackbox.trackHttpCall({
+            timestamp: startTime,
+            method,
+            url,
+            status,
+            durationMs: Date.now() - startTime,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiHttpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiHttpService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiHttpService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/http/http.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @module ng-ui-system/http\r\n * Central HTTP orchestration service.\r\n *\r\n * Wraps Angular's `HttpClient` with an automatic pipeline:\r\n * - Loader activation via `UiLayoutService`\r\n * - Success / error toasts via `UiToastService`\r\n * - Debounced toast messages to prevent spam\r\n * - Optional BlackBox tracking of every call\r\n * - Pluggable custom headers via `UiHeadersProvider`\r\n *\r\n * @usageNotes\r\n * ### Basic GET\r\n * ```typescript\r\n * const http = inject(UiHttpService);\r\n * const endpoint: UiEndpoint = {\r\n *   url: '/api/users',\r\n *   id: 'users_list',\r\n * };\r\n * http.get<User[]>(endpoint).subscribe(users => { ... });\r\n * ```\r\n *\r\n * ### POST with success toast\r\n * ```typescript\r\n * const endpoint: UiEndpoint = {\r\n *   url: '/api/users',\r\n *   id: 'users_create',\r\n *   showSuccess: true,\r\n *   messages: { success: 'Utente creato!' },\r\n * };\r\n * http.post<User>(endpoint, payload).subscribe();\r\n * ```\r\n *\r\n * ### Custom headers provider\r\n * ```typescript\r\n * // app.config.ts\r\n * { provide: UI_HEADERS_PROVIDER, useClass: MyAuthHeaders }\r\n * ```\r\n */\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { HttpClient, HttpErrorResponse, HttpHeaders } from '@angular/common/http';\r\nimport { Observable, throwError } from 'rxjs';\r\nimport { catchError, finalize, map } from 'rxjs/operators';\r\n\r\nimport type { UiEndpoint } from '../../core/types/index';\r\nimport { UiHttpMessageHandler } from './http-message.handler';\r\nimport { UI_HTTP_CONFIG, UI_HEADERS_PROVIDER } from './http.tokens';\r\nimport { UiBlackboxService } from '../blackbox/blackbox.service';\r\n\r\n/**\r\n * Central HTTP service with automatic loader, toast, and error handling.\r\n *\r\n * All toast flags default to `false` — enable them per-endpoint via\r\n * `showSuccess: true` and/or `showError: true`.\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiHttpService {\r\n    private readonly http = inject(HttpClient);\r\n    private readonly messageHandler = inject(UiHttpMessageHandler);\r\n    private readonly config = inject(UI_HTTP_CONFIG, { optional: true });\r\n    private readonly headersProvider = inject(UI_HEADERS_PROVIDER, { optional: true });\r\n    private readonly blackbox = inject(UiBlackboxService, { optional: true });\r\n\r\n    /** Resolved base URL from config token. */\r\n    private get baseUrl(): string {\r\n        return this.config?.baseUrl ?? '';\r\n    }\r\n\r\n    // ── HTTP Methods ───────────────────────────────────────────────────\r\n\r\n    /** Execute a **GET** request. */\r\n    get<T>(endpoint: UiEndpoint, options: { headers?: HttpHeaders; params?: any } = {}): Observable<T> {\r\n        return this._request<T>('GET', endpoint, null, options);\r\n    }\r\n\r\n    /** Execute a **POST** request. */\r\n    post<T>(endpoint: UiEndpoint, body: unknown, options: { headers?: HttpHeaders; params?: any } = {}): Observable<T> {\r\n        return this._request<T>('POST', endpoint, body, options);\r\n    }\r\n\r\n    /** Execute a **PUT** request. */\r\n    put<T>(endpoint: UiEndpoint, body: unknown, options: { headers?: HttpHeaders; params?: any } = {}): Observable<T> {\r\n        return this._request<T>('PUT', endpoint, body, options);\r\n    }\r\n\r\n    /** Execute a **PATCH** request. */\r\n    patch<T>(endpoint: UiEndpoint, body: unknown, options: { headers?: HttpHeaders; params?: any } = {}): Observable<T> {\r\n        return this._request<T>('PATCH', endpoint, body, options);\r\n    }\r\n\r\n    /** Execute a **DELETE** request. */\r\n    delete<T>(endpoint: UiEndpoint, body?: unknown, options: { headers?: HttpHeaders; params?: any } = {}): Observable<T> {\r\n        return this._request<T>('DELETE', endpoint, body ?? null, options);\r\n    }\r\n\r\n    /**\r\n     * Download a **binary file** (Blob).\r\n     *\r\n     * Applies the same loader / toast pipeline as JSON requests.\r\n     */\r\n    download(endpoint: UiEndpoint, options: { headers?: HttpHeaders; params?: any } = {}): Observable<Blob> {\r\n        const headers = this.buildHeaders(options.headers);\r\n        const requestOptions = {\r\n            headers,\r\n            params: options.params,\r\n            observe: 'body' as const,\r\n            responseType: 'blob' as const,\r\n        };\r\n        const url = this.baseUrl + endpoint.url;\r\n        const startTime = Date.now();\r\n\r\n        const observable = this.http.get(url, requestOptions);\r\n\r\n        return this._handleRequest(observable, endpoint, 'GET', url, startTime);\r\n    }\r\n\r\n    // ── Manual controls ────────────────────────────────────────────────\r\n\r\n    /** Show a custom success toast (not tied to an endpoint). */\r\n    showCustomSuccess(message: string): void {\r\n        this.messageHandler.showCustomSuccess(message);\r\n    }\r\n\r\n    /** Show a custom error toast (not tied to an endpoint). */\r\n    showCustomError(message: string): void {\r\n        this.messageHandler.showCustomError(message);\r\n    }\r\n\r\n    /** Manually control the loader state. */\r\n    setLoading(loading: boolean): void {\r\n        if (loading) {\r\n            this.messageHandler.startLoading();\r\n        } else {\r\n            this.messageHandler.stopLoading();\r\n        }\r\n    }\r\n\r\n    /** Show a success toast for a specific endpoint (manual trigger). */\r\n    showEndpointSuccess(endpoint: UiEndpoint): void {\r\n        this.messageHandler.showSuccess(endpoint);\r\n    }\r\n\r\n    /** Show an error toast for a specific endpoint (manual trigger). */\r\n    showEndpointError(endpoint: UiEndpoint, error?: any, fallbackMessage?: string): void {\r\n        this.messageHandler.showError(endpoint, error, fallbackMessage);\r\n    }\r\n\r\n    /** Cancel all pending debounce timeouts. */\r\n    clearAllToastTimeouts(): void {\r\n        this.messageHandler.clearAllTimeouts();\r\n    }\r\n\r\n    // ── Internals ──────────────────────────────────────────────────────\r\n\r\n    /**\r\n     * Generic JSON request handler.\r\n     * Builds headers, serialises body, and pipes through the common pipeline.\r\n     */\r\n    private _request<T>(\r\n        method: string,\r\n        endpoint: UiEndpoint,\r\n        body: unknown,\r\n        options: { headers?: HttpHeaders; params?: any },\r\n    ): Observable<T> {\r\n        const headers = this.buildHeaders(options.headers);\r\n        const url = this.baseUrl + endpoint.url;\r\n        const startTime = Date.now();\r\n\r\n        const requestOptions: Record<string, any> = {\r\n            headers,\r\n            params: options.params,\r\n            body: body != null ? JSON.stringify(body) : undefined,\r\n            observe: 'body' as const,\r\n        };\r\n\r\n        const observable = this.http.request<T>(method, url, requestOptions);\r\n        return this._handleRequest(observable, endpoint, method, url, startTime);\r\n    }\r\n\r\n    /**\r\n     * Common pipeline applied to every HTTP request:\r\n     * 1. Start loader\r\n     * 2. On success → show success toast\r\n     * 3. On error → show error toast, log, re-throw\r\n     * 4. Always stop loader\r\n     * 5. Track in BlackBox (if available and endpoint is trackable)\r\n     */\r\n    private _handleRequest<T>(\r\n        observable: Observable<T>,\r\n        endpoint: UiEndpoint,\r\n        method: string,\r\n        url: string,\r\n        startTime: number,\r\n    ): Observable<T> {\r\n        this.messageHandler.startLoading();\r\n\r\n        return observable.pipe(\r\n            map((response) => {\r\n                this.messageHandler.showSuccess(endpoint);\r\n                this.trackBlackbox(method, url, startTime, 200, endpoint);\r\n                return response;\r\n            }),\r\n            catchError((error: HttpErrorResponse) => {\r\n                this.handleErrors(error, endpoint);\r\n                this.trackBlackbox(method, url, startTime, error.status ?? 0, endpoint);\r\n                return throwError(() => error);\r\n            }),\r\n            finalize(() => this.messageHandler.stopLoading()),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Build the final HttpHeaders by merging:\r\n     * 1. Default headers from config\r\n     * 2. Custom headers from UiHeadersProvider\r\n     * 3. Per-request headers\r\n     */\r\n    private buildHeaders(requestHeaders?: HttpHeaders): HttpHeaders {\r\n        const defaults: Record<string, string> = {\r\n            'Content-Type': 'application/json; charset=utf-8',\r\n            ...(this.config?.defaultHeaders ?? {}),\r\n        };\r\n\r\n        // Apply custom headers from provider\r\n        const custom = this.headersProvider?.getHeaders() ?? {};\r\n\r\n        let headers = new HttpHeaders({ ...defaults, ...custom });\r\n\r\n        // Merge per-request headers\r\n        if (requestHeaders) {\r\n            requestHeaders.keys().forEach(key => {\r\n                const value = requestHeaders.get(key);\r\n                if (value !== null) {\r\n                    headers = headers.set(key, value);\r\n                }\r\n            });\r\n        }\r\n\r\n        return headers;\r\n    }\r\n\r\n    /**\r\n     * Centralised error handling.\r\n     * Logs the error and delegates toast display to the message handler.\r\n     */\r\n    private handleErrors(error: HttpErrorResponse, endpoint: UiEndpoint): void {\r\n        console.error(`[UiHttpService] API Error (${error.status}):`, error.url, error);\r\n        this.messageHandler.showError(endpoint, error, 'Si è verificato un errore imprevisto');\r\n    }\r\n\r\n    /**\r\n     * Track the HTTP call in BlackBox if the service is available\r\n     * and the endpoint hasn't opted out.\r\n     */\r\n    private trackBlackbox(\r\n        method: string,\r\n        url: string,\r\n        startTime: number,\r\n        status: number,\r\n        endpoint: UiEndpoint,\r\n    ): void {\r\n        if (!this.blackbox || endpoint.trackable === false) return;\r\n\r\n        this.blackbox.trackHttpCall({\r\n            timestamp: startTime,\r\n            method,\r\n            url,\r\n            status,\r\n            durationMs: Date.now() - startTime,\r\n        });\r\n    }\r\n}\r\n"]}

package/esm2022/http/lib/components/http/http.tokens.mjs

@@ -0,0 +1,29 @@
+/**
+ * @module ng-ui-system/http
+ * Injection tokens for the HTTP orchestration service.
+ */
+import { InjectionToken } from '@angular/core';
+/**
+ * Optional global configuration for `UiHttpService`.
+ *
+ * @usageNotes
+ * ```typescript
+ * providers: [
+ *   { provide: UI_HTTP_CONFIG, useValue: { baseUrl: '/api' } },
+ * ]
+ * ```
+ */
+export const UI_HTTP_CONFIG = new InjectionToken('UI_HTTP_CONFIG');
+/**
+ * Optional headers provider for injecting custom headers (auth, correlation, etc.)
+ * into every HTTP request.
+ *
+ * @usageNotes
+ * ```typescript
+ * providers: [
+ *   { provide: UI_HEADERS_PROVIDER, useClass: MyAuthHeadersProvider },
+ * ]
+ * ```
+ */
+export const UI_HEADERS_PROVIDER = new InjectionToken('UI_HEADERS_PROVIDER');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC50b2tlbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy11aS1zeXN0ZW0vc3JjL2xpYi9jb21wb25lbnRzL2h0dHAvaHR0cC50b2tlbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUcvQzs7Ozs7Ozs7O0dBU0c7QUFDSCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsSUFBSSxjQUFjLENBQWUsZ0JBQWdCLENBQUMsQ0FBQztBQUVqRjs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxjQUFjLENBQW9CLHFCQUFxQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQG1vZHVsZSBuZy11aS1zeXN0ZW0vaHR0cFxyXG4gKiBJbmplY3Rpb24gdG9rZW5zIGZvciB0aGUgSFRUUCBvcmNoZXN0cmF0aW9uIHNlcnZpY2UuXHJcbiAqL1xyXG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgdHlwZSB7IFVpSHR0cENvbmZpZywgVWlIZWFkZXJzUHJvdmlkZXIgfSBmcm9tICcuL2h0dHAudHlwZXMnO1xyXG5cclxuLyoqXHJcbiAqIE9wdGlvbmFsIGdsb2JhbCBjb25maWd1cmF0aW9uIGZvciBgVWlIdHRwU2VydmljZWAuXHJcbiAqXHJcbiAqIEB1c2FnZU5vdGVzXHJcbiAqIGBgYHR5cGVzY3JpcHRcclxuICogcHJvdmlkZXJzOiBbXHJcbiAqICAgeyBwcm92aWRlOiBVSV9IVFRQX0NPTkZJRywgdXNlVmFsdWU6IHsgYmFzZVVybDogJy9hcGknIH0gfSxcclxuICogXVxyXG4gKiBgYGBcclxuICovXHJcbmV4cG9ydCBjb25zdCBVSV9IVFRQX0NPTkZJRyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxVaUh0dHBDb25maWc+KCdVSV9IVFRQX0NPTkZJRycpO1xyXG5cclxuLyoqXHJcbiAqIE9wdGlvbmFsIGhlYWRlcnMgcHJvdmlkZXIgZm9yIGluamVjdGluZyBjdXN0b20gaGVhZGVycyAoYXV0aCwgY29ycmVsYXRpb24sIGV0Yy4pXHJcbiAqIGludG8gZXZlcnkgSFRUUCByZXF1ZXN0LlxyXG4gKlxyXG4gKiBAdXNhZ2VOb3Rlc1xyXG4gKiBgYGB0eXBlc2NyaXB0XHJcbiAqIHByb3ZpZGVyczogW1xyXG4gKiAgIHsgcHJvdmlkZTogVUlfSEVBREVSU19QUk9WSURFUiwgdXNlQ2xhc3M6IE15QXV0aEhlYWRlcnNQcm92aWRlciB9LFxyXG4gKiBdXHJcbiAqIGBgYFxyXG4gKi9cclxuZXhwb3J0IGNvbnN0IFVJX0hFQURFUlNfUFJPVklERVIgPSBuZXcgSW5qZWN0aW9uVG9rZW48VWlIZWFkZXJzUHJvdmlkZXI+KCdVSV9IRUFERVJTX1BST1ZJREVSJyk7XHJcbiJdfQ==

package/esm2022/http/lib/components/http/http.types.mjs

@@ -0,0 +1,6 @@
+/**
+ * @module ng-ui-system/http
+ * Types and interfaces for the HTTP orchestration service.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/http/lib/components/http/index.mjs

@@ -0,0 +1,19 @@
+/**
+ * ng-ui-system — HTTP Orchestration Service entry point.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   UiHttpService,
+ *   UiHttpMessageHandler,
+ *   UI_HTTP_CONFIG,
+ *   UI_HEADERS_PROVIDER,
+ * } from '@gnggln/ng-ui-system';
+ * ```
+ */
+// Services
+export { UiHttpService } from './http.service';
+export { UiHttpMessageHandler } from './http-message.handler';
+// Tokens
+export { UI_HTTP_CONFIG, UI_HEADERS_PROVIDER } from './http.tokens';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy11aS1zeXN0ZW0vc3JjL2xpYi9jb21wb25lbnRzL2h0dHAvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7OztHQVlHO0FBRUgsV0FBVztBQUNYLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUMvQyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUU5RCxTQUFTO0FBQ1QsT0FBTyxFQUFFLGNBQWMsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBuZy11aS1zeXN0ZW0g4oCUIEhUVFAgT3JjaGVzdHJhdGlvbiBTZXJ2aWNlIGVudHJ5IHBvaW50LlxyXG4gKlxyXG4gKiBAZXhhbXBsZVxyXG4gKiBgYGB0eXBlc2NyaXB0XHJcbiAqIGltcG9ydCB7XHJcbiAqICAgVWlIdHRwU2VydmljZSxcclxuICogICBVaUh0dHBNZXNzYWdlSGFuZGxlcixcclxuICogICBVSV9IVFRQX0NPTkZJRyxcclxuICogICBVSV9IRUFERVJTX1BST1ZJREVSLFxyXG4gKiB9IGZyb20gJ0BnbmdnbG4vbmctdWktc3lzdGVtJztcclxuICogYGBgXHJcbiAqL1xyXG5cclxuLy8gU2VydmljZXNcclxuZXhwb3J0IHsgVWlIdHRwU2VydmljZSB9IGZyb20gJy4vaHR0cC5zZXJ2aWNlJztcclxuZXhwb3J0IHsgVWlIdHRwTWVzc2FnZUhhbmRsZXIgfSBmcm9tICcuL2h0dHAtbWVzc2FnZS5oYW5kbGVyJztcclxuXHJcbi8vIFRva2Vuc1xyXG5leHBvcnQgeyBVSV9IVFRQX0NPTkZJRywgVUlfSEVBREVSU19QUk9WSURFUiB9IGZyb20gJy4vaHR0cC50b2tlbnMnO1xyXG5cclxuLy8gVHlwZXNcclxuZXhwb3J0IHR5cGUgeyBVaUh0dHBDb25maWcsIFVpSGVhZGVyc1Byb3ZpZGVyIH0gZnJvbSAnLi9odHRwLnR5cGVzJztcclxuIl19

package/esm2022/http/lib/components/layout-builder/layout-builder.types.mjs

@@ -0,0 +1,9 @@
+/**
+ * @module ng-ui-system/layout-builder
+ * Types and interfaces for the UiLayoutBuilder shell component.
+ *
+ * The layout builder uses a schema-driven approach (similar to UiFormBuilder)
+ * to materialize a full responsive application shell from a single descriptor.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layout-builder.types.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/layout-builder/layout-builder.types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG","sourcesContent":["/**\r\n * @module ng-ui-system/layout-builder\r\n * Types and interfaces for the UiLayoutBuilder shell component.\r\n *\r\n * The layout builder uses a schema-driven approach (similar to UiFormBuilder)\r\n * to materialize a full responsive application shell from a single descriptor.\r\n */\r\n\r\nimport { UiIconName, UiVariant } from '../../core/types/index';\r\n\r\n// ─── Layout Mode & Content Type ──────────────────────────────────────\r\n\r\n/** Layout mode controlling the overall navigation strategy. */\r\nexport type UiLayoutMode = 'sidebar' | 'topbar' | 'slotted';\r\n\r\n/** Content area sizing strategy. */\r\nexport type UiContentType = 'fluid' | 'boxed' | 'fullscreen';\r\n\r\n// ─── Breadcrumb ──────────────────────────────────────────────────────\r\n\r\n/** Single breadcrumb entry derived from the navigation schema. */\r\nexport interface UiLayoutBreadcrumb {\r\n  /** Display label. */\r\n  label: string;\r\n  /** Route URL (omitted for the current/last crumb). */\r\n  url?: string;\r\n  /** Whether this is the last (current) breadcrumb in the trail. */\r\n  isLast: boolean;\r\n}\r\n\r\n// ─── Navigation ──────────────────────────────────────────────────────\r\n\r\n/** Discriminator for navigation item behaviour. */\r\nexport type UiNavItemType = 'route' | 'external' | 'divider';\r\n\r\n/**\r\n * Single navigation item descriptor.\r\n *\r\n * @usageNotes\r\n * ### Internal route\r\n * ```typescript\r\n * { id: 'users', label: 'Utenti', icon: 'users', route: '/users' }\r\n * ```\r\n *\r\n * ### External link\r\n * ```typescript\r\n * { id: 'docs', label: 'Docs', icon: 'external-link', type: 'external',\r\n *   href: 'https://docs.example.com', target: '_blank' }\r\n * ```\r\n *\r\n * ### Expandable with children\r\n * ```typescript\r\n * {\r\n *   id: 'form-builder', label: 'Form Builder', icon: 'file-text',\r\n *   route: '/form-builder',\r\n *   children: [\r\n *     { label: 'Panoramica', items: [\r\n *       { id: 'fb-all', label: 'Tutti i campi', route: '/form-builder/all-fields' }\r\n *     ]}\r\n *   ]\r\n * }\r\n * ```\r\n */\r\nexport interface UiNavItem {\r\n  /** Unique item identifier. */\r\n  id: string;\r\n  /** Display label. */\r\n  label: string;\r\n  /** Lucide icon name. */\r\n  icon?: UiIconName;\r\n  /** Item behaviour type. @default 'route' */\r\n  type?: UiNavItemType;\r\n  /** Angular router path (for `type: 'route'`). */\r\n  route?: string;\r\n  /** Whether to use exact matching for active state. @default false */\r\n  routeActiveExact?: boolean;\r\n  /** External URL (for `type: 'external'`). */\r\n  href?: string;\r\n  /** Link target for external links. @default '_blank' */\r\n  target?: '_blank' | '_self';\r\n  /** Nested child groups for expandable navigation. */\r\n  children?: UiNavGroup[];\r\n  /** Whether this item is hidden. @default false */\r\n  hidden?: boolean;\r\n  /** Badge text or count displayed next to the label. */\r\n  badge?: string | number;\r\n  /** Whether to include this item in the mobile bottom navigation bar. @default false */\r\n  bottomNav?: boolean;\r\n  /** Sort order in the bottom navigation bar (lower = first). */\r\n  bottomNavOrder?: number;\r\n}\r\n\r\n/**\r\n * Labelled group of navigation items (nested under a parent `UiNavItem`).\r\n *\r\n * @usageNotes\r\n * ```typescript\r\n * const group: UiNavGroup = {\r\n *   label: 'Validazioni',\r\n *   items: [\r\n *     { id: 'v-std', label: 'Standard', route: '/form-builder/validations-standard' },\r\n *     { id: 'v-cross', label: 'Cross-field', route: '/form-builder/validations-crossfield' },\r\n *   ]\r\n * };\r\n * ```\r\n */\r\nexport interface UiNavGroup {\r\n  /** Group heading displayed above the items. */\r\n  label: string;\r\n  /** Items belonging to this group. */\r\n  items: UiNavItem[];\r\n}\r\n\r\n/**\r\n * Top-level grouping used to partition `UiNavItem[]` into labelled sections\r\n * in the sidebar (e.g. \"Overview\", \"Components\").\r\n */\r\nexport interface UiNavSection {\r\n  /** Unique section identifier. */\r\n  id: string;\r\n  /** Section heading displayed in the sidebar. */\r\n  label: string;\r\n  /** IDs of `UiNavItem`s belonging to this section (order preserved). */\r\n  itemIds: string[];\r\n}\r\n\r\n/**\r\n * Auto-discovery configuration for generating navigation items from Angular routes.\r\n *\r\n * When enabled, the layout builder scans the route tree and creates\r\n * `UiNavItem` entries from routes that declare `data.id` and `data.title`.\r\n */\r\nexport interface UiNavAutoDiscoveryConfig {\r\n  /** Whether auto-discovery is enabled. */\r\n  enabled: boolean;\r\n  /** Route paths to exclude from discovery (exact match). */\r\n  excludePaths?: string[];\r\n  /** How to merge discovered items with manually defined items. @default 'append' */\r\n  mergeStrategy?: 'prepend' | 'append' | 'replace';\r\n}\r\n\r\n/** Navigation configuration block within `UiLayoutSchema`. */\r\nexport interface UiLayoutNavigationConfig {\r\n  /** Flat list of all navigation items. */\r\n  items: UiNavItem[];\r\n  /** Optional grouping into labelled sidebar sections. */\r\n  sections?: UiNavSection[];\r\n  /** Whether the desktop sidebar can collapse to icon-only mode. @default true */\r\n  collapsible?: boolean;\r\n  /** Mobile navigation behaviour. @default 'both' */\r\n  mobileMode?: 'drawer' | 'bottom-nav' | 'both';\r\n  /** Auto-discovery settings for route-driven navigation. */\r\n  autoDiscovery?: UiNavAutoDiscoveryConfig;\r\n}\r\n\r\n// ─── Header ──────────────────────────────────────────────────────────\r\n\r\n/** Logo configuration for the layout header. */\r\nexport interface UiLayoutLogo {\r\n  /** Short text rendered inside a styled badge (e.g. \"UI\"). Mutually exclusive with `src`. */\r\n  text?: string;\r\n  /** Image URL for the logo. Mutually exclusive with `text`. */\r\n  src?: string;\r\n  /** Alt text for the logo image. */\r\n  alt?: string;\r\n}\r\n\r\n/** Header / top-bar configuration. */\r\nexport interface UiLayoutHeaderConfig {\r\n  /** Logo displayed in the sidebar header and mobile top-bar. */\r\n  logo?: UiLayoutLogo;\r\n  /** Application title. */\r\n  title: string;\r\n  /** Optional subtitle or tagline. */\r\n  subtitle?: string;\r\n}\r\n\r\n// ─── Footer ──────────────────────────────────────────────────────────\r\n\r\n/** Single link rendered in the layout footer. */\r\nexport interface UiFooterLink {\r\n  /** Display label. */\r\n  label: string;\r\n  /** External URL. */\r\n  href?: string;\r\n  /** Angular router path (alternative to `href`). */\r\n  route?: string;\r\n  /** Lucide icon name. */\r\n  icon?: UiIconName;\r\n  /** Link target for external links. @default '_self' */\r\n  target?: '_blank' | '_self';\r\n}\r\n\r\n/** Footer configuration. */\r\nexport interface UiLayoutFooterConfig {\r\n  /** Links rendered in the footer. */\r\n  links?: UiFooterLink[];\r\n  /** Static text (e.g. copyright, version). */\r\n  text?: string;\r\n}\r\n\r\n// ─── FAB (Floating Action Button / Speed Dial) ───────────────────────\r\n\r\n/**\r\n * Single action within the speed-dial FAB.\r\n *\r\n * @usageNotes\r\n * ```typescript\r\n * const action: UiFabAction = {\r\n *   id: 'new-user',\r\n *   label: 'Nuovo utente',\r\n *   icon: 'user',\r\n *   variant: 'primary',\r\n *   action: () => router.navigate(['/users/new']),\r\n * };\r\n * ```\r\n */\r\nexport interface UiFabAction {\r\n  /** Unique action identifier. */\r\n  id: string;\r\n  /** Tooltip / label text. */\r\n  label: string;\r\n  /** Lucide icon name. */\r\n  icon: UiIconName;\r\n  /** Callback invoked on click. */\r\n  action?: () => void;\r\n  /** Visual variant for the button. @default 'primary' */\r\n  variant?: UiVariant;\r\n  /** Accessible label (falls back to `label` if omitted). */\r\n  ariaLabel?: string;\r\n}\r\n\r\n/** Speed-dial FAB configuration. */\r\nexport interface UiLayoutFabConfig {\r\n  /** Primary FAB action (always visible). */\r\n  mainAction: UiFabAction;\r\n  /** Secondary actions revealed on expand. */\r\n  secondaryActions?: UiFabAction[];\r\n  /** Screen corner position. @default 'bottom-right' */\r\n  position?: 'bottom-right' | 'bottom-left';\r\n}\r\n\r\n// ─── Page Header ─────────────────────────────────────────────────────\r\n\r\n/** Default page-header settings applied to every route unless overridden. */\r\nexport interface UiLayoutPageHeaderConfig {\r\n  /** Whether to show the page header (breadcrumbs + title). @default true */\r\n  show?: boolean;\r\n  /** Home breadcrumb route path. @default '/' */\r\n  homeRoute?: string;\r\n  /** Whether to show the Home link in breadcrumbs. @default true */\r\n  showHome?: boolean;\r\n  /** Whether to sync `document.title` with the current page. @default false */\r\n  updateDocumentTitle?: boolean;\r\n  /** Suffix appended to `document.title`. */\r\n  titleSuffix?: string;\r\n}\r\n\r\n// ─── Loader ──────────────────────────────────────────────────────────\r\n\r\n/** Overlay loader configuration. */\r\nexport interface UiLayoutLoaderConfig {\r\n  /** Show the loader when the layout mounts (hides on first NavigationEnd). @default false */\r\n  showOnInit?: boolean;\r\n  /** Minimum display duration in milliseconds (prevents flicker). @default 0 */\r\n  minDuration?: number;\r\n}\r\n\r\n// ─── Topbar (multi-bar header) ───────────────────────────────────────\r\n\r\n/** Discriminator for topbar bar type. */\r\nexport type UiBarType = 'notification' | 'brand' | 'navigation' | 'links';\r\n\r\n/**\r\n * Notification bar displayed at the top of the page.\r\n *\r\n * @usageNotes\r\n * ```typescript\r\n * { text: 'Manutenzione prevista alle 22:00', variant: 'warn', dismissible: true }\r\n * ```\r\n */\r\nexport interface UiNotificationBarConfig {\r\n  /** Notification message text. */\r\n  text: string;\r\n  /** Visual variant. @default 'primary' */\r\n  variant?: UiVariant;\r\n  /** Whether the user can dismiss this bar. @default true */\r\n  dismissible?: boolean;\r\n  /** Lucide icon shown before the text. */\r\n  icon?: UiIconName;\r\n}\r\n\r\n/**\r\n * Brand bar with logo, title, and optional user dropdown.\r\n *\r\n * @usageNotes\r\n * ```typescript\r\n * {\r\n *   logo: { src: '/assets/logo.svg', alt: 'My App' },\r\n *   title: 'My App',\r\n *   userDropdown: {\r\n *     label: 'Mario Rossi',\r\n *     avatar: { src: '/avatar.jpg' },\r\n *     items: [\r\n *       { id: 'profile', label: 'Profilo', icon: 'user', route: '/profile' },\r\n *       { id: 'logout', label: 'Logout', icon: 'log-out', action: () => auth.logout() },\r\n *     ],\r\n *   },\r\n * }\r\n * ```\r\n */\r\nexport interface UiBrandBarConfig {\r\n  /** Logo displayed on the left. */\r\n  logo?: UiLayoutLogo;\r\n  /** Application title. */\r\n  title?: string;\r\n  /** User dropdown aligned to the right. */\r\n  userDropdown?: UiUserDropdownConfig;\r\n}\r\n\r\n/** User dropdown menu configuration for the brand bar. */\r\nexport interface UiUserDropdownConfig {\r\n  /** Display label (e.g. user's name). */\r\n  label: string;\r\n  /** Lucide icon name (fallback when no avatar). */\r\n  icon?: UiIconName;\r\n  /** User avatar image. */\r\n  avatar?: { src: string; alt?: string };\r\n  /** Dropdown menu items. */\r\n  items: UiDropdownItem[];\r\n}\r\n\r\n/** Single item in a dropdown menu. */\r\nexport interface UiDropdownItem {\r\n  /** Unique item identifier. */\r\n  id: string;\r\n  /** Display label. */\r\n  label: string;\r\n  /** Lucide icon name. */\r\n  icon?: UiIconName;\r\n  /** Angular router path. */\r\n  route?: string;\r\n  /** Callback invoked on click. */\r\n  action?: () => void;\r\n  /** Render a divider above this item. */\r\n  divider?: boolean;\r\n}\r\n\r\n/** Navigation bar (used in topbar mode to render horizontal nav links). */\r\nexport interface UiNavigationBarConfig {\r\n  /** Override items for this bar (defaults to `schema.navigation.items`). */\r\n  items?: UiNavItem[];\r\n}\r\n\r\n/**\r\n * Links bar with icon links (e.g. social media, external resources).\r\n *\r\n * @usageNotes\r\n * ```typescript\r\n * {\r\n *   align: 'end',\r\n *   items: [\r\n *     { icon: 'github', href: 'https://github.com/...', ariaLabel: 'GitHub' },\r\n *     { label: 'Docs', icon: 'book-open', href: 'https://docs.example.com' },\r\n *   ],\r\n * }\r\n * ```\r\n */\r\nexport interface UiLinksBarConfig {\r\n  /** Horizontal alignment of items. @default 'end' */\r\n  align?: 'start' | 'center' | 'end' | 'space-between';\r\n  /** Link items. */\r\n  items: UiBarLinkItem[];\r\n}\r\n\r\n/** Single link item in a links bar. */\r\nexport interface UiBarLinkItem {\r\n  /** Display label (optional, icon-only if omitted). */\r\n  label?: string;\r\n  /** Lucide icon name. */\r\n  icon?: UiIconName;\r\n  /** External URL. */\r\n  href?: string;\r\n  /** Angular router path. */\r\n  route?: string;\r\n  /** Link target. @default '_self' */\r\n  target?: '_blank' | '_self';\r\n  /** Accessible label for icon-only items. */\r\n  ariaLabel?: string;\r\n}\r\n\r\n/**\r\n * Single bar descriptor in the topbar bar stack.\r\n *\r\n * @usageNotes\r\n * ```typescript\r\n * const bars: UiBarConfig[] = [\r\n *   { id: 'promo', type: 'notification', notification: { text: 'Promo attiva!', dismissible: true } },\r\n *   { id: 'main', type: 'brand', brand: { logo: { text: 'UI' }, title: 'My App' } },\r\n *   { id: 'nav', type: 'navigation' },\r\n *   { id: 'social', type: 'links', links: { align: 'end', items: [...] } },\r\n * ];\r\n * ```\r\n */\r\nexport interface UiBarConfig {\r\n  /** Unique bar identifier. */\r\n  id: string;\r\n  /** Bar type discriminator. */\r\n  type: UiBarType;\r\n  /** Whether the bar is initially visible. @default true */\r\n  visible?: boolean;\r\n  /** Configuration when `type === 'notification'`. */\r\n  notification?: UiNotificationBarConfig;\r\n  /** Configuration when `type === 'brand'`. */\r\n  brand?: UiBrandBarConfig;\r\n  /** Configuration when `type === 'navigation'`. */\r\n  navigation?: UiNavigationBarConfig;\r\n  /** Configuration when `type === 'links'`. */\r\n  links?: UiLinksBarConfig;\r\n}\r\n\r\n/** Topbar configuration (bar stack). */\r\nexport interface UiTopbarConfig {\r\n  /** Ordered list of bars rendered top-to-bottom. */\r\n  bars: UiBarConfig[];\r\n}\r\n\r\n// ─── Root Schema ─────────────────────────────────────────────────────\r\n\r\n/**\r\n * Root descriptor for the `ui-layout-builder` component.\r\n *\r\n * @usageNotes\r\n * ### Minimal sidebar example\r\n * ```typescript\r\n * const schema: UiLayoutSchema = {\r\n *   header: { title: 'My App' },\r\n *   navigation: {\r\n *     items: [\r\n *       { id: 'home', label: 'Home', icon: 'home', route: '/', routeActiveExact: true },\r\n *       { id: 'users', label: 'Utenti', icon: 'users', route: '/users' },\r\n *     ],\r\n *   },\r\n * };\r\n * ```\r\n *\r\n * ### Topbar mode example\r\n * ```typescript\r\n * const schema: UiLayoutSchema = {\r\n *   mode: 'topbar',\r\n *   header: { logo: { text: 'UI' }, title: 'My App' },\r\n *   navigation: { items: [...] },\r\n *   topbar: {\r\n *     bars: [\r\n *       { id: 'alert', type: 'notification', notification: { text: 'Beta!', dismissible: true } },\r\n *       { id: 'main', type: 'brand', brand: { logo: { text: 'UI' }, title: 'My App' } },\r\n *       { id: 'nav', type: 'navigation' },\r\n *     ],\r\n *   },\r\n * };\r\n * ```\r\n */\r\nexport interface UiLayoutSchema {\r\n  /** Layout mode. @default 'sidebar' */\r\n  mode?: UiLayoutMode;\r\n  /** Header / top-bar branding. Required for sidebar/topbar modes, ignored in slotted mode. */\r\n  header?: UiLayoutHeaderConfig;\r\n  /** Navigation structure and behaviour. Required for sidebar/topbar modes, ignored in slotted mode. */\r\n  navigation?: UiLayoutNavigationConfig;\r\n  /** Footer content (optional). In slotted mode use `[uiLayoutFooter]` content projection instead. */\r\n  footer?: UiLayoutFooterConfig;\r\n  /** Floating action button / speed dial (optional). */\r\n  fab?: UiLayoutFabConfig;\r\n  /** Page header defaults applied to every page (optional). */\r\n  pageHeader?: UiLayoutPageHeaderConfig;\r\n  /** Overlay loader configuration (optional). */\r\n  loader?: UiLayoutLoaderConfig;\r\n  /** Content area sizing strategy. @default 'fluid' */\r\n  contentType?: UiContentType;\r\n  /** Topbar configuration (only used when `mode === 'topbar'`). */\r\n  topbar?: UiTopbarConfig;\r\n}\r\n"]}