@web-portal/core-infrastructure 0.0.1

package/fesm2022/web-portal-core-infrastructure.mjs

@@ -0,0 +1,2669 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, PLATFORM_ID as PLATFORM_ID$1, Inject, inject, Optional, Injector, signal } from '@angular/core';
+import * as i1$1 from '@angular/router';
+import { Router, NavigationEnd } from '@angular/router';
+import { BehaviorSubject, distinctUntilChanged, tap, filter, map, catchError, of, throwError, firstValueFrom, Observable, Subject, takeUntil, fromEvent } from 'rxjs';
+import * as i1$2 from '@angular/common/http';
+import { HttpClient, HttpRequest, HttpEventType, HttpHeaders, HttpResponse, HttpErrorResponse, HttpStatusCode } from '@angular/common/http';
+import { BREAKPOINTS_VALUE } from '@web-portal/core-base';
+import * as i1 from '@angular/cdk/layout';
+import { isPlatformBrowser, DOCUMENT } from '@angular/common';
+import { tap as tap$1, take, catchError as catchError$1, switchMap, finalize, map as map$1 } from 'rxjs/operators';
+import { MessageService } from 'primeng/api';
+import * as i1$3 from 'ngx-cookie-service';
+import moment from 'moment-timezone';
+import { ViewType } from '@web-portal/core-domain';
+import * as i1$4 from '@angular/platform-browser';
+
+/**
+ * Injection token for AuthDialogService
+ * App should provide implementation in app.config.ts
+ */
+const AUTH_DIALOG_SERVICE = new InjectionToken('AUTH_DIALOG_SERVICE');
+
+class BreakpointService {
+    constructor(breakpointObserver) {
+        this.breakpointObserver = breakpointObserver;
+        this.BreakpointsSubject = new BehaviorSubject({
+            isBigDesktopUp: false,
+            isDesktopUp: false,
+            isPhoneOnly: false,
+            isTabletLandscapeUp: false,
+            isTabletPortraitUp: false
+        });
+        this.breakpointsResult$ = this.BreakpointsSubject.asObservable();
+        this.breakpoint$ = this.breakpointObserver
+            .observe([
+            //for-big-desktop-up
+            BREAKPOINTS_VALUE.FOR_BIG_DESKTOP_UP,
+            //for-desktop-up
+            BREAKPOINTS_VALUE.FOR_DESKTOP_UP,
+            //for-tablet-landscape-up
+            BREAKPOINTS_VALUE.FOR_TABLET_LANDSCAPE_UP,
+            //for-tablet-portrait-up
+            BREAKPOINTS_VALUE.FOR_TABLET_PORTRAIT_UP,
+            //for-phone-only
+            BREAKPOINTS_VALUE.FOR_PHONE_ONLY
+        ])
+            .pipe(distinctUntilChanged());
+        this.breakpoint$.subscribe(state => {
+            const newBreakpoints = {
+                isPhoneOnly: state.breakpoints[BREAKPOINTS_VALUE.FOR_PHONE_ONLY],
+                isTabletPortraitUp: state.breakpoints[BREAKPOINTS_VALUE.FOR_TABLET_PORTRAIT_UP],
+                isTabletLandscapeUp: state.breakpoints[BREAKPOINTS_VALUE.FOR_TABLET_LANDSCAPE_UP],
+                isDesktopUp: state.breakpoints[BREAKPOINTS_VALUE.FOR_DESKTOP_UP],
+                isBigDesktopUp: state.breakpoints[BREAKPOINTS_VALUE.FOR_BIG_DESKTOP_UP]
+            };
+            this.setBreakpoints(newBreakpoints);
+        });
+    }
+    setBreakpoints(breakpoints) {
+        this.BreakpointsSubject.next(breakpoints);
+    }
+    getBreakpoints() {
+        return this.BreakpointsSubject.getValue()
+            ? this.BreakpointsSubject.getValue()
+            : {
+                isPhoneOnly: false,
+                isTabletPortraitUp: false,
+                isTabletLandscapeUp: true,
+                isDesktopUp: false,
+                isBigDesktopUp: false
+            };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BreakpointService, deps: [{ token: i1.BreakpointObserver }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BreakpointService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BreakpointService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [{ type: i1.BreakpointObserver }] });
+
+// Cache configuration constants
+const DEFAULT_CACHE_TIME = 5 * 60 * 1000; // 5 minutes
+const MAX_CACHE_SIZE = 100;
+class CacheService {
+    constructor() {
+        this.cache = new Map();
+        this.DEFAULT_TTL = DEFAULT_CACHE_TIME;
+        this.MAX_CACHE_SIZE = MAX_CACHE_SIZE;
+    }
+    /**
+     * Get data from cache by key
+     * @param key Cache key
+     * @returns Cached data or null if not found or expired
+     */
+    get(key) {
+        const item = this.cache.get(key);
+        if (!item)
+            return null;
+        const now = Date.now();
+        if (now - item.timestamp > this.DEFAULT_TTL) {
+            this.cache.delete(key);
+            return null;
+        }
+        // Update last access time
+        item.lastAccess = now;
+        this.cache.set(key, item);
+        return item.data;
+    }
+    /**
+     * Store data in cache
+     * @param key Cache key
+     * @param data Data to store
+     * @param ttl Time to live for the cache entry (in milliseconds)
+     */
+    set(key, data, ttl = this.DEFAULT_TTL) {
+        const now = Date.now();
+        // Check if cache has reached size limit
+        if (this.cache.size >= this.MAX_CACHE_SIZE && !this.cache.has(key)) {
+            this.removeLeastRecentlyUsed();
+        }
+        this.cache.set(key, {
+            data,
+            timestamp: now,
+            lastAccess: now
+        });
+    }
+    /**
+     * Check if cache has valid (non-expired) data for key
+     * @param key Cache key
+     * @returns True if cache has valid data
+     */
+    has(key) {
+        const item = this.cache.get(key);
+        if (!item)
+            return false;
+        const now = Date.now();
+        if (now - item.timestamp > this.DEFAULT_TTL) {
+            this.remove(key);
+            return false;
+        }
+        // Update last access time
+        item.lastAccess = now;
+        this.cache.set(key, item);
+        return true;
+    }
+    /**
+     * Remove item from cache by key
+     * @param key Cache key
+     */
+    remove(key) {
+        this.cache.delete(key);
+    }
+    /**
+     * Clear all cache data
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Generate a unique key for a given URL and optional parameters
+     * @param url Base URL
+     * @param params Optional query parameters
+     * @returns Generated key
+     */
+    generateKey(url, params) {
+        if (!params)
+            return url;
+        return `${url}?${JSON.stringify(params)}`;
+    }
+    /**
+     * Remove the least recently used item from cache when it reaches MAX_CACHE_SIZE
+     * @private
+     */
+    removeLeastRecentlyUsed() {
+        let oldestKey = null;
+        let oldestAccess = Date.now();
+        // Find the least recently used item
+        this.cache.forEach((value, key) => {
+            if (value.lastAccess < oldestAccess) {
+                oldestAccess = value.lastAccess;
+                oldestKey = key;
+            }
+        });
+        // Remove the least recently used item
+        if (oldestKey) {
+            this.remove(oldestKey);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: CacheService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: CacheService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: CacheService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [] });
+
+class PlatformService {
+    constructor(platformId) {
+        this.platformId = platformId;
+    }
+    get isBrowser() {
+        return isPlatformBrowser(this.platformId);
+    }
+    get isServer() {
+        return !isPlatformBrowser(this.platformId);
+    }
+    runOnBrowser(callback) {
+        if (this.isBrowser) {
+            return callback();
+        }
+        return null;
+    }
+    runOnServer(callback) {
+        if (this.isServer) {
+            return callback();
+        }
+        return null;
+    }
+    getWindow() {
+        return this.isBrowser ? window : null;
+    }
+    getDocument() {
+        return this.isBrowser ? document : null;
+    }
+    getNavigator() {
+        return this.isBrowser ? navigator : null;
+    }
+    getLocalStorage() {
+        return this.isBrowser ? localStorage : null;
+    }
+    getSessionStorage() {
+        return this.isBrowser ? sessionStorage : null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: PlatformService, deps: [{ token: PLATFORM_ID$1 }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: PlatformService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: PlatformService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID$1]
+                }] }] });
+
+// Constants
+const HTTP_STATUS = {
+    OK: 200,
+    BAD_REQUEST: 400,
+    NOT_ACCEPTABLE: 406
+};
+const ERROR_MESSAGES = {
+    INVALID_DATA: "Dữ liệu không hợp lệ",
+    INVALID_DATA_RETRY: "Dữ liệu không hợp lệ. Vui lòng thao tác lại"
+};
+const PLATFORM_ID = {
+    PHONE: "1",
+    DESKTOP: "2"
+};
+const HEADER_GATEWAY_API = "gateway-api";
+/**
+ * Injection token cho ApiServiceConfig - chỉ dùng để tránh lỗi DI
+ * Thực tế config không được inject, chỉ truyền trực tiếp khi extend
+ */
+const API_SERVICE_CONFIG = Symbol("API_SERVICE_CONFIG");
+class ApiService {
+    /**
+     * Constructor của ApiService
+     * @param config - Config cho service (optional khi inject trực tiếp, bắt buộc khi extend)
+     * Note: Config không được inject qua DI, chỉ truyền trực tiếp khi extend class
+     */
+    constructor(config) {
+        this.customHeaders = {};
+        this._http = inject(HttpClient);
+        this._breakpoints = inject(BreakpointService);
+        this._cache = inject(CacheService);
+        this._platformService = inject(PlatformService);
+        // Không inject config qua DI - chỉ nhận khi extend class
+        // Khi inject trực tiếp qua DI, config sẽ là undefined
+        // Khi extend class, bắt buộc phải truyền config vào super()
+        this.isBrowser = this._platformService.isBrowser;
+        this._breakpoints.breakpointsResult$.subscribe(observer => {
+            this.breakpoints = observer;
+        });
+        // Tự động initialize nếu có config
+        if (config) {
+            this._initializeInternal(config);
+        }
+    }
+    /**
+     * Initialize service với config - Tự động được gọi trong constructor
+     * @protected
+     */
+    _initializeInternal(config) {
+        const parsedConfig = this._parseConfig(config);
+        this.baseUrl = parsedConfig.baseUrl;
+        this.serviceName = parsedConfig.gatewayApi;
+        if (parsedConfig.gatewayApi) {
+            this._setGatewayApiHeader(parsedConfig.gatewayApi);
+        }
+    }
+    /**
+     * Protected GET request - Sử dụng trong child classes để tránh shadowing
+     * @protected
+     */
+    _get(url, params, useCache = false) {
+        return this._handleCachedRequest(() => this.sendRequest("GET", url, null, params), url, params?.toString(), useCache);
+    }
+    /**
+     * Protected GET by ID request
+     * @protected
+     */
+    _getById(url, id, useCache = true) {
+        const fullUrl = `${url}/${id}`;
+        return this._handleCachedRequest(() => this.sendRequest("GET", fullUrl), fullUrl, undefined, useCache);
+    }
+    /**
+     * Protected DELETE request - Sử dụng trong child classes để tránh shadowing
+     * @protected
+     */
+    _delete(url, id) {
+        return this.sendRequest("DELETE", `${url}/${id}`);
+    }
+    /**
+     * Protected PUT request - Sử dụng trong child classes để tránh shadowing
+     * @protected
+     */
+    _put(url, value) {
+        return this.sendRequest("PUT", url, value);
+    }
+    /**
+     * Protected POST request - Sử dụng trong child classes để tránh shadowing
+     * @protected
+     */
+    _post(url, value, useCache = false) {
+        return this._handleCachedRequest(() => this.sendRequest("POST", url, value), url, value, useCache);
+    }
+    /**
+     * Protected POST FormData request
+     * @protected
+     */
+    _postFormData(url, value) {
+        const formData = this._createFormData(value);
+        return this._sendFormDataRequest(url, formData, true);
+    }
+    /**
+     * Protected POST File request
+     * @protected
+     */
+    _postFile(url, file, value) {
+        const formData = this._createFormData(value);
+        formData.append("file", file);
+        return this._sendFormDataRequest(url, formData, false);
+    }
+    // ====== Public methods for backward compatibility ======
+    // Các methods này giữ lại để backward compatibility
+    // Child classes nên sử dụng protected methods với prefix _
+    /**
+     * GET request với optional caching
+     * @deprecated Sử dụng protected _get() trong child classes để tránh shadowing
+     */
+    // get<T>(
+    //   url: string,
+    //   params?: HttpParams,
+    //   useCache: boolean = false
+    // ): Observable<T> {
+    //   return this._get<T>(url, params, useCache);
+    // }
+    // /**
+    //  * GET request by ID với caching enabled by default
+    //  * @deprecated Sử dụng protected _getById() trong child classes để tránh shadowing
+    //  */
+    // getById<T>(url: string, id: number, useCache: boolean = true): Observable<T> {
+    //   return this._getById<T>(url, id, useCache);
+    // }
+    /**
+     * DELETE request
+     * @deprecated Sử dụng protected _delete() trong child classes để tránh shadowing
+     * Note: Method này đã bị remove để tránh conflict. Sử dụng _delete() trong child classes.
+     */
+    // delete<T>(url: string, id: string): Observable<T> {
+    //   return this._delete<T>(url, id);
+    // }
+    /**
+     * PUT request
+     * @deprecated Sử dụng protected _put() trong child classes để tránh shadowing
+     */
+    put(url, value) {
+        return this._put(url, value);
+    }
+    /**
+     * POST request với optional caching
+     * @deprecated Sử dụng protected _post() trong child classes để tránh shadowing
+     */
+    post(url, value, useCache = false) {
+        return this._post(url, value, useCache);
+    }
+    /**
+     * POST request với FormData
+     * @deprecated Sử dụng protected _postFormData() trong child classes để tránh shadowing
+     */
+    postFormData(url, value) {
+        return this._postFormData(url, value);
+    }
+    /**
+     * POST request với File upload
+     * @deprecated Sử dụng protected _postFile() trong child classes để tránh shadowing
+     */
+    postFile(url, file, value) {
+        return this._postFile(url, file, value);
+    }
+    /**
+     * Send HTTP request và process response
+     * @private
+     */
+    sendRequest(method, url, data = null, params) {
+        const requestOptions = new HttpRequest(method.toUpperCase(), url, data, {
+            headers: this.setHeaders(),
+            params: params,
+            withCredentials: true,
+            responseType: "json"
+        });
+        console.log(`[ApiService] Request: ${method} ${url}`, {
+            headers: requestOptions.headers.keys().reduce((acc, key) => ({ ...acc, [key]: requestOptions.headers.get(key) }), {}),
+            params: params?.toString(),
+            data
+        });
+        return this._http.request(requestOptions).pipe(tap({
+            next: (event) => console.log(`[ApiService] Event for ${url}:`, event),
+            error: (error) => console.error(`[ApiService] Request Error for ${url}:`, error)
+        }), filter((event) => event?.type === HttpEventType.Response), map((response) => {
+            console.log(`[ApiService] Full Response Object for ${url}:`, response);
+            return response.body;
+        }), tap((apiResponse) => {
+            console.log(`[ApiService] Raw Body from ${url}:`, apiResponse);
+            if (apiResponse.status !== HTTP_STATUS.OK) {
+                throw {
+                    status: apiResponse.status,
+                    message: apiResponse.message
+                };
+            }
+        }), map((apiResponse) => apiResponse.data), catchError((error) => {
+            console.error(`[ApiService] Caught Error for ${url}:`, error);
+            return this._handleError(error);
+        }));
+    }
+    /**
+     * Send FormData request
+     * @private
+     */
+    _sendFormDataRequest(url, formData, includeHeaders) {
+        const req = new HttpRequest("POST", url, formData, {
+            reportProgress: true,
+            responseType: "json",
+            ...(includeHeaders && { headers: this.setHeaders() })
+        });
+        return this._http.request(req).pipe(filter((event) => event.type === HttpEventType.Response), map((response) => response.body), tap((apiResponse) => {
+            if (apiResponse.status !== HTTP_STATUS.OK) {
+                throw {
+                    status: apiResponse.status,
+                    message: apiResponse.message
+                };
+            }
+        }), map((apiResponse) => apiResponse.data), catchError((error) => this._handleError(error)));
+    }
+    /**
+     * Get default headers cho mọi request
+     * @protected
+     */
+    getDefaultHeaders() {
+        return {
+            ConcungContextID: this.generateUUID(),
+            ...(this.isBrowser && { returnUrl: window.location.href }),
+            Platform_id: this.breakpoints?.isPhoneOnly
+                ? PLATFORM_ID.PHONE
+                : PLATFORM_ID.DESKTOP
+        };
+    }
+    /**
+     * Set headers cho request
+     * @protected
+     */
+    setHeaders(customHeaders) {
+        const headersObj = {
+            ...this.customHeaders,
+            ...this.getDefaultHeaders(),
+            ...(customHeaders || {})
+        };
+        let headers = new HttpHeaders();
+        Object.entries(headersObj).forEach(([key, value]) => {
+            headers = headers.set(key, value);
+        });
+        return headers;
+    }
+    /**
+     * Convert object thành query string
+     * @param obj - Object chứa key-value pairs
+     * @returns Query string
+     */
+    objectToQueryString(obj) {
+        const queryParams = [];
+        Object.entries(obj).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                const encodedValue = encodeURIComponent(String(value));
+                queryParams.push(`${encodeURIComponent(key)}=${encodedValue}`);
+            }
+        });
+        return queryParams.join("&");
+    }
+    /**
+     * Generate UUID v4
+     * @returns UUID string without dashes
+     */
+    generateUUID() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
+            .replace(/[xy]/g, c => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        })
+            .replace(/-/g, "");
+    }
+    /**
+     * Handle cached request logic
+     * @private
+     */
+    _handleCachedRequest(requestFn, url, params, useCache) {
+        if (!useCache) {
+            return requestFn();
+        }
+        const cacheKey = this._cache.generateKey(url, params);
+        const cachedData = this._cache.get(cacheKey);
+        if (cachedData) {
+            return of(cachedData);
+        }
+        return requestFn().pipe(tap(response => {
+            this._cache.set(cacheKey, response);
+        }));
+    }
+    /**
+     * Create FormData từ object
+     * @private
+     */
+    _createFormData(value) {
+        const formData = new FormData();
+        if (value) {
+            Object.entries(value).forEach(([key, val]) => {
+                if (val !== undefined && val !== null) {
+                    formData.append(key, val);
+                }
+            });
+        }
+        return formData;
+    }
+    /**
+     * Handle errors từ HTTP requests
+     * @private
+     */
+    _handleError(error) {
+        // Log error in development (environment check removed for library)
+        if (typeof console !== 'undefined' && console.error) {
+            console.error("API Error:", error);
+        }
+        const httpError = error;
+        // Handle 406 Not Acceptable
+        if (httpError?.status === HTTP_STATUS.NOT_ACCEPTABLE) {
+            const rawMessage = httpError.error ??
+                httpError?.message;
+            const message = this._extractErrorMessage(rawMessage, ERROR_MESSAGES.INVALID_DATA);
+            return throwError(() => ({
+                status: HTTP_STATUS.NOT_ACCEPTABLE,
+                message
+            }));
+        }
+        // Handle 400 Bad Request
+        if (httpError?.status === HTTP_STATUS.BAD_REQUEST) {
+            return throwError(() => ({
+                status: httpError.status,
+                message: httpError?.error?.message || ERROR_MESSAGES.INVALID_DATA_RETRY
+            }));
+        }
+        // Return original error for other cases
+        return throwError(() => error);
+    }
+    /**
+     * Extract error message từ various formats
+     * @private
+     */
+    _extractErrorMessage(raw, fallback) {
+        if (typeof raw === "string" && raw.trim().length > 0) {
+            return raw;
+        }
+        if (raw && typeof raw === "object" && "message" in raw) {
+            return String(raw.message) || fallback;
+        }
+        return fallback;
+    }
+    /**
+     * Parse config từ string hoặc object
+     * @private
+     */
+    _parseConfig(config) {
+        if (typeof config === "string") {
+            return { gatewayApi: config };
+        }
+        return {
+            gatewayApi: config.gatewayApi,
+            baseUrl: config.baseUrl
+        };
+    }
+    /**
+     * Set gateway-api header cho tất cả requests
+     * @private
+     */
+    _setGatewayApiHeader(serviceName) {
+        this.customHeaders = {
+            ...this.customHeaders,
+            [HEADER_GATEWAY_API]: serviceName
+        };
+    }
+    /**
+     * Override gateway-api header cho request cụ thể
+     * @param gatewayApi - Gateway API name
+     * @returns Instance để support method chaining
+     *
+     * @example
+     * ```typescript
+     * this.withGatewayApi('other-api')._get('/endpoint');
+     * ```
+     */
+    withGatewayApi(gatewayApi) {
+        this.customHeaders = {
+            ...this.customHeaders,
+            [HEADER_GATEWAY_API]: gatewayApi
+        };
+        return this;
+    }
+    /**
+     * Get current service name
+     * @returns Gateway API name hoặc undefined
+     */
+    getServiceName() {
+        return this.serviceName;
+    }
+    /**
+     * Get base URL for current service
+     * @returns Base URL hoặc undefined
+     */
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ApiService, deps: [{ token: API_SERVICE_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ApiService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [API_SERVICE_CONFIG]
+                }] }] });
+
+const USER_KEY = "UserPrincipal";
+const AUTH_EXPIRED_KEY = "__AUTH_EXPIRED__";
+class StorageService {
+    clean() {
+        window.sessionStorage.clear();
+    }
+    saveUser(user) {
+        window.sessionStorage.removeItem(USER_KEY);
+        window.sessionStorage.setItem(USER_KEY, JSON.stringify(user));
+        // phiên mới hợp lệ → clear cờ hết hạn
+        this.setAuthExpired(false);
+    }
+    removeUser() {
+        window.sessionStorage.removeItem(USER_KEY);
+    }
+    getUser() {
+        const user = window.sessionStorage.getItem(USER_KEY);
+        if (user) {
+            return JSON.parse(user);
+        }
+        return null;
+    }
+    isLoggedIn() {
+        const user = window.sessionStorage.getItem(USER_KEY);
+        if (user) {
+            return true;
+        }
+        return false;
+    }
+    setAuthExpired(value) {
+        try {
+            window.sessionStorage.setItem(AUTH_EXPIRED_KEY, value ? "1" : "0");
+        }
+        catch { }
+    }
+    isAuthExpired() {
+        try {
+            return window.sessionStorage.getItem(AUTH_EXPIRED_KEY) === "1";
+        }
+        catch {
+            return false;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: StorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: StorageService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }] });
+
+class AuthService extends ApiService {
+    getIsReLogin() {
+        return this.isReLogin;
+    }
+    setIsReLogin(value) {
+        this.isReLogin = value;
+    }
+    constructor(_storageService) {
+        super({ baseUrl: "/accounts" });
+        this._storageService = _storageService;
+        this.isReLogin = false;
+    }
+    async isAuthenticated() {
+        var isValidSession = await this.isValidSession();
+        if (!isValidSession) {
+            this._storageService.removeUser();
+            return false;
+        }
+        return true;
+    }
+    async isValidSession() {
+        try {
+            let response = await firstValueFrom(this._post(`${this.baseUrl}/checkLogin`, null));
+            const user = response;
+            if (user == null || user == undefined || user.UserID <= 0) {
+                return false;
+            }
+            this._user = user;
+            this._storageService.saveUser(this._user);
+            return true;
+        }
+        catch (err) {
+            console.log("error:", err);
+            return false;
+        }
+    }
+    getCurrentUser() {
+        var currentUser = this._storageService.getUser();
+        return currentUser;
+    }
+    hasPermission(roleFunctionName) {
+        var currentUser = this._storageService.getUser();
+        const user = currentUser;
+        if (user == null)
+            return false;
+        return user.UserPermission?.map(x => x.RoleFunctionName).includes(roleFunctionName);
+    }
+    login(returnUrl) {
+        try {
+            const url = `${this.baseUrl}/login?returnUrl=${returnUrl}`;
+            this._get(url, null, false).subscribe({
+                next: (url) => {
+                    window.location.href = url;
+                    return;
+                },
+                error: err => {
+                    console.log("err:", err);
+                }
+            });
+        }
+        catch (err) {
+            console.log("error:", err);
+        }
+        return;
+    }
+    logout() {
+        try {
+            this._post(`${this.baseUrl}/logout`).subscribe({
+                next: async (url) => {
+                    this._storageService.clean();
+                    window.location.href = url;
+                },
+                error: err => {
+                    console.log("err:", err);
+                }
+            });
+            return true;
+        }
+        catch (err) {
+            console.log("error:", err);
+        }
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthService, deps: [{ token: StorageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [{ type: StorageService }] });
+class SessionValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SessionValidationError";
+    }
+}
+
+function isPageReload$1() {
+    try {
+        return window.sessionStorage.getItem("__LOAD_IS_RELOAD__") === "1";
+    }
+    catch {
+        return false;
+    }
+}
+class AuthGuard {
+    get authDialog() {
+        if (!this._authDialog) {
+            this._authDialog = this.injector.get(AUTH_DIALOG_SERVICE, null);
+        }
+        return this._authDialog;
+    }
+    constructor(router, _authService, storage, injector) {
+        this.router = router;
+        this._authService = _authService;
+        this.storage = storage;
+        this.injector = injector;
+        // Lazy inject AuthDialogService to avoid circular dependency
+        this._authDialog = null;
+        this._authService.setIsReLogin(false);
+    }
+    async canActivate(route) {
+        const requiredPermission = route.data.permission;
+        var returnUrl = window.document.URL;
+        // Ghi nhận trạng thái có user trong session TRƯỚC khi gọi isAuthenticated()
+        const hadSessionUser = this.storage.isLoggedIn();
+        var isAuthenticated = await this._authService.isAuthenticated();
+        if (isAuthenticated) {
+            this._authService.setIsReLogin(true);
+            const hasPermission = this._authService.hasPermission(requiredPermission);
+            if (!hasPermission) {
+                this.router.navigate(["page-403"], { skipLocationChange: true });
+                return false;
+            }
+            return true;
+        }
+        // Nếu F5/reload → đá thẳng qua login, không popup
+        if (isPageReload$1()) {
+            this._authService.login(returnUrl);
+            return false;
+        }
+        // Nếu trước đó chưa có user trong session (chưa từng login)
+        // → redirect thẳng đến login, không show popup
+        if (!hadSessionUser) {
+            this._authService.login(returnUrl);
+            return false;
+        }
+        // Nếu đã có user nhưng session hết hạn → show popup re-login
+        if (!this.authDialog) {
+            // Fallback: redirect to login if dialog service not provided
+            this._authService.login(returnUrl);
+            return false;
+        }
+        const confirmed = await this.authDialog.openReLoginDialog();
+        if (confirmed) {
+            // Mở popup đăng nhập lại, không reload trang hiện tại
+            const screenX = typeof window.screenX != "undefined"
+                ? window.screenX
+                : window.screenLeft;
+            const screenY = typeof window.screenY != "undefined"
+                ? window.screenY
+                : window.screenTop;
+            const outerWidth = typeof window.outerWidth != "undefined"
+                ? window.outerWidth
+                : document.body.clientWidth;
+            const outerHeight = typeof window.outerHeight != "undefined"
+                ? window.outerHeight
+                : document.body.clientHeight - 22;
+            const width = 550;
+            const height = 600;
+            const left = screenX + (outerWidth - width) / 2;
+            const top = screenY + (outerHeight - height) / 3;
+            const features = [
+                `width=${width}`,
+                `height=${height}`,
+                `left=${left}`,
+                `top=${top}`,
+                "resizable=yes",
+                "scrollbars=yes",
+                "status=no",
+                "location=no",
+                "menubar=no",
+                "toolbar=no"
+            ].join(",");
+            const popupReturnUrl = `${window.document.baseURI}` + "account/relogin";
+            window.open(`/accounts/relogin?returnUrl=${popupReturnUrl}`, "Đăng nhập lại", features);
+        }
+        // Hủy điều hướng hiện tại để không reload
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthGuard, deps: [{ token: i1$1.Router }, { token: AuthService }, { token: StorageService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthGuard, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [{ type: i1$1.Router }, { type: AuthService }, { type: StorageService }, { type: i0.Injector }] });
+
+// Helper functions
+let isShowingDialog = false;
+function hasSessionUser() {
+    try {
+        return !!window.sessionStorage.getItem("UserPrincipal");
+    }
+    catch {
+        return false;
+    }
+}
+function isPageReload() {
+    try {
+        return window.sessionStorage.getItem("__LOAD_IS_RELOAD__") === "1";
+    }
+    catch {
+        return false;
+    }
+}
+// Functional interceptor for newer Angular versions
+const authInterceptor = (req, next) => {
+    const router = inject(Router);
+    const authService = inject(AuthService);
+    const storage = inject(StorageService);
+    const injector = inject(Injector);
+    return next(req).pipe(tap$1(async (response) => {
+        if (response instanceof HttpResponse) {
+            const body = response.body;
+            if (body?.status === 401) {
+                await ensureReLoginDialog(injector, authService, storage);
+                return;
+            }
+        }
+    }, async (error) => {
+        if (error instanceof HttpErrorResponse) {
+            const respError = error;
+            if (respError.status === 403) {
+                router.navigate(["/page-403"]);
+            }
+            else if (respError.status === 401) {
+                await ensureReLoginDialog(injector, authService, storage);
+                return;
+            }
+        }
+    }));
+};
+async function ensureReLoginDialog(injector, authService, storage) {
+    // Lazy inject AuthDialogService to avoid circular dependency
+    const authDialog = injector.get(AUTH_DIALOG_SERVICE, null);
+    if (!authDialog) {
+        // Fallback: redirect to login if dialog service not provided
+        const returnUrl = window.location.href;
+        authService.login(returnUrl);
+        return;
+    }
+    // Nếu đang reload trang (F5) và backend trả 401 → luôn redirect login
+    if (isPageReload()) {
+        const returnUrl = window.location.href;
+        authService.login(returnUrl);
+        return;
+    }
+    // Nếu chưa có user trong session (first load ẩn danh) và chưa đặt cờ hết hạn → redirect ngay đến login
+    if (!hasSessionUser() && !storage.isAuthExpired()) {
+        const returnUrl = window.location.href;
+        authService.login(returnUrl);
+        return;
+    }
+    if (isShowingDialog)
+        return;
+    isShowingDialog = true;
+    try {
+        const confirmed = await authDialog.openReLoginDialog();
+        if (confirmed) {
+            storage.setAuthExpired(false);
+            openReLogin();
+        }
+        else {
+            storage.setAuthExpired(true);
+        }
+    }
+    finally {
+        isShowingDialog = false;
+    }
+}
+function setHeaders() {
+    let headers = new HttpHeaders();
+    headers = headers.set("ConcungContextID", generateUUID().toString().replace(/-/g, ""));
+    headers = headers.set("returnUrl", window.location.href);
+    return headers;
+}
+function openReLogin() {
+    var newwindow;
+    let screenX = typeof window.screenX != "undefined" ? window.screenX : window.screenLeft;
+    let screenY = typeof window.screenY != "undefined" ? window.screenY : window.screenTop;
+    let outerWidth = typeof window.outerWidth != "undefined"
+        ? window.outerWidth
+        : document.body.clientWidth;
+    let outerHeight = typeof window.outerHeight != "undefined"
+        ? window.outerHeight
+        : document.body.clientHeight - 22;
+    let width = 550;
+    let height = 600;
+    let left = screenX + (outerWidth - width) / 2;
+    let top = screenY + (outerHeight - height) / 3;
+    let features = [
+        `width=${width}`,
+        `height=${height}`,
+        `left=${left}`,
+        `top=${top}`,
+        "resizable=yes",
+        "scrollbars=yes",
+        "status=no",
+        "location=no",
+        "menubar=no",
+        "toolbar=no"
+    ].join(",");
+    setTimeout(() => {
+        var returnUrl = `${window.document.baseURI}` + "account/relogin";
+        newwindow = window.open(`/accounts/relogin?returnUrl=${returnUrl}`, "Đăng nhập lại", features);
+        if (window.focus && newwindow) {
+            newwindow.focus();
+        }
+    }, 100);
+    return false;
+}
+function generateUUID() {
+    let dt = new Date().getTime();
+    const uuid = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+        const r = (dt + Math.random() * 16) % 16 | 0;
+        dt = Math.floor(dt / 16);
+        return (c === "x" ? r : (r & 0x3) | 0x8).toString(16);
+    });
+    return uuid.replace(/-/g, "");
+}
+
+// Cache để lưu trữ pending requests
+const pendingRequests = new Map();
+const duplicateRequestInterceptor = (request, next) => {
+    // Chỉ áp dụng cho GET requests
+    if (request.method !== "GET") {
+        return next(request);
+    }
+    const cacheKey = generateCacheKey(request);
+    // Kiểm tra nếu có request đang pending
+    if (pendingRequests.has(cacheKey)) {
+        console.log(`[DuplicateRequestInterceptor] Duplicate request detected for: ${cacheKey}`);
+        return pendingRequests.get(cacheKey);
+    }
+    // Tạo request mới
+    const request$ = next(request).pipe(take(1), catchError$1(error => {
+        // Xóa request khỏi pending khi có lỗi
+        pendingRequests.delete(cacheKey);
+        throw error;
+    }), switchMap(response => {
+        // Xóa request khỏi pending khi hoàn thành
+        pendingRequests.delete(cacheKey);
+        return of(response);
+    }));
+    // Lưu request vào pending
+    pendingRequests.set(cacheKey, request$);
+    return request$;
+};
+function generateCacheKey(request) {
+    const url = request.url;
+    const params = request.params.toString();
+    return `${request.method}:${url}${params ? `?${params}` : ""}`;
+}
+
+/**
+ * Global Error Interceptor
+ * Handles HTTP errors globally and shows appropriate user-friendly messages
+ */
+const errorInterceptor = (req, next) => {
+    const messageService = inject(MessageService);
+    const router = inject(Router);
+    return next(req).pipe(catchError((error) => {
+        // Don't show error for auth interceptor handled errors
+        if (error.status === HttpStatusCode.Unauthorized) {
+            // Auth interceptor already handles this
+            return throwError(() => error);
+        }
+        // Don't show error for cancelled requests
+        if (error.status === 0 && error.error?.name === "TimeoutError") {
+            return throwError(() => error);
+        }
+        // Handle different error statuses
+        switch (error.status) {
+            case HttpStatusCode.BadRequest:
+                // messageService.add({
+                //   severity: "error",
+                //   summary: "Lỗi dữ liệu",
+                //   detail:
+                //     error.error?.message ||
+                //     "Dữ liệu không hợp lệ. Vui lòng kiểm tra lại.",
+                //   life: 3000
+                // });
+                break;
+            case HttpStatusCode.Unauthorized:
+                // Already handled by auth interceptor
+                return throwError(() => error);
+            case HttpStatusCode.Forbidden:
+                // messageService.add({
+                //   severity: "error",
+                //   summary: "Không có quyền",
+                //   detail: "Bạn không có quyền thực hiện thao tác này.",
+                //   life: 3000
+                // });
+                router.navigate(["/notfound"]);
+                break;
+            case HttpStatusCode.NotFound:
+                // messageService.add({
+                //   severity: "warn",
+                //   summary: "Không tìm thấy",
+                //   detail: error.error?.message || "Tài nguyên không tồn tại.",
+                //   life: 3000
+                // });
+                break;
+            case HttpStatusCode.InternalServerError:
+                // messageService.add({
+                //   severity: "error",
+                //   summary: "Lỗi server",
+                //   detail: "Server đang gặp sự cố. Vui lòng thử lại sau.",
+                //   life: 4000
+                // });
+                break;
+            case HttpStatusCode.ServiceUnavailable:
+            case HttpStatusCode.GatewayTimeout:
+                // messageService.add({
+                //   severity: "error",
+                //   summary: "Dịch vụ không khả dụng",
+                //   detail: "Dịch vụ tạm thời không khả dụng. Vui lòng thử lại sau.",
+                //   life: 4000
+                // });
+                break;
+            case HttpStatusCode.NotAcceptable:
+                // 406 - Let component handle the error message
+                // Component will show appropriate toast via effect
+                break;
+            case 0:
+                // Network error or CORS error
+                // messageService.add({
+                //   severity: "error",
+                //   summary: "Lỗi kết nối",
+                //   detail:
+                //     "Không thể kết nối đến server. Vui lòng kiểm tra kết nối mạng.",
+                //   life: 4000
+                // });
+                break;
+            default:
+                const errorMessage = error.error?.message || "Có lỗi xảy ra. Vui lòng thử lại.";
+                messageService.add({
+                    severity: "error",
+                    summary: "Lỗi",
+                    detail: errorMessage,
+                    life: 3000
+                });
+        }
+        return throwError(() => error);
+    }));
+};
+
+class LoadingService {
+    constructor() {
+        this.activeRequestsCount = 0;
+        this.isLoading = signal(false);
+    }
+    start() {
+        this.activeRequestsCount++;
+        if (!this.isLoading())
+            this.isLoading.set(true);
+    }
+    stop() {
+        if (this.activeRequestsCount > 0)
+            this.activeRequestsCount--;
+        if (this.activeRequestsCount === 0 && this.isLoading()) {
+            this.isLoading.set(false);
+        }
+    }
+    reset() {
+        this.activeRequestsCount = 0;
+        this.isLoading.set(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LoadingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LoadingService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LoadingService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }] });
+
+const loadingInterceptor = (req, next) => {
+    const loadingService = inject(LoadingService);
+    // Skip loading for specific APIs that are called frequently
+    const skipLoadingUrls = [
+    // Add more URLs here if needed
+    ];
+    const shouldSkipLoading = skipLoadingUrls.some(url => req.url.includes(url));
+    if (shouldSkipLoading) {
+        return next(req);
+    }
+    loadingService.start();
+    return next(req).pipe(finalize(() => loadingService.stop()));
+};
+
+// Injection token for environment (optional - app can provide it)
+const APP_ENVIRONMENT = Symbol('APP_ENVIRONMENT');
+class AppConfigService {
+    constructor(http, env) {
+        this.http = http;
+        this.configSubject = new BehaviorSubject(null);
+        this.config = null;
+        this.environment = null;
+        // Try to get environment from injection, or from window (for backward compatibility)
+        this.environment = env || (typeof window !== 'undefined' && window.__ENVIRONMENT__) || null;
+    }
+    /**
+     * Lấy config từ backend và lưu vào service, fallback về environment nếu fail
+     */
+    loadConfig() {
+        return this.http.post("/api1/configs", {}).pipe(map$1(response => response.data), tap$1(config => {
+            this.config = config;
+            this.configSubject.next(config);
+        }), catchError$1(error => {
+            console.warn("⚠️ Failed to load config from backend, using fallback from environment:", error);
+            return this.loadFallbackConfig();
+        }));
+    }
+    /**
+     * Load fallback config từ environment
+     */
+    loadFallbackConfig() {
+        const env = this.environment?.appConfig;
+        const fallbackConfig = {
+            Environment: env?.Environment || "",
+            ClientID: env?.ClientID || ""
+        };
+        this.config = fallbackConfig;
+        this.configSubject.next(fallbackConfig);
+        return of(fallbackConfig);
+    }
+    /**
+     * Lấy config hiện tại (observable)
+     */
+    getConfig() {
+        return this.configSubject.asObservable();
+    }
+    /**
+     * Lấy config hiện tại (sync)
+     */
+    getConfigSync() {
+        return this.config;
+    }
+    /**
+     * Lấy Environment
+     */
+    getEnvironment() {
+        const env = this.environment?.appConfig;
+        return this.config?.Environment || env?.Environment || "";
+    }
+    /**
+     * Lấy ClientID/ClientName
+     */
+    getClientName() {
+        const env = this.environment?.appConfig;
+        return this.config?.ClientID || env?.ClientID || "";
+    }
+    /**
+     * Check xem đã load config chưa
+     */
+    isConfigLoaded() {
+        return this.config !== null;
+    }
+    /**
+     * Check xem config có được load từ backend hay fallback
+     */
+    isLoadedFromBackend() {
+        // Compare với environment để check xem có được load từ backend không
+        const env = this.environment?.appConfig;
+        return (this.config !== null &&
+            env &&
+            this.config.Environment !== env.Environment);
+    }
+    /**
+     * Lấy URL để clear cache khi tạo mới landing page
+     */
+    getCacheClearUrlForCreate() {
+        return this.environment?.landingPageConfig?.cacheClearUrlForCreate || null;
+    }
+    /**
+     * Lấy URL để clear cache khi cập nhật landing page
+     */
+    getCacheClearUrlForUpdate() {
+        return this.environment?.landingPageConfig?.cacheClearUrlForUpdate || null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AppConfigService, deps: [{ token: i1$2.HttpClient }, { token: APP_ENVIRONMENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AppConfigService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AppConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [{ type: i1$2.HttpClient }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [APP_ENVIRONMENT]
+                }] }] });
+
+class AppInitializeService {
+    constructor() {
+        this.initAppSubject = new BehaviorSubject(false);
+        this.appConfigService = inject(AppConfigService);
+    }
+    initialize() {
+        return this.initAppSubject.asObservable();
+    }
+    /**
+     * Khởi tạo app: Load config từ backend hoặc fallback từ environment
+     */
+    initializeApp() {
+        return this.appConfigService.loadConfig().pipe(map$1(() => {
+            this.setInitialize(true);
+            const configSource = this.appConfigService.isLoadedFromBackend()
+                ? "backend"
+                : "environment fallback";
+            return true;
+        })
+        // Không cần catchError nữa vì service đã handle fallback internally
+        );
+    }
+    setInitialize(data) {
+        this.initAppSubject.next(data);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AppInitializeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AppInitializeService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AppInitializeService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }] });
+
+class CookieService {
+    constructor(cookieService) {
+        this.cookieService = cookieService;
+    }
+    set(name, value, days = 1) {
+        this.cookieService.set(name, value, days);
+    }
+    get(name) {
+        return this.cookieService.get(name);
+    }
+    delete(name) {
+        this.cookieService.delete(name);
+    }
+    check(name) {
+        return this.cookieService.check(name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: CookieService, deps: [{ token: i1$3.CookieService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: CookieService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: CookieService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1$3.CookieService }] });
+
+class DocumentService {
+    constructor(platformService) {
+        this.platformService = platformService;
+    }
+    get nativeDocument() {
+        return this.platformService.getDocument();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DocumentService, deps: [{ token: PlatformService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DocumentService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DocumentService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: PlatformService }] });
+
+class LoaderService {
+    constructor() {
+        this._loading = new BehaviorSubject(false);
+        this.loading$ = this._loading.asObservable();
+    }
+    show() {
+        this._loading.next(true);
+    }
+    hide() {
+        this._loading.next(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LoaderService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }] });
+
+class FileService {
+    constructor(_http, _loader) {
+        this._http = _http;
+        this._loader = _loader;
+        this.baseUrl = "/api1/files/filehandler";
+    }
+    uploadExcel(file) {
+        const formData = new FormData();
+        formData.append("file", file);
+        const req = new HttpRequest("POST", `${this.baseUrl}/uploadExcel`, formData, {
+            reportProgress: true,
+            responseType: "json"
+        });
+        return this._http.request(req);
+    }
+    downloadExcel(filePathOrRes, fileName = "") {
+        this._loader.show();
+        // Support passing raw path or API response { data: path } or { file_path: path }
+        let filePath = undefined;
+        if (typeof filePathOrRes === "string") {
+            filePath = filePathOrRes;
+        }
+        else if (filePathOrRes) {
+            filePath =
+                filePathOrRes.data || filePathOrRes.file_path || filePathOrRes.FilePath;
+        }
+        if (!filePath) {
+            this._loader.hide();
+            return;
+        }
+        if (!fileName) {
+            const timestamp = Date.now();
+            fileName = `file_${timestamp}.xlsx`;
+        }
+        const encodedPath = encodeURIComponent(filePath);
+        this._http
+            .get(`${this.baseUrl}/downloadExcel?filePath=${encodedPath}`, {
+            responseType: "blob"
+        })
+            .subscribe({
+            next: response => {
+                if (response) {
+                    let blob = new Blob([response]);
+                    this.createElementDownload(blob, fileName);
+                }
+                this._loader.hide();
+            },
+            error: () => {
+                this._loader.hide();
+            }
+        });
+    }
+    exportExcel(sheet_datas, fileName) {
+        this._loader.show();
+        this.exportExcelBase(sheet_datas).subscribe(event => {
+            if (event.body) {
+                let blob = new Blob([event.body]);
+                this.createElementDownload(blob, fileName);
+                this._loader.hide();
+            }
+        });
+    }
+    exportExcelBase(sheet_datas) {
+        const formData = new FormData();
+        formData.append("sheet_datas", JSON.stringify(sheet_datas));
+        const req = new HttpRequest("POST", `${this.baseUrl}/exportExcel`, formData, { responseType: "blob" });
+        return this._http.request(req);
+    }
+    createElementDownload(blob, fileName = "") {
+        const parts = fileName.split(".");
+        let extention = parts.pop();
+        let name = fileName.replace(`.${extention}`, "");
+        let downLoadFileName = `${name}_${moment(new Date()).format("DD-MM-YYYY")}_.${extention ? extention : ".xlsx"}`;
+        let downloadLink = document.createElement("a");
+        downloadLink.href = window.URL.createObjectURL(blob);
+        downloadLink.setAttribute("download", downLoadFileName);
+        document.body.appendChild(downloadLink);
+        downloadLink.click();
+        setTimeout(() => {
+            document.body.removeChild(downloadLink);
+        }, 100);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FileService, deps: [{ token: i1$2.HttpClient }, { token: LoaderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FileService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FileService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1$2.HttpClient }, { type: LoaderService }] });
+
+class FileGCSService {
+    constructor(_http, _apiService) {
+        this._http = _http;
+        this._apiService = _apiService;
+        this.baseUrl = "/api1/files/gcs";
+    }
+    getSignedLink(filePath) {
+        return this._apiService.post(`${this.baseUrl}/getSignedLink?filePath=${filePath}`);
+    }
+    attachFile(file) {
+        const formData = new FormData();
+        formData.append("file", file);
+        const req = new HttpRequest("POST", `${this.baseUrl}/attachFile`, formData, {
+            reportProgress: true,
+            responseType: "json"
+        });
+        return this._http.request(req);
+    }
+    attachFilePromise(file) {
+        const formData = new FormData();
+        formData.append("file", file);
+        const req = new HttpRequest("POST", `${this.baseUrl}/attachFile`, formData, {
+            reportProgress: true,
+            responseType: "json"
+        });
+        return firstValueFrom(this._http.request(req));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FileGCSService, deps: [{ token: i1$2.HttpClient }, { token: ApiService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FileGCSService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FileGCSService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1$2.HttpClient }, { type: ApiService }] });
+
+class FileAIA_GCSService {
+    constructor(_http, _apiService) {
+        this._http = _http;
+        this._apiService = _apiService;
+        this.baseUrl = "/api1/files/aia-gcs";
+    }
+    getSignedLink(filePath) {
+        return this._apiService.post(`${this.baseUrl}/getSignedLink?filePath=${filePath}`);
+    }
+    attachFile(file) {
+        const formData = new FormData();
+        formData.append("file", file);
+        const req = new HttpRequest("POST", `${this.baseUrl}/attachFile`, formData, {
+            reportProgress: true,
+            responseType: "json"
+        });
+        return this._http.request(req);
+    }
+    attachFilePromise(file) {
+        const formData = new FormData();
+        formData.append("file", file);
+        const req = new HttpRequest("POST", `${this.baseUrl}/attachFile`, formData, {
+            reportProgress: true,
+            responseType: "json"
+        });
+        return firstValueFrom(this._http.request(req));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FileAIA_GCSService, deps: [{ token: i1$2.HttpClient }, { token: ApiService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FileAIA_GCSService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FileAIA_GCSService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1$2.HttpClient }, { type: ApiService }] });
+
+class FileWAPGCSService {
+    constructor(_http, _apiService) {
+        this._http = _http;
+        this._apiService = _apiService;
+        this.baseUrl = "/api1/files/wap-gcs";
+    }
+    getSignedLink(filePath) {
+        return this._apiService.post(`${this.baseUrl}/getSignedLink?filePath=${filePath}`);
+    }
+    getPresignedLink(fileName) {
+        return this._apiService.post(`${this.baseUrl}/getPresignedLink?fileName=${fileName}`);
+    }
+    setPublic(filePath) {
+        return this._apiService.post(`${this.baseUrl}/setPublic?filePath=${filePath}`);
+    }
+    attachFile(file) {
+        const formData = new FormData();
+        formData.append("file", file);
+        const req = new HttpRequest("POST", `${this.baseUrl}/attachFile`, formData, {
+            reportProgress: true,
+            responseType: "json"
+        });
+        return this._http.request(req);
+    }
+    attachFilePromise(file) {
+        const formData = new FormData();
+        formData.append("file", file);
+        const req = new HttpRequest("POST", `${this.baseUrl}/attachFile`, formData, {
+            reportProgress: true,
+            responseType: "json"
+        });
+        return firstValueFrom(this._http.request(req));
+    }
+    uploadFile(file) {
+        return new Observable(observer => {
+            let xhr = null;
+            // Tạo tên file unique để tránh trùng tên khi upload nhiều lần
+            const uniqueFileName = this.generateUniqueFileName(file.name);
+            firstValueFrom(this.getPresignedLink(uniqueFileName))
+                .then(presignedData => {
+                if (!presignedData) {
+                    throw new Error("Không nhận được presigned link từ server");
+                }
+                const presignedURL = presignedData.PreSignedURL ||
+                    presignedData.preSignedURL ||
+                    presignedData.url;
+                const filePath = presignedData.FilePath || presignedData.filePath;
+                const absoluteURL = presignedData.AbsoluteURL || presignedData.absoluteURL;
+                if (!presignedURL) {
+                    throw new Error("Presigned URL không hợp lệ");
+                }
+                const contentType = file.type || "application/octet-stream";
+                xhr = new XMLHttpRequest();
+                const cleanup = () => {
+                    if (xhr) {
+                        xhr.upload.removeEventListener("progress", progressHandler);
+                        xhr.removeEventListener("load", loadHandler);
+                        xhr.removeEventListener("error", errorHandler);
+                        xhr.removeEventListener("timeout", timeoutHandler);
+                        xhr.abort();
+                        xhr = null;
+                    }
+                };
+                const progressHandler = (_event) => {
+                    // No-op: progress not consumed by current callers
+                };
+                const loadHandler = async () => {
+                    if (xhr && xhr.status === 200) {
+                        try {
+                            if (filePath) {
+                                const setPublicResult = await firstValueFrom(this.setPublic(filePath));
+                                if (setPublicResult !== true) {
+                                    throw new Error("Set public không thành công");
+                                }
+                            }
+                            const finalUrl = absoluteURL || presignedURL;
+                            const result = this.buildResult(file, filePath, finalUrl);
+                            cleanup();
+                            observer.next(result);
+                            observer.complete();
+                        }
+                        catch (err) {
+                            cleanup();
+                            const msg = err?.message ||
+                                "Upload thành công nhưng setPublic thất bại. Vui lòng thử lại.";
+                            observer.error(new Error(msg));
+                        }
+                    }
+                    else if (xhr) {
+                        const errorMessage = `Upload file thất bại: ${xhr.statusText} (${xhr.status})`;
+                        cleanup();
+                        observer.error(new Error(errorMessage));
+                    }
+                };
+                const errorHandler = () => {
+                    if (!xhr)
+                        return;
+                    let userMessage = "Upload file thất bại";
+                    if (xhr.status === 0) {
+                        userMessage =
+                            "Không thể kết nối đến máy chủ lưu trữ. Máy chủ không phản hồi.";
+                    }
+                    else if (xhr.status >= 500) {
+                        userMessage = "Lỗi máy chủ. Vui lòng thử lại sau.";
+                    }
+                    else if (xhr.status >= 400) {
+                        userMessage = `Lỗi yêu cầu: ${xhr.statusText}`;
+                    }
+                    cleanup();
+                    observer.error(new Error(userMessage));
+                };
+                const timeoutHandler = () => {
+                    cleanup();
+                    observer.error(new Error("Kết nối đến máy chủ hết thời gian. Vui lòng thử lại."));
+                };
+                xhr.upload.addEventListener("progress", progressHandler);
+                xhr.addEventListener("load", loadHandler);
+                xhr.addEventListener("error", errorHandler);
+                xhr.addEventListener("timeout", timeoutHandler);
+                xhr.timeout = 60000 * 5;
+                xhr.open("PUT", presignedURL, true);
+                xhr.setRequestHeader("Content-Type", contentType);
+                xhr.send(file);
+            })
+                .catch(error => {
+                if (xhr) {
+                    xhr.abort();
+                    xhr = null;
+                }
+                let userMessage = "Upload file thất bại";
+                if (error.errorMessage) {
+                    userMessage = error.errorMessage;
+                }
+                else if (error.code === "ECONNABORTED" ||
+                    error.message?.includes("timeout")) {
+                    userMessage =
+                        "Kết nối đến máy chủ hết thời gian. Vui lòng thử lại.";
+                }
+                else if (error.message?.includes("failed to respond") ||
+                    error.message?.includes("Network Error")) {
+                    userMessage =
+                        "Không thể kết nối đến máy chủ lưu trữ. Máy chủ không phản hồi.";
+                }
+                else if (error.message) {
+                    userMessage = `Lỗi kết nối: ${error.message}`;
+                }
+                else if (error.error?.message) {
+                    userMessage = error.error.message;
+                }
+                observer.error(new Error(userMessage));
+            });
+            return () => {
+                if (xhr) {
+                    xhr.abort();
+                    xhr = null;
+                }
+            };
+        });
+    }
+    /**
+     * Tạo tên file unique bằng cách thêm timestamp và random string
+     * Format: originalname-timestamp-random.ext
+     */
+    generateUniqueFileName(originalFileName) {
+        const timestamp = Date.now();
+        const randomString = Math.random().toString(36).substring(2, 9);
+        // Tách tên file và extension
+        const lastDotIndex = originalFileName.lastIndexOf(".");
+        if (lastDotIndex === -1) {
+            // Không có extension
+            return `${originalFileName}-${timestamp}-${randomString}`;
+        }
+        const nameWithoutExt = originalFileName.substring(0, lastDotIndex);
+        const extension = originalFileName.substring(lastDotIndex);
+        return `${nameWithoutExt}-${timestamp}-${randomString}${extension}`;
+    }
+    extractFileName(filePath) {
+        return filePath.split("/").pop() || "";
+    }
+    buildResult(file, filePath, url) {
+        return {
+            url,
+            filePath,
+            fileName: this.extractFileName(filePath) || file.name,
+            originalName: file.name
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FileWAPGCSService, deps: [{ token: i1$2.HttpClient }, { token: ApiService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FileWAPGCSService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: FileWAPGCSService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1$2.HttpClient }, { type: ApiService }] });
+
+class LoadingSpinnerService {
+    constructor() {
+        this._loading = new BehaviorSubject(false);
+        this.loading$ = this._loading.asObservable();
+    }
+    show() {
+        this._loading.next(true);
+    }
+    hide() {
+        this._loading.next(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LoadingSpinnerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LoadingSpinnerService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LoadingSpinnerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }] });
+
+class LocalStorageService {
+    constructor(platformService) {
+        this.platformService = platformService;
+    }
+    setItem(key, value) {
+        this.platformService.runOnBrowser(() => {
+            localStorage.setItem(key, value);
+        });
+    }
+    getItem(key) {
+        return this.platformService.runOnBrowser(() => {
+            return localStorage.getItem(key);
+        });
+    }
+    removeItem(key) {
+        this.platformService.runOnBrowser(() => {
+            localStorage.removeItem(key);
+        });
+    }
+    clear() {
+        this.platformService.runOnBrowser(() => {
+            localStorage.clear();
+        });
+    }
+    hasKey(key) {
+        return (this.platformService.runOnBrowser(() => {
+            return localStorage.getItem(key) !== null;
+        }) || false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LocalStorageService, deps: [{ token: PlatformService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LocalStorageService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [{ type: PlatformService }] });
+
+class OverlayService {
+    constructor(_document) {
+        this._document = _document;
+        this.isOverlaySubject = new BehaviorSubject(false);
+        this.isOverlay$ = this.isOverlaySubject.asObservable();
+        this.overlayRequestors = new Set(); // Set lưu các component yêu cầu overlay
+        this.htmlWrapperElement = this._document.querySelector("html");
+    }
+    onShowOverlay(requestor) {
+        this.overlayRequestors.add(requestor); // Thêm component vào Set
+        if (this.overlayRequestors.size === 1) {
+            // Chỉ hiển thị overlay nếu là yêu cầu đầu tiên
+            this.isOverlaySubject.next(true);
+            this.htmlWrapperElement.style.overflow = "hidden";
+        }
+    }
+    onHiddenOverlay(requestor) {
+        this.overlayRequestors.delete(requestor); // Xóa component khỏi Set
+        if (this.overlayRequestors.size === 0) {
+            // Chỉ ẩn overlay nếu không còn yêu cầu nào
+            this.isOverlaySubject.next(false);
+            this.htmlWrapperElement.style.overflow = "auto";
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: OverlayService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: OverlayService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: OverlayService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+
+class RequestCacheService {
+    constructor() {
+        this.cache = new Map();
+        this.pendingRequests = new Map();
+        this.cacheStats = new BehaviorSubject({
+            hits: 0,
+            misses: 0
+        });
+        // Cleanup expired cache entries every 5 minutes
+        setInterval(() => this.cleanupExpiredEntries(), 5 * 60 * 1000);
+    }
+    /**
+     * Lấy dữ liệu từ cache hoặc thực hiện request mới
+     */
+    get(key, requestFn, ttl = 5 * 60 * 1000) {
+        // Kiểm tra cache
+        const cached = this.getFromCache(key);
+        if (cached) {
+            this.incrementHits();
+            return of(cached);
+        }
+        // Kiểm tra pending requests
+        if (this.pendingRequests.has(key)) {
+            return this.pendingRequests.get(key);
+        }
+        // Thực hiện request mới
+        this.incrementMisses();
+        const request$ = requestFn().pipe(tap$1(data => {
+            this.setCache(key, data, ttl);
+            this.pendingRequests.delete(key);
+        }), catchError$1(error => {
+            this.pendingRequests.delete(key);
+            throw error;
+        }));
+        this.pendingRequests.set(key, request$);
+        return request$;
+    }
+    /**
+     * Lấy dữ liệu từ cache
+     */
+    getFromCache(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        const now = Date.now();
+        if (now - entry.timestamp > entry.ttl) {
+            this.cache.delete(key);
+            return null;
+        }
+        return entry.data;
+    }
+    /**
+     * Lưu dữ liệu vào cache
+     */
+    setCache(key, data, ttl) {
+        this.cache.set(key, {
+            data,
+            timestamp: Date.now(),
+            ttl
+        });
+    }
+    /**
+     * Xóa cache entry
+     */
+    clearCache(key) {
+        this.cache.delete(key);
+        this.pendingRequests.delete(key);
+    }
+    /**
+     * Xóa toàn bộ cache
+     */
+    clearAllCache() {
+        this.cache.clear();
+        this.pendingRequests.clear();
+    }
+    /**
+     * Dọn dẹp cache entries đã hết hạn
+     */
+    cleanupExpiredEntries() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > entry.ttl) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    /**
+     * Tạo cache key từ URL và parameters
+     */
+    generateKey(url, params) {
+        const paramsStr = params ? JSON.stringify(params) : "";
+        return `${url}${paramsStr}`;
+    }
+    /**
+     * Lấy thống kê cache
+     */
+    getStats() {
+        return this.cacheStats.asObservable();
+    }
+    incrementHits() {
+        const stats = this.cacheStats.value;
+        this.cacheStats.next({ ...stats, hits: stats.hits + 1 });
+    }
+    incrementMisses() {
+        const stats = this.cacheStats.value;
+        this.cacheStats.next({ ...stats, misses: stats.misses + 1 });
+    }
+    /**
+     * Log cache statistics
+     */
+    logStats() {
+        const stats = this.cacheStats.value;
+        const total = stats.hits + stats.misses;
+        const hitRate = total > 0 ? ((stats.hits / total) * 100).toFixed(2) : "0";
+        // console.log(`[RequestCacheService] Cache Stats:`, {
+        //   hits: stats.hits,
+        //   misses: stats.misses,
+        //   total,
+        //   hitRate: `${hitRate}%`,
+        //   cacheSize: this.cache.size,
+        //   pendingRequests: this.pendingRequests.size
+        // });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: RequestCacheService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: RequestCacheService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: RequestCacheService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [] });
+
+class ResponsiveService {
+    constructor(breakpointService) {
+        this.breakpointService = breakpointService;
+        this.currentView = new BehaviorSubject(ViewType.DESKTOP);
+        this.currentView$ = this.currentView.asObservable();
+        this.breakpointService.breakpointsResult$.subscribe(breakpoints => {
+            if (breakpoints.isDesktopUp) {
+                this.currentView.next(ViewType.DESKTOP);
+            }
+            else if (breakpoints.isPhoneOnly) {
+                this.currentView.next(ViewType.MOBILE);
+            }
+            else {
+                this.currentView.next(ViewType.DESKTOP); // Default to desktop
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ResponsiveService, deps: [{ token: BreakpointService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ResponsiveService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ResponsiveService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [{ type: BreakpointService }] });
+
+/**
+ * Search Event Types for Shell-MFE Communication
+ * These mirror the types from the Search MFE but are simplified for cross-app communication
+ */
+var ShellSearchEventType;
+(function (ShellSearchEventType) {
+    ShellSearchEventType["NAVIGATION_TO_SEARCH"] = "NAVIGATION_TO_SEARCH";
+    ShellSearchEventType["NAVIGATION_AWAY_FROM_SEARCH"] = "NAVIGATION_AWAY_FROM_SEARCH";
+    ShellSearchEventType["NAVIGATION_REQUEST"] = "NAVIGATION_REQUEST";
+    ShellSearchEventType["ROUTE_ACCESSED_DIRECTLY"] = "ROUTE_ACCESSED_DIRECTLY";
+    ShellSearchEventType["ROUTE_RELOADED"] = "ROUTE_RELOADED";
+    ShellSearchEventType["SEARCH_INITIATED"] = "SEARCH_INITIATED";
+    ShellSearchEventType["FILTER_CHANGED"] = "FILTER_CHANGED";
+    ShellSearchEventType["SORT_CHANGED"] = "SORT_CHANGED";
+})(ShellSearchEventType || (ShellSearchEventType = {}));
+/**
+ * Search Event Bridge Service for Shell Application
+ * Handles communication between Shell and Search MFE via postMessage and routing
+ */
+class SearchEventBridgeService {
+    constructor(router) {
+        this.router = router;
+        this.destroy$ = new Subject();
+        this.eventSubject = new BehaviorSubject(null);
+        // Current route tracking
+        this.currentRoute = "";
+        this.previousRoute = "";
+        this.isSearchRoute = false;
+        this.initializeRouteTracking();
+        this.initializePostMessageListener();
+    }
+    /**
+     * Get observable stream of search events
+     */
+    getEventStream() {
+        return this.eventSubject.pipe(filter(event => event !== null), takeUntil(this.destroy$));
+    }
+    /**
+     * Emit a search event from Shell
+     */
+    emitShellEvent(type, data) {
+        const event = {
+            type,
+            source: "shell",
+            timestamp: Date.now(),
+            route: this.currentRoute,
+            queryParams: this.getQueryParams(),
+            data,
+            correlationId: this.generateCorrelationId()
+        };
+        this.eventSubject.next(event);
+        this.postMessageToMFE(event);
+    }
+    /**
+     * Navigate to search page with query
+     */
+    navigateToSearch(searchQuery, additionalParams) {
+        const queryParams = {
+            q: searchQuery,
+            ...additionalParams
+        };
+        // Emit navigation event
+        this.emitShellEvent(ShellSearchEventType.NAVIGATION_TO_SEARCH, {
+            searchQuery,
+            queryParams
+        });
+        // Perform navigation
+        this.router.navigate(["/tim-kiem"], { queryParams });
+    }
+    /**
+     * Update search query in current route
+     */
+    updateSearchQuery(searchQuery, replaceUrl = false) {
+        const currentParams = this.getQueryParams();
+        const newParams = {
+            ...currentParams,
+            q: searchQuery
+        };
+        this.router.navigate([], {
+            relativeTo: this.router.routerState.root,
+            queryParams: newParams,
+            replaceUrl
+        });
+    }
+    /**
+     * Clear search and navigate to home
+     */
+    clearSearchAndNavigateHome() {
+        this.emitShellEvent(ShellSearchEventType.NAVIGATION_AWAY_FROM_SEARCH, {
+            targetRoute: "/"
+        });
+        this.router.navigate(["/"]);
+    }
+    /**
+     * Check if currently on search route
+     */
+    isOnSearchRoute() {
+        return this.isSearchRoute;
+    }
+    /**
+     * Get current route info
+     */
+    getCurrentRouteInfo() {
+        return {
+            route: this.currentRoute,
+            queryParams: this.getQueryParams(),
+            isSearchRoute: this.isSearchRoute
+        };
+    }
+    /**
+     * Initialize route tracking
+     */
+    initializeRouteTracking() {
+        this.router.events
+            .pipe(filter(event => event instanceof NavigationEnd), takeUntil(this.destroy$))
+            .subscribe((event) => {
+            this.handleRouteChange(event);
+        });
+        // Handle initial route
+        this.currentRoute = this.router.url;
+        this.isSearchRoute = this.checkIfSearchRoute(this.currentRoute);
+    }
+    /**
+     * Handle route changes
+     */
+    handleRouteChange(event) {
+        this.previousRoute = this.currentRoute;
+        this.currentRoute = event.url;
+        const wasSearchRoute = this.isSearchRoute;
+        this.isSearchRoute = this.checkIfSearchRoute(this.currentRoute);
+        // Emit appropriate events based on route change
+        if (!wasSearchRoute && this.isSearchRoute) {
+            // Navigated to search
+            this.emitShellEvent(ShellSearchEventType.NAVIGATION_TO_SEARCH, {
+                fromRoute: this.previousRoute,
+                toRoute: this.currentRoute
+            });
+        }
+        else if (wasSearchRoute && !this.isSearchRoute) {
+            // Navigated away from search
+            this.emitShellEvent(ShellSearchEventType.NAVIGATION_AWAY_FROM_SEARCH, {
+                fromRoute: this.previousRoute,
+                toRoute: this.currentRoute
+            });
+        }
+        else if (this.isSearchRoute) {
+            // Navigation within search (filter/sort changes)
+            this.detectSearchNavigationType();
+        }
+    }
+    /**
+     * Detect type of navigation within search page
+     */
+    detectSearchNavigationType() {
+        const currentParams = this.getQueryParams();
+        const urlPath = this.currentRoute.split("?")[0];
+        // Check if it's a direct access or reload
+        if (this.isDirectAccess()) {
+            this.emitShellEvent(ShellSearchEventType.ROUTE_ACCESSED_DIRECTLY, {
+                route: urlPath,
+                queryParams: currentParams
+            });
+        }
+        else if (this.isPageReload()) {
+            this.emitShellEvent(ShellSearchEventType.ROUTE_RELOADED, {
+                route: urlPath,
+                queryParams: currentParams
+            });
+        }
+    }
+    /**
+     * Check if current route is search route
+     */
+    checkIfSearchRoute(route) {
+        return route.includes("/tim-kiem");
+    }
+    /**
+     * Check if this is direct access (no previous route or referrer)
+     */
+    isDirectAccess() {
+        return (!this.previousRoute ||
+            (typeof window !== "undefined" && !document.referrer) ||
+            (typeof window !== "undefined" && !window.history.length));
+    }
+    /**
+     * Check if this is a page reload
+     */
+    isPageReload() {
+        if (typeof window !== "undefined" && typeof performance !== "undefined") {
+            const navigation = performance.navigation;
+            return navigation?.type === "reload";
+        }
+        return false;
+    }
+    /**
+     * Get current query parameters
+     */
+    getQueryParams() {
+        const urlTree = this.router.parseUrl(this.currentRoute);
+        return urlTree.queryParams;
+    }
+    /**
+     * Initialize postMessage listener for MFE communication
+     */
+    initializePostMessageListener() {
+        if (typeof window === "undefined")
+            return;
+        fromEvent(window, "message")
+            .pipe(filter(event => this.isValidMFEEvent(event)), map(event => event.data.payload), takeUntil(this.destroy$))
+            .subscribe(payload => {
+            this.handleMFEEvent(payload);
+        });
+    }
+    /**
+     * Validate incoming postMessage events
+     */
+    isValidMFEEvent(event) {
+        return (event.data &&
+            event.data.type === "SEARCH_EVENT" &&
+            event.data.payload &&
+            event.data.payload.source === "mfe-search");
+    }
+    /**
+     * Send event to MFE via postMessage
+     */
+    postMessageToMFE(event) {
+        if (typeof window === "undefined")
+            return;
+        // Find MFE iframes or windows
+        const mfeFrames = document.querySelectorAll('iframe[src*="5201"], iframe[src*="mfe-search"]');
+        mfeFrames.forEach(frame => {
+            try {
+                frame.contentWindow?.postMessage({
+                    type: "SEARCH_EVENT",
+                    payload: event
+                }, "*");
+            }
+            catch (error) {
+                console.warn("[SearchEventBridge] Failed to send message to MFE:", error);
+            }
+        });
+        // Also try window.parent in case Shell is embedded
+        try {
+            window.parent?.postMessage({
+                type: "SEARCH_EVENT",
+                payload: event
+            }, "*");
+        }
+        catch (error) {
+            // Ignore cross-origin errors
+        }
+    }
+    /**
+     * Generate correlation ID for event tracking
+     */
+    generateCorrelationId() {
+        return `shell_${Date.now()}_${Math.random().toString(36).substring(2)}`;
+    }
+    /**
+     * Get event history for debugging
+     */
+    getEventHistory() {
+        // Implementation would store recent events for debugging
+        return [];
+    }
+    /**
+     * Public method to handle events from MFE (called by wrapper)
+     */
+    handleMFEEvent(payload) {
+        // Re-emit the event for Shell consumers
+        this.eventSubject.next(payload);
+        // Handle specific events that require Shell action
+        switch (payload.type) {
+            case ShellSearchEventType.NAVIGATION_TO_SEARCH:
+                // Handle navigation request from MFE
+                if (payload.data?.searchQuery) {
+                    this.navigateToSearch(payload.data.searchQuery, payload.data?.additionalParams);
+                }
+                else if (payload.data?.queryParams) {
+                    // For cases like image search where only queryParams are provided
+                    this.router.navigate(["/tim-kiem"], {
+                        queryParams: payload.data.queryParams
+                    });
+                }
+                break;
+            case ShellSearchEventType.NAVIGATION_AWAY_FROM_SEARCH:
+                // Handle navigation away from search
+                if (payload.data?.targetRoute) {
+                    this.router.navigate([payload.data.targetRoute]);
+                }
+                break;
+            case ShellSearchEventType.NAVIGATION_REQUEST:
+                // Handle general navigation request from MFE
+                if (payload.data?.targetRoute) {
+                    this.router.navigate([payload.data.targetRoute]);
+                }
+                break;
+            case ShellSearchEventType.SEARCH_INITIATED:
+                // Update URL if needed
+                if (payload.data?.searchQuery) {
+                    this.updateSearchQuery(payload.data.searchQuery, true);
+                }
+                break;
+            case ShellSearchEventType.FILTER_CHANGED:
+            case ShellSearchEventType.SORT_CHANGED:
+                // These are handled by the MFE but can trigger Shell-level analytics
+                break;
+        }
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SearchEventBridgeService, deps: [{ token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SearchEventBridgeService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SearchEventBridgeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [{ type: i1$1.Router }] });
+/**
+ * Factory function for providing the service
+ */
+function provideSearchEventBridge() {
+    return {
+        provide: SearchEventBridgeService,
+        useClass: SearchEventBridgeService
+    };
+}
+
+var NgxSeoMetaTagAttr;
+(function (NgxSeoMetaTagAttr) {
+    NgxSeoMetaTagAttr["name"] = "name";
+    NgxSeoMetaTagAttr["property"] = "property";
+})(NgxSeoMetaTagAttr || (NgxSeoMetaTagAttr = {}));
+class SeoService {
+    constructor(meta, title, 
+    // tslint:disable-next-line: variable-name
+    _document) {
+        this.meta = meta;
+        this.title = title;
+        this._document = _document;
+    }
+    setData(data) {
+        this.setSection(data.section);
+        if (typeof data.keywords !== "undefined") {
+            this.setKeywords(data.keywords);
+        }
+        //this.setKeywords(data.keywords);
+        this.setTitle(data.title);
+        this.setType(data.type);
+        this.setDescription(data.description);
+        this.setImage(data.image);
+        this.setUrl(data.url);
+        this.setPublished(data.published);
+        this.setModified(data.modified);
+        this.setAuthor(data.author);
+    }
+    setKeywords(keywords) {
+        if (Boolean(keywords)) {
+            this.meta.updateTag({ name: "keywords", content: keywords });
+        }
+        else {
+            this.meta.removeTag(`name='keywords'`);
+        }
+    }
+    setSection(section) {
+        if (Boolean(section)) {
+            //this.meta.updateTag({ name: 'article:section', content: section });
+            if (typeof section !== "undefined") {
+                this.meta.updateTag({ name: "article:section", content: section });
+            }
+        }
+        else {
+            this.meta.removeTag(`name='article:section'`);
+        }
+    }
+    setTitle(title = "") {
+        this.title.setTitle(title);
+        if (title && title.length) {
+            this.meta.updateTag({ name: "twitter:title", content: title });
+            this.meta.updateTag({ name: "twitter:image:alt", content: title });
+            this.meta.updateTag({ property: "og:image:alt", content: title });
+            this.meta.updateTag({ property: "og:title", content: title });
+            this.meta.updateTag({ name: "title", content: title });
+        }
+        else {
+            this.meta.removeTag(`name='twitter:title'`);
+            this.meta.removeTag(`name='twitter:image:alt'`);
+            this.meta.removeTag(`property='og:image:alt'`);
+            this.meta.removeTag(`property='og:title'`);
+            this.meta.removeTag(`name='title'`);
+        }
+    }
+    setType(type) {
+        if (type && type.length) {
+            this.meta.updateTag({ property: "og:type", content: type });
+        }
+        else {
+            this.meta.removeTag(`property='og:type'`);
+        }
+    }
+    setDescription(description) {
+        if (description && description.length) {
+            this.meta.updateTag({
+                name: "twitter:description",
+                content: description
+            });
+            this.meta.updateTag({ property: "og:description", content: description });
+            this.meta.updateTag({ name: "description", content: description });
+        }
+        else {
+            this.meta.removeTag(`name='twitter:description'`);
+            this.meta.removeTag(`property='og:description'`);
+            this.meta.removeTag(`name='description'`);
+        }
+    }
+    setImage(image) {
+        if (image && image.length) {
+            this.meta.updateTag({ name: "twitter:image", content: image });
+            this.meta.updateTag({ property: "og:image", content: image });
+            this.meta.updateTag({ property: "og:image:height", content: "630" });
+        }
+        else {
+            this.meta.removeTag(`name='twitter:image'`);
+            this.meta.removeTag(`property='og:image'`);
+            this.meta.removeTag(`property='og:image:height'`);
+        }
+    }
+    setUrl(url) {
+        if (url && url.length) {
+            this.meta.updateTag({ property: "og:url", content: url });
+        }
+        else {
+            this.meta.removeTag(`property='og:url'`);
+        }
+        this.setCanonicalUrl(url);
+    }
+    setPublished(publishedDateString) {
+        if (publishedDateString) {
+            const publishedDate = new Date(publishedDateString);
+            this.meta.updateTag({
+                name: "article:published_time",
+                content: publishedDate.toISOString()
+            });
+            this.meta.updateTag({
+                name: "published_date",
+                content: publishedDate.toISOString()
+            });
+        }
+        else {
+            this.meta.removeTag(`name='article:published_time'`);
+            this.meta.removeTag(`name='publication_date'`);
+        }
+    }
+    setModified(modifiedDateString) {
+        if (modifiedDateString) {
+            const modifiedDate = new Date(modifiedDateString);
+            this.meta.updateTag({
+                name: "article:modified_time",
+                content: modifiedDate.toISOString()
+            });
+            this.meta.updateTag({
+                name: "og:updated_time",
+                content: modifiedDate.toISOString()
+            });
+        }
+        else {
+            this.meta.removeTag(`name='article:modified_time'`);
+            this.meta.removeTag(`name='og:updated_time'`);
+        }
+    }
+    setAuthor(author) {
+        if (author && author.length) {
+            this.meta.updateTag({ name: "article:author", content: author });
+            this.meta.updateTag({ name: "author", content: author });
+        }
+        else {
+            this.meta.removeTag(`name='article:author'`);
+            this.meta.removeTag(`name='author'`);
+        }
+    }
+    setTwitterSiteCreator(site) {
+        if (Boolean(site)) {
+            //this.meta.updateTag({ name: 'twitter:site', content: site });
+            if (typeof site !== "undefined") {
+                this.meta.updateTag({ name: "twitter:site", content: site });
+                this.meta.updateTag({ name: "twitter:creator", content: site });
+            }
+        }
+        else {
+            this.meta.removeTag(`name='twitter:site'`);
+            this.meta.removeTag(`name='twitter:creator'`);
+        }
+    }
+    setTwitterCard(card) {
+        if (Boolean(card)) {
+            if (typeof card !== "undefined") {
+                this.meta.updateTag({ name: "twitter:card", content: card });
+            }
+        }
+        else {
+            this.meta.removeTag(`name='twitter:card'`);
+        }
+    }
+    setFbAppId(appId) {
+        if (Boolean(appId)) {
+            if (typeof appId !== "undefined") {
+                this.meta.updateTag({ property: "fb:app_id", content: appId });
+            }
+        }
+        else {
+            this.meta.removeTag(`property='fb:app_id'`);
+        }
+    }
+    setMetaTag(metaTag) {
+        if (Boolean(metaTag.value)) {
+            if (typeof metaTag !== "undefined" &&
+                typeof metaTag.attr !== "undefined" &&
+                typeof metaTag.attrValue !== "undefined" &&
+                typeof metaTag.value !== "undefined") {
+                const metaTagObject = {
+                    [metaTag.attr]: metaTag.attrValue,
+                    content: metaTag.value
+                };
+                this.meta.updateTag(metaTagObject);
+            }
+        }
+        else {
+            const selector = `${metaTag.attr}='${metaTag.attrValue}'`;
+            this.meta.removeTag(selector);
+        }
+    }
+    setMetaTags(metaTags) {
+        for (const metaTag of metaTags) {
+            this.setMetaTag(metaTag);
+        }
+    }
+    setCanonicalUrl(url) {
+        // first remove potential previous url
+        const selector = `link[rel='canonical']`;
+        const canonicalElement = this._document.head.querySelector(selector);
+        if (canonicalElement) {
+            this._document.head.removeChild(canonicalElement);
+        }
+        if (url && url.length) {
+            const link = this._document.createElement("link");
+            link.setAttribute("rel", "canonical");
+            this._document.head.appendChild(link);
+            link.setAttribute("href", url);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SeoService, deps: [{ token: i1$4.Meta }, { token: i1$4.Title }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SeoService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SeoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [{ type: i1$4.Meta }, { type: i1$4.Title }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+
+class SessionStorageService {
+    constructor(platformService) {
+        this.platformService = platformService;
+    }
+    setItem(key, value) {
+        this.platformService.runOnBrowser(() => {
+            sessionStorage.setItem(key, value);
+        });
+    }
+    getItem(key) {
+        return this.platformService.runOnBrowser(() => {
+            return sessionStorage.getItem(key);
+        });
+    }
+    removeItem(key) {
+        this.platformService.runOnBrowser(() => {
+            sessionStorage.removeItem(key);
+        });
+    }
+    clear() {
+        this.platformService.runOnBrowser(() => {
+            sessionStorage.clear();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SessionStorageService, deps: [{ token: PlatformService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SessionStorageService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SessionStorageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: PlatformService }] });
+
+class WindowService {
+    constructor(platformService) {
+        this.platformService = platformService;
+    }
+    get nativeWindow() {
+        return this.platformService.getWindow();
+    }
+    get configApp() {
+        return this.nativeWindow?.__CONFIG_APP__ ?? null;
+    }
+    getConfigValue(key) {
+        return this.configApp?.[key] ?? null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: WindowService, deps: [{ token: PlatformService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: WindowService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: WindowService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: PlatformService }] });
+
+/*
+ * Public API Surface of core/infrastructure
+ */
+// Guards
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { API_SERVICE_CONFIG, APP_ENVIRONMENT, AUTH_DIALOG_SERVICE, ApiService, AppConfigService, AppInitializeService, AuthGuard, AuthService, BreakpointService, CacheService, CookieService, DocumentService, FileAIA_GCSService, FileGCSService, FileService, FileWAPGCSService, LoaderService, LoadingService, LoadingSpinnerService, LocalStorageService, NgxSeoMetaTagAttr, OverlayService, PlatformService, RequestCacheService, ResponsiveService, SearchEventBridgeService, SeoService, SessionStorageService, SessionValidationError, ShellSearchEventType, StorageService, WindowService, authInterceptor, duplicateRequestInterceptor, errorInterceptor, loadingInterceptor, provideSearchEventBridge };
+//# sourceMappingURL=web-portal-core-infrastructure.mjs.map