@bnsights/bbsf-utilities 1.2.5 → 1.2.8-beta.1

package/fesm2022/bnsights-bbsf-utilities.mjs

@@ -12,11 +12,11 @@ import * as i4$1 from 'ngx-cookie-service';
 import { CookieService } from 'ngx-cookie-service';
 import * as i1 from '@angular/common/http';
 import { HttpParams, HttpErrorResponse, HttpHeaders } from '@angular/common/http';
-import { Subject, throwError, of, Observable, lastValueFrom, BehaviorSubject } from 'rxjs';
+import { Subject, switchMap, tap, take, takeUntil, throwError, of, Observable, lastValueFrom, BehaviorSubject } from 'rxjs';
 import { JwtHelperService } from '@auth0/angular-jwt';
 import { __decorate } from 'tslib';
 import { plainToClass } from 'class-transformer';
-import { takeUntil, tap, map, shareReplay, take, filter, switchMap } from 'rxjs/operators';
+import { takeUntil as takeUntil$1, tap as tap$1, map, shareReplay, take as take$1, filter, switchMap as switchMap$1 } from 'rxjs/operators';
 import * as i1$2 from '@angular/service-worker';
 
 class User {
@@ -67,10 +67,6 @@ class ConfigurationService {
     constructor(httpClient, injector) {
         this.httpClient = httpClient;
         this.injector = injector;
-        this.httpClient.get("./assets/config/configurations.json")
-            .subscribe(data => {
-            ConfigurationService.JsonData = data;
-        });
     }
     get authService() {
         if (!this._authService) {
@@ -386,39 +382,63 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.16", ngImpo
         }] });
 
 class MasterLayoutService {
-    constructor(router, http, authService, stylesBundleService, translate, environmentService) {
+    constructor(router, http, authService, stylesBundleService, translate, fileLoaderService) {
         this.router = router;
         this.http = http;
         this.authService = authService;
         this.stylesBundleService = stylesBundleService;
         this.translate = translate;
-        this.environmentService = environmentService;
+        this.fileLoaderService = fileLoaderService;
         this.apiUrl = '/api/Home/';
+        this.destroy$ = new Subject();
     }
     switchLang(lang, bundleEnglishName, bundleArabicName) {
-        if (this.authService.isAuthenticated()) {
-            this.changeLanguage(lang).subscribe((result) => {
-                this.updateUserInfo().subscribe((Value) => {
-                    let UserInfoObject = Value;
-                    this.authService.handleAccessToken(UserInfoObject.token);
-                    this.stylesBundleService.loadThemes(lang, bundleEnglishName, bundleArabicName);
-                    localStorage.setItem('language', lang);
-                    this.translate.use(lang);
-                });
-            });
+        if (!lang?.trim()) {
+            return;
         }
-        else
+        if (!this.authService.isAuthenticated()) {
             this.router.navigate(['/Admin/account/login']);
+            return;
+        }
+        this.changeLanguage(lang).pipe(switchMap(() => this.updateUserInfo()), tap((userInfo) => {
+            if (!userInfo?.token) {
+                return;
+            }
+            this.authService.handleAccessToken(userInfo.token).then(async () => {
+                this.stylesBundleService.loadThemes(lang, bundleEnglishName, bundleArabicName);
+                localStorage.setItem('language', lang);
+                try {
+                    await this.fileLoaderService.loadLanguage(lang);
+                }
+                catch (e) {
+                    this.logError(e?.message || `loadLanguage failed for ${lang}`).pipe(take(1)).subscribe();
+                }
+                this.translate.use(lang);
+            });
+        }), takeUntil(this.destroy$)).subscribe({
+            error: (error) => {
+                this.logError(error?.message || 'switchLang failed').pipe(take(1)).subscribe();
+            }
+        });
     }
     reloadComponent() {
-        let currentUrl = this.router.url;
+        const currentUrl = this.router.url;
+        const previousShouldReuseRoute = this.router.routeReuseStrategy.shouldReuseRoute;
+        const previousOnSameUrlNavigation = this.router.onSameUrlNavigation;
         this.router.routeReuseStrategy.shouldReuseRoute = () => false;
         this.router.onSameUrlNavigation = 'reload';
-        this.router.navigate([currentUrl]);
+        this.router.navigate([currentUrl]).finally(() => {
+            this.router.routeReuseStrategy.shouldReuseRoute = previousShouldReuseRoute;
+            this.router.onSameUrlNavigation = previousOnSameUrlNavigation;
+        });
     }
     changeLanguage(key) {
+        const profile = this.authService.getCurrentUserProfile();
+        if (!profile?.id) {
+            return this.logError('changeLanguage failed: missing user profile id');
+        }
         let params = new HttpParams();
-        params = params.append('UserId', AuthService.user.profile.id);
+        params = params.append('UserId', profile.id);
         params = params.append('LanguageKey', key);
         return this.http.post(this.apiUrl + 'UpdateLanguage', null, null, params);
     }
@@ -431,20 +451,34 @@ class MasterLayoutService {
         return this.http.get(this.apiUrl + 'UpdateUserInfo', null, null);
     }
     switchRole(permissionSetID) {
-        this.updateRole(permissionSetID).subscribe((result) => {
-            this.updateUserInfo().subscribe((Value) => {
-                let UserInfoObject = Value;
-                this.authService.handleAccessToken(UserInfoObject.token);
-            });
+        if (!permissionSetID?.trim()) {
+            return;
+        }
+        this.updateRole(permissionSetID).pipe(switchMap(() => this.updateUserInfo()), tap((userInfo) => {
+            if (userInfo?.token) {
+                this.authService.handleAccessToken(userInfo.token);
+            }
+        }), takeUntil(this.destroy$)).subscribe({
+            error: (error) => {
+                this.logError(error?.message || 'switchRole failed').pipe(take(1)).subscribe();
+            }
         });
     }
     updateRole(permissionSetID) {
+        const profile = this.authService.getCurrentUserProfile();
+        if (!profile?.id) {
+            return this.logError('updateRole failed: missing user profile id');
+        }
         let params = new HttpParams();
-        params = params.append('UserId', AuthService.user.profile.id);
+        params = params.append('UserId', profile.id);
         params = params.append('RoleID', permissionSetID);
         return this.http.post(this.apiUrl + 'SwitchRole', null, null, params);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.16", ngImport: i0, type: MasterLayoutService, deps: [{ token: i1$1.Router }, { token: RequestHandlerService }, { token: AuthService }, { token: StylesBundleService }, { token: i4.TranslateService }, { token: EnvironmentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.16", ngImport: i0, type: MasterLayoutService, deps: [{ token: i1$1.Router }, { token: RequestHandlerService }, { token: AuthService }, { token: StylesBundleService }, { token: i4.TranslateService }, { token: FileLoaderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.16", ngImport: i0, type: MasterLayoutService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.16", ngImport: i0, type: MasterLayoutService, decorators: [{
@@ -452,7 +486,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.16", ngImpo
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [{ type: i1$1.Router }, { type: RequestHandlerService }, { type: AuthService }, { type: StylesBundleService }, { type: i4.TranslateService }, { type: EnvironmentService }] });
+        }], ctorParameters: () => [{ type: i1$1.Router }, { type: RequestHandlerService }, { type: AuthService }, { type: StylesBundleService }, { type: i4.TranslateService }, { type: FileLoaderService }] });
 
 class RequestHandlerService {
     constructor(http, authService, environmentService, utilityService, bbsfTranslateService) {
@@ -488,7 +522,7 @@ class RequestHandlerService {
         let headers = this.getHeaders();
         if (!currentRequestOptions.disableBlockUI)
             this.utilityService.startBlockUI();
-        return this.http.get(this.environmentService.getApiUrl() + Url, { headers: headers, params: params }).pipe(takeUntil(this.onDestroy$), tap((result) => {
+        return this.http.get(this.environmentService.getApiUrl() + Url, { headers: headers, params: params }).pipe(takeUntil$1(this.onDestroy$), tap$1((result) => {
             if (!currentRequestOptions.disableBlockUI)
                 this.utilityService.stopBlockUI();
         }, error => {
@@ -513,7 +547,7 @@ class RequestHandlerService {
         let headers = this.getHeaders();
         if (!currentRequestOptions.disableBlockUI)
             this.utilityService.startBlockUI();
-        return this.http.post(this.environmentService.getApiUrl() + Url, model, { headers: headers, params: params, responseType: currentRequestOptions.responseType }).pipe(takeUntil(this.onDestroy$), tap((result) => {
+        return this.http.post(this.environmentService.getApiUrl() + Url, model, { headers: headers, params: params, responseType: currentRequestOptions.responseType }).pipe(takeUntil$1(this.onDestroy$), tap$1((result) => {
             if (!currentRequestOptions.disableBlockUI)
                 this.utilityService.stopBlockUI();
         }, error => {
@@ -538,7 +572,7 @@ class RequestHandlerService {
         let headers = this.getHeaders();
         if (!currentRequestOptions.disableBlockUI)
             this.utilityService.startBlockUI();
-        return this.http.delete(this.environmentService.getApiUrl() + Url + `/${deletedId}`, { headers: headers, params: params }).pipe(takeUntil(this.onDestroy$), tap((result) => {
+        return this.http.delete(this.environmentService.getApiUrl() + Url + `/${deletedId}`, { headers: headers, params: params }).pipe(takeUntil$1(this.onDestroy$), tap$1((result) => {
             if (!currentRequestOptions.disableBlockUI)
                 this.utilityService.stopBlockUI();
         }, error => {
@@ -563,7 +597,7 @@ class RequestHandlerService {
         let headers = this.getHeaders();
         if (!currentRequestOptions.disableBlockUI)
             this.utilityService.startBlockUI();
-        return this.http.put(this.environmentService.getApiUrl() + Url, model, { headers: headers, params: params, responseType: currentRequestOptions.responseType }).pipe(takeUntil(this.onDestroy$), tap((result) => {
+        return this.http.put(this.environmentService.getApiUrl() + Url, model, { headers: headers, params: params, responseType: currentRequestOptions.responseType }).pipe(takeUntil$1(this.onDestroy$), tap$1((result) => {
             if (!currentRequestOptions.disableBlockUI)
                 this.utilityService.stopBlockUI();
         }, error => {
@@ -594,7 +628,7 @@ class RequestHandlerService {
         headers = headers.set('ignore-cookies', 'true');
         if (!currentRequestOptions.disableBlockUI)
             this.utilityService.startBlockUI();
-        return this.http.patch(this.environmentService.getApiUrl() + Url, model, { headers: headers, params: params, responseType: currentRequestOptions.responseType }).pipe(takeUntil(this.onDestroy$), tap((result) => {
+        return this.http.patch(this.environmentService.getApiUrl() + Url, model, { headers: headers, params: params, responseType: currentRequestOptions.responseType }).pipe(takeUntil$1(this.onDestroy$), tap$1((result) => {
             if (!currentRequestOptions.disableBlockUI)
                 this.utilityService.stopBlockUI();
         }, error => {
@@ -619,7 +653,7 @@ class RequestHandlerService {
         let headers = this.getHeaders();
         if (!currentRequestOptions.disableBlockUI)
             this.utilityService.startBlockUI();
-        return this.http.get(this.environmentService.getApiUrl() + Url, { headers: headers, params: params, responseType: currentRequestOptions.responseType }).pipe(takeUntil(this.onDestroy$), tap((result) => {
+        return this.http.get(this.environmentService.getApiUrl() + Url, { headers: headers, params: params, responseType: currentRequestOptions.responseType }).pipe(takeUntil$1(this.onDestroy$), tap$1((result) => {
             if (!currentRequestOptions.disableBlockUI)
                 this.utilityService.stopBlockUI();
         }, error => {
@@ -637,7 +671,7 @@ class RequestHandlerService {
         }
         const currentRequestOptions = requestOptions || new RequestOptionsModel();
         let headers = this.getHeadersUpdated();
-        return this.http.post(this.environmentService.getApiUrl() + Url, model, { headers: headers, reportProgress: true, observe: 'events' }).pipe(takeUntil(this.onDestroy$), tap((result) => {
+        return this.http.post(this.environmentService.getApiUrl() + Url, model, { headers: headers, reportProgress: true, observe: 'events' }).pipe(takeUntil$1(this.onDestroy$), tap$1((result) => {
             if (!currentRequestOptions.disableBlockUI)
                 this.utilityService.stopBlockUI();
         }, error => {
@@ -896,13 +930,13 @@ class LanguageService {
         if (this.isLoaded || this.isLoading)
             return; // Sync guard prevents race condition
         this.isLoading = true; // Set immediately to block concurrent calls
-        this.loadRequest$ = this.http.get(this.apiUrl + 'GetAll', null, null).pipe(tap((languages) => {
+        this.loadRequest$ = this.http.get(this.apiUrl + 'GetAll', null, null).pipe(tap$1((languages) => {
             this._languages = languages;
             this.isLoaded = true;
             this.isLoading = false;
         }), shareReplay(1));
         // take(1) ensures auto-unsubscribe after completion
-        this.loadRequest$.pipe(take(1)).subscribe({
+        this.loadRequest$.pipe(take$1(1)).subscribe({
             error: (err) => {
                 this.isLoading = false;
                 this.loadRequest$ = null;
@@ -1007,8 +1041,23 @@ class FileLoaderService {
         this.translate = translate;
         this.http = http;
         this.availableLanguages = ['en', 'ar']; // Add more languages as needed
+        this.loadedLanguages = new Set();
         this.translate.addLangs(this.availableLanguages);
     }
+    async preloadAll() {
+        const defaultLang = this.getDefaultLanguage();
+        try {
+            await Promise.all([
+                this.loadEnvironment(),
+                this.loadConfigurations(),
+                this.loadLanguage(defaultLang),
+            ]);
+            this.translate.use(defaultLang);
+        }
+        catch (error) {
+            console.error('Error during preloadAll:', error);
+        }
+    }
     loadEnvironment() {
         return new Promise((resolve, reject) => {
             const script = document.createElement('script');
@@ -1026,6 +1075,32 @@ class FileLoaderService {
             document.head.insertBefore(script, document.head.firstChild);
         });
     }
+    async loadConfigurations() {
+        const data = await lastValueFrom(this.http.get('./assets/config/configurations.json'));
+        ConfigurationService.JsonData = data;
+    }
+    getDefaultLanguage() {
+        const lang = localStorage.getItem('language');
+        if (lang && this.availableLanguages.includes(lang)) {
+            return lang;
+        }
+        return 'en';
+    }
+    async loadLanguage(lang) {
+        const normalizedLang = (lang || '').trim();
+        if (!normalizedLang) {
+            return;
+        }
+        if (!this.availableLanguages.includes(normalizedLang)) {
+            return;
+        }
+        if (this.loadedLanguages.has(normalizedLang)) {
+            return;
+        }
+        const translations = await lastValueFrom(this.http.get(`/assets/i18n/${normalizedLang}.json`));
+        this.translate.setTranslation(normalizedLang, translations, true);
+        this.loadedLanguages.add(normalizedLang);
+    }
     async preloadTranslations() {
         try {
             const requests = this.availableLanguages.map(async (lang) => {
@@ -1054,7 +1129,12 @@ class ServiceWorkerHelperService {
         this.updates = updates;
         this.swRegistration = null;
         this.updateCheckInProgress = false;
+        this.chunkHandlersRegistered = false;
+        this.chunkRecoveryInFlight = false;
+        this.sessionRecoveryAttemptsKey = 'bbsf_chunk_recovery_count';
+        this.maxChunkRecoveryAttempts = 3;
         this.initializeServiceWorker();
+        this.setupChunkErrorHandler();
     }
     checkForUpdates() {
         if (!this.updates.isEnabled) {
@@ -1065,8 +1145,6 @@ class ServiceWorkerHelperService {
         this.setupUpdateListeners();
         // Start smart checking for updates
         this.startSmartUpdateChecking();
-        // CRITICAL: Handle chunk load errors
-        this.setupChunkErrorHandler();
     }
     setupUpdateListeners() {
         this.updates.versionUpdates
@@ -1076,7 +1154,7 @@ class ServiceWorkerHelperService {
             this.skipWaiting();
         });
         this.updates.versionUpdates
-            .pipe(filter((event) => event.type === 'VERSION_READY'), switchMap(() => this.updates.activateUpdate()))
+            .pipe(filter((event) => event.type === 'VERSION_READY'), switchMap$1(() => this.updates.activateUpdate()))
             .subscribe(() => {
             console.log('New version activated, reloading page...');
             // CRITICAL FIX: Reload the page after activation
@@ -1142,38 +1220,92 @@ class ServiceWorkerHelperService {
             this.swRegistration.waiting.postMessage({ type: 'SKIP_WAITING' });
         }
     }
-    // CRITICAL: Handle chunk load errors
     setupChunkErrorHandler() {
+        if (this.chunkHandlersRegistered) {
+            return;
+        }
+        this.chunkHandlersRegistered = true;
         window.addEventListener('error', (event) => {
-            const chunkFailedMessage = /Loading chunk [\d]+ failed|ChunkLoadError/i;
-            const isChunkError = event.message && chunkFailedMessage.test(event.message);
-            if (isChunkError) {
-                console.warn('Chunk load error detected, attempting recovery...');
-                event.preventDefault(); // Prevent default error handling
-                this.handleChunkLoadError();
+            if (!this.isChunkErrorEvent(event)) {
+                return;
             }
+            console.warn('Chunk load error detected, attempting recovery...');
+            event.preventDefault();
+            this.handleChunkLoadError();
         });
-        // Also handle unhandled promise rejections (some chunk errors appear here)
         window.addEventListener('unhandledrejection', (event) => {
-            const reason = event.reason?.message || event.reason?.toString() || '';
-            const isChunkError = /Loading chunk [\d]+ failed|ChunkLoadError/i.test(reason);
-            if (isChunkError) {
-                console.warn('Chunk load error in promise, attempting recovery...');
-                event.preventDefault();
-                this.handleChunkLoadError();
+            const reason = event.reason;
+            const text = (reason && typeof reason === 'object' && 'message' in reason
+                ? String(reason.message)
+                : '') || (reason instanceof Error ? reason.message : String(reason ?? ''));
+            const name = reason instanceof Error ? reason.name : '';
+            if (!this.isChunkLoadFailure(reason, text) && name !== 'ChunkLoadError') {
+                return;
             }
+            console.warn('Chunk load error in promise, attempting recovery...');
+            event.preventDefault();
+            this.handleChunkLoadError();
         });
     }
+    isChunkErrorEvent(event) {
+        const ev = event;
+        const message = ev.message || '';
+        const scriptSrc = event.target instanceof HTMLScriptElement ? event.target.src || undefined : undefined;
+        return this.isChunkLoadFailure(ev.error, message, scriptSrc);
+    }
+    isChunkLoadFailure(error, message, scriptSrc) {
+        const segments = [message];
+        if (error instanceof Error) {
+            segments.push(error.message, error.name);
+        }
+        else if (error && typeof error === 'object' && 'message' in error) {
+            segments.push(String(error.message));
+        }
+        else if (error != null) {
+            segments.push(String(error));
+        }
+        const text = segments.join(' ');
+        if (/Loading chunk .+ failed/i.test(text)) {
+            return true;
+        }
+        if (/ChunkLoadError/i.test(text)) {
+            return true;
+        }
+        if (/Failed to fetch dynamically imported module/i.test(text)) {
+            return true;
+        }
+        if (scriptSrc && /\.js(\?|#|$)/i.test(scriptSrc)) {
+            const looksLikeBundle = /chunk|main|runtime|polyfills|vendor/i.test(scriptSrc) ||
+                /\/\d+\.[\w.-]*\.js(\?|#|$)/i.test(scriptSrc);
+            const opaqueOrEmpty = !message || message === 'Script error.';
+            if (looksLikeBundle && opaqueOrEmpty) {
+                return true;
+            }
+        }
+        return false;
+    }
     handleChunkLoadError() {
-        // Check if we've already tried to recover recently (prevent infinite loops)
-        const lastReloadTime = localStorage.getItem('lastChunkErrorReload');
-        const now = Date.now();
-        if (lastReloadTime && (now - parseInt(lastReloadTime, 10)) < 5000) {
-            console.error('Multiple chunk errors in short time, skipping auto-reload');
+        if (this.chunkRecoveryInFlight) {
             return;
         }
-        localStorage.setItem('lastChunkErrorReload', now.toString());
-        // Clear cache and reload
+        let attempts = 0;
+        try {
+            attempts = parseInt(sessionStorage.getItem(this.sessionRecoveryAttemptsKey) || '0', 10);
+        }
+        catch {
+            /* private / blocked storage */
+        }
+        if (attempts >= this.maxChunkRecoveryAttempts) {
+            console.error('Chunk error recovery limit reached for this session; not reloading again.');
+            return;
+        }
+        try {
+            sessionStorage.setItem(this.sessionRecoveryAttemptsKey, String(attempts + 1));
+        }
+        catch {
+            /* ignore */
+        }
+        this.chunkRecoveryInFlight = true;
         this.clearCacheAndReload();
     }
     clearCacheAndReload() {
@@ -1222,15 +1354,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.16", ngImpo
 class AuthService {
     static { this.user = null; }
     get user() {
-        if (!this._user) {
-            this._user = this.getUserManager();
+        // Always use static as source of truth
+        // Only hydrate if static is null
+        if (!AuthService.user) {
+            this.getUserManager(); // This will set AuthService.user
         }
-        return this._user;
+        return AuthService.user; // Always return fresh static value
     }
     static { this.UserClaims = null; }
     //refresh
     static { this.timers = []; }
     static { this.seconds = 0; }
+    static { this.isLoginInProgress = false; }
     constructor(injector, http, environmentService, translateService, router, cookieService, utilityService) {
         this.injector = injector;
         this.http = http;
@@ -1243,6 +1378,9 @@ class AuthService {
         this.jwtHelper = new JwtHelperService();
         this.isAuthenticatedSubject = new BehaviorSubject(this.hasToken());
         this.isAuthenticate$ = this.isAuthenticatedSubject.asObservable();
+        // User cache to prevent inconsistent multi-call results
+        this._userCache = null;
+        this.USER_CACHE_TTL = 100; // ms
         // Listen for logout events from other tabs
         window.addEventListener('storage', (event) => {
             if (event.key === 'auth_logout_broadcast' && event.newValue) {
@@ -1262,6 +1400,11 @@ class AuthService {
         return token && !this.jwtHelper.isTokenExpired(token);
     }
     getUserManager() {
+        const now = Date.now();
+        // Return cached user if fresh (within 100ms TTL)
+        if (this._userCache && now - this._userCache.timestamp < this.USER_CACHE_TTL) {
+            return this._userCache.user;
+        }
         const token = this.cookieService.get(this.TOKEN_KEY);
         if (token) {
             try {
@@ -1270,10 +1413,7 @@ class AuthService {
                 const expiryDate = this.jwtHelper.getTokenExpirationDate(token);
                 const hasTimeLeft = expiryDate && expiryDate.getTime() > Date.now();
                 if (!isExpired && hasTimeLeft) {
-                    // Only hydrate if user is null OR token has changed
-                    if (!AuthService.user || AuthService.user.access_token !== token) {
-                        this.handleAccessTokenWithoutLanguage(token);
-                    }
+                    this.handleAccessTokenWithoutLanguage(token);
                 }
                 else {
                     this.clearLocalAuthState({ keepRedirectUrl: true });
@@ -1287,13 +1427,17 @@ class AuthService {
         else {
             this.clearLocalAuthState({ keepRedirectUrl: true });
         }
+        // Update cache with current user state
+        this._userCache = { user: AuthService.user, timestamp: now };
         return AuthService.user;
     }
     getUser() {
-        this._user = AuthService.user;
+        // No-op: getter now always reads from static
+        // Kept for backward compatibility
     }
     storUser(User) {
-        AuthService.user = this._user = this.user;
+        // Getter now always reads from static, so we don't need to sync
+        // This method appears unused but kept for backward compatibility
     }
     getCurrentUser() {
         return AuthService.user;
@@ -1308,13 +1452,17 @@ class AuthService {
         return AuthService.user?.profile ?? null;
     }
     isAuthenticated() {
-        AuthService.user = this.user;
-        if (!AuthService.user)
+        const user = this.user; // Call getter to ensure hydrated
+        if (!user) {
             return false;
+        }
         // Add 10-second grace period to prevent race conditions
-        const expiryDate = new Date(AuthService.user.expires_at);
+        const expiryDate = new Date(user.expires_at);
         const nowWithBuffer = new Date(Date.now() + 10000);
-        return expiryDate.getTime() > nowWithBuffer.getTime();
+        const now = new Date();
+        const secondsUntilExpiry = (expiryDate.getTime() - now.getTime()) / 1000;
+        const result = expiryDate.getTime() > nowWithBuffer.getTime();
+        return result;
     }
     isUserInRole(allowedPermission) {
         const profile = this.getCurrentUserProfile();
@@ -1362,8 +1510,12 @@ class AuthService {
      */
     clearLocalAuthState(options) {
         // Clear timers
-        AuthService.timers.map(t => clearInterval(t));
+        AuthService.timers.forEach((t) => {
+            clearInterval(t);
+        });
         AuthService.timers = [];
+        // Reset seconds counter to prevent stale timers
+        AuthService.seconds = 0;
         // Clear memory
         AuthService.user = null;
         this._user = null;
@@ -1374,6 +1526,8 @@ class AuthService {
         if (options?.keepRedirectUrl !== true) {
             localStorage.removeItem('redirectUrl');
         }
+        // Invalidate user cache since auth state is cleared
+        this._userCache = null;
         this.isAuthenticatedSubject.next(false);
     }
     signOut() {
@@ -1412,24 +1566,37 @@ class AuthService {
         return this.http.get(this.environmentService.getBaseUrl() + ApiUrl + 'ClearCurrentUserSession', httpOptions);
     }
     async handleAccessToken(response) {
-        const token = response;
-        // Clear timers only (don't delete cookie to avoid race condition window)
-        AuthService.timers.map(t => clearInterval(t));
-        AuthService.timers = [];
-        // Update user atomically
-        AuthService.user = new User();
-        AuthService.user.token_type = "Bearer";
-        AuthService.user.access_token = token;
-        AuthService.user.profile = this.jwtHelper.decodeToken(token);
-        AuthService.user.expires_at = this.jwtHelper.getTokenExpirationDate(token);
-        this._user = AuthService.user;
-        // Update cookie atomically (no deletion window)
-        this.cookieService.set(this.TOKEN_KEY, token, AuthService.user.expires_at, "/", null, true, 'Lax');
-        localStorage.setItem("language", AuthService.user.profile.locale);
-        this.isAuthenticatedSubject.next(true);
-        this.setTokenSeconds();
-        AuthService.timers.push(this.checkRefreshToken());
-        await this.updateLanguage();
+        AuthService.isLoginInProgress = true;
+        try {
+            const token = response;
+            // AGGRESSIVE timer cleanup before starting new session
+            AuthService.timers.map(t => clearInterval(t));
+            AuthService.timers = [];
+            AuthService.seconds = 0; // Reset counter
+            // Brief pause to ensure intervals are cleared
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Update user atomically
+            AuthService.user = new User();
+            AuthService.user.token_type = "Bearer";
+            AuthService.user.access_token = token;
+            AuthService.user.profile = this.jwtHelper.decodeToken(token);
+            AuthService.user.expires_at = this.jwtHelper.getTokenExpirationDate(token);
+            // Add 5-minute buffer to cookie expiry to prevent browser deletion before refresh
+            // JWT expiry in isAuthenticated() remains authoritative
+            const cookieExpiry = new Date(AuthService.user.expires_at.getTime() + (5 * 60 * 1000));
+            // Update cookie atomically (no deletion window)
+            this.cookieService.set(this.TOKEN_KEY, token, cookieExpiry, "/", null, true, 'Lax');
+            localStorage.setItem("language", AuthService.user.profile.locale);
+            this.isAuthenticatedSubject.next(true);
+            // Invalidate user cache since we have a new token
+            this._userCache = null;
+            this.setTokenSeconds();
+            AuthService.timers.push(this.checkRefreshToken());
+            await this.updateLanguage();
+        }
+        finally {
+            AuthService.isLoginInProgress = false;
+        }
     }
     handleAccessTokenWithoutLanguage(response) {
         const token = response;
@@ -1442,11 +1609,15 @@ class AuthService {
         AuthService.user.access_token = token;
         AuthService.user.profile = this.jwtHelper.decodeToken(token);
         AuthService.user.expires_at = this.jwtHelper.getTokenExpirationDate(token);
-        this._user = AuthService.user;
+        // Add 5-minute buffer to cookie expiry to prevent browser deletion before refresh
+        // JWT expiry in isAuthenticated() remains authoritative
+        const cookieExpiry = new Date(AuthService.user.expires_at.getTime() + (5 * 60 * 1000));
         // Update cookie atomically (no deletion window)
-        this.cookieService.set(this.TOKEN_KEY, token, AuthService.user.expires_at, "/", null, true, 'Lax');
+        this.cookieService.set(this.TOKEN_KEY, token, cookieExpiry, "/", null, true, 'Lax');
         localStorage.setItem("language", AuthService.user.profile.locale);
         this.isAuthenticatedSubject.next(true);
+        // Invalidate user cache since we have a new token
+        this._userCache = null;
         this.setTokenSeconds();
         AuthService.timers.push(this.checkRefreshToken());
     }
@@ -1464,23 +1635,68 @@ class AuthService {
     }
     checkRefreshToken() {
         let date = new Date();
-        return setInterval(() => {
-            if (Math.floor(AuthService.seconds) < 120 && this.isAuthenticated()) {
+        const timerId = setInterval(() => {
+            // Early exit if user logged out or no user exists
+            if (!AuthService.user) {
+                return;
+            }
+            const secondsRemaining = Math.floor(AuthService.seconds);
+            // Early exit if seconds is invalid (negative or zero means already expired/cleared)
+            if (secondsRemaining <= 0) {
+                return;
+            }
+            // Refresh when 30 seconds remain (instead of 120)
+            // This prevents continuous refresh loops with short-lived tokens
+            // Timer is cleared after triggering to ensure only ONE refresh per token cycle
+            if (secondsRemaining <= 30 && secondsRemaining > 0 && this.isAuthenticated()) {
+                // Double-check user still exists before refreshing
+                if (!AuthService.user) {
+                    return;
+                }
                 AuthService.timers.map(t => clearInterval(t));
                 AuthService.timers = [];
                 const token = this.cookieService.get(this.TOKEN_KEY);
                 if (token) {
                     this.refresh();
                 }
+                else {
+                    // Defensive: Token disappeared between isAuthenticated() check and now
+                    console.error('[REFRESH-TIMER] Token disappeared! Attempting recovery...', {
+                        timestamp: new Date().toISOString(),
+                        secondsRemaining,
+                        wasAuthenticated: true
+                    });
+                    // Try one more time after short delay
+                    setTimeout(() => {
+                        const retryToken = this.cookieService.get(this.TOKEN_KEY);
+                        if (retryToken) {
+                            this.refresh();
+                        }
+                        else {
+                            console.error('[REFRESH-TIMER] Token still missing after retry');
+                            // Don't clear auth state here - let natural expiry handle it
+                            // This prevents premature logout if user is still active
+                        }
+                    }, 100);
+                }
             }
             AuthService.seconds--;
         }, 1000);
+        return timerId;
     }
     setTokenSeconds() {
         let date = new Date();
         AuthService.seconds = (AuthService.user.expires_at - date) / 1000;
     }
     refresh() {
+        // Don't refresh if login is in progress
+        if (AuthService.isLoginInProgress) {
+            return;
+        }
+        // Don't refresh if user logged out
+        if (!AuthService.user) {
+            return;
+        }
         const refreshLockKey = 'auth_refreshing_lock';
         const lockValue = localStorage.getItem(refreshLockKey);
         // Check if another tab is refreshing (within last 5 seconds)
@@ -1489,6 +1705,10 @@ class AuthService {
         }
         // Acquire lock
         localStorage.setItem(refreshLockKey, Date.now().toString());
+        // IMPORTANT: Don't delete cookie before refresh to prevent:
+        // 1. Race condition window where no token exists
+        // 2. Repeated cookie deletion/recreation cycles with short-lived tokens
+        // The cookie will be atomically replaced by handleAccessTokenWithoutLanguage()
         const httpOptions = {
             headers: new HttpHeaders({
                 'Content-Type': 'application/json',
@@ -1498,16 +1718,56 @@ class AuthService {
         let ApiUrl = '/api/Home/';
         this.http.get(this.environmentService.getApiUrl() + ApiUrl + 'RefreshAccessToken', httpOptions).subscribe({
             next: (res) => {
+                // Check if user logged out during HTTP call
+                if (!AuthService.user) {
+                    localStorage.removeItem(refreshLockKey);
+                    return; // Abort - don't set new token
+                }
+                // Atomically replaces the old cookie with new token
                 this.handleAccessTokenWithoutLanguage(res.val);
                 localStorage.removeItem(refreshLockKey);
+                // Auto-navigate if user was redirected to login during token expiry
+                // this.handlePostRefreshNavigation();
             },
             error: (err) => {
-                // Only clear auth state if refresh actually failed
-                this.clearLocalAuthState({ keepRedirectUrl: true });
                 localStorage.removeItem(refreshLockKey);
+                // On error, old cookie remains valid until natural expiry
             }
         });
     }
+    /**
+     * Handles navigation after successful token refresh.
+     * If user is on login page and has a stored redirect URL, navigates to that URL.
+     * This resolves the issue where users remain on login page after token refresh.
+     * NOTE: This is not used anymore because we are using the async guard to wait for the refresh to complete before navigating to the protected route.
+     */
+    handlePostRefreshNavigation() {
+        // Get the stored redirect URL
+        const redirectUrl = this.getUrl(); // Returns localStorage 'redirectUrl' or "/"
+        // Get current URL
+        const currentUrl = this.router.url;
+        // Check if we're currently on the login page
+        const isOnLoginPage = currentUrl.toLowerCase().includes('login');
+        const isAuth = this.isAuthenticated();
+        // More lenient conditions:
+        // 1. User is authenticated
+        // 2. User is on login page
+        // 3. There's ANY redirect URL (even "/")
+        if (isAuth && isOnLoginPage) {
+            // Determine target URL
+            const targetUrl = redirectUrl && !redirectUrl.toLowerCase().includes('login')
+                ? redirectUrl
+                : '/Admin/Home'; // Default fallback instead of rejecting "/"
+            // Clear the stored redirect URL first
+            localStorage.removeItem('redirectUrl');
+            // Use setTimeout to ensure router has finished current navigation
+            // This prevents competing navigation attempts
+            setTimeout(() => {
+                this.router.navigate([targetUrl]);
+            }, 100);
+        }
+    }
+    //#region uaepass methods
     loginWithUAEPass() {
         const authEndpoint = `${this.environmentService.getUAEPassBaseUrl()}${this.environmentService.getUAEPassAuthorizationEndPoint()}`;
         const queryParams = {