cloud-ide-layout 1.0.124 → 1.0.125

package/fesm2022/{cloud-ide-layout-cloud-ide-layout-DJxJ2FIt.mjs → cloud-ide-layout-cloud-ide-layout-DdMf1j7_.mjs}

@@ -1,14 +1,13 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, signal, ComponentRef, ViewContainerRef, computed, effect, DestroyRef, Component, ViewChild, ElementRef, HostListener, ChangeDetectionStrategy, ViewChildren, viewChild, input, InjectionToken, PLATFORM_ID, output } from '@angular/core';
+import { Injectable, inject, signal, computed, effect, DestroyRef, Component, ViewChild, ElementRef, HostListener, ChangeDetectionStrategy, ComponentRef, ViewContainerRef, ViewChildren, viewChild, input, InjectionToken, PLATFORM_ID, output } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
 import { cidePath, hostManagerRoutesUrl, coreRoutesUrl, commonRoutesUrl, designConfigRoutesUrl, generateStringFromObject } from 'cloud-ide-lms-model';
-import { Observable, BehaviorSubject, throwError, of, interval, take as take$1, firstValueFrom } from 'rxjs';
-import { map, distinctUntilChanged, filter, tap, catchError, shareReplay, take } from 'rxjs/operators';
+import { Observable, throwError, of, BehaviorSubject, interval, take as take$1, firstValueFrom } from 'rxjs';
+import { map, filter, tap, catchError, shareReplay, take, distinctUntilChanged } from 'rxjs/operators';
 import * as i2 from '@angular/router';
-import { Router, RouteReuseStrategy, NavigationEnd, RouterModule, ActivatedRoute } from '@angular/router';
+import { Router, NavigationEnd, RouteReuseStrategy, RouterModule, ActivatedRoute } from '@angular/router';
 import { Title, DomSanitizer } from '@angular/platform-browser';
-import { CideEleFloatingContainerService, CideEleFileManagerService, CideElementsService, NotificationService, CideIconComponent, CideEleButtonComponent, CideInputComponent, CideSelectComponent, CideThemeService, WebSocketNotificationService, NotificationApiService, CideEleDropdownComponent, CideEleFileImageDirective, CideEleResizerDirective, TooltipDirective, CideSpinnerComponent, CideEleSkeletonLoaderComponent, KeyboardShortcutService, FloatingContainerShortcutsService, CideEleFloatingContainerManagerComponent, CideEleGlobalNotificationsComponent, CideEleBreadcrumbComponent } from 'cloud-ide-element';
-import { merge } from 'lodash';
+import { CideEleFileManagerService, CideElementsService, CideEleFloatingContainerService, NotificationService, CideIconComponent, CideEleButtonComponent, CideInputComponent, CideSelectComponent, CideThemeService, WebSocketNotificationService, NotificationApiService, CideEleDropdownComponent, CideEleFileImageDirective, CideEleResizerDirective, TooltipDirective, CideSpinnerComponent, CideEleSkeletonLoaderComponent, KeyboardShortcutService, FloatingContainerShortcutsService, CideEleFloatingContainerManagerComponent, CideEleGlobalNotificationsComponent, CideEleBreadcrumbComponent } from 'cloud-ide-element';
 import * as i1$1 from '@angular/common';
 import { CommonModule, NgClass, NgFor, NgIf, isPlatformBrowser } from '@angular/common';
 import { FINANCIAL_YEAR_SERVICE_TOKEN, ACADEMIC_YEAR_SERVICE_TOKEN, AUTH_SERVICE_TOKEN, authGuard, ENTITY_SERVICE_TOKEN } from 'cloud-ide-shared';
@@ -16,6 +15,7 @@ import * as i1 from '@angular/forms';
 import { FormBuilder, Validators, ReactiveFormsModule, FormsModule } from '@angular/forms';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { trigger, state, transition, style, animate } from '@angular/animations';
+import { merge } from 'lodash';
 
 class CloudIdeLayoutService {
     constructor() { }
@@ -247,1035 +247,464 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImpor
                 }]
         }] });
 
-/**
- * A custom route reuse strategy that allows storing and retrieving routes
- * to persist component state, especially for tabbed navigation.
- */
-class CustomRouteReuseStrategy {
-    storedRoutes = {};
-    // Generates a unique key for a route.
-    // For routes marked with 'reuseTab', this key includes sorted query parameters
-    // to ensure distinct states for tabs differing by query params.
-    getPathKey(route) {
-        let path = route.pathFromRoot
-            .map(r => r.url.map(segment => segment.path).join('/'))
-            .filter(p => p.length > 0)
-            .join('/');
-        // If the route is marked for tab reuse and has query parameters,
-        // append them to the key in a sorted, consistent manner.
-        if (route.data && route.data['reuseTab'] && route.queryParamMap.keys.length > 0) {
-            const queryParams = route.queryParamMap.keys
-                .sort() // Ensure consistent order of query parameters
-                .map(key => `${key}=${route.queryParamMap.get(key)}`)
-                .join('&');
-            path += '?' + queryParams;
-        }
-        return path;
-    }
-    // Determines if this route (and its subtree) should be detached to be reused later.
-    shouldDetach(route) {
-        return !!(route.data && route.data['reuseTab']);
-    }
-    // Stores the detached route.
-    store(route, handle) {
-        const pathKey = this.getPathKey(route);
-        if (handle && route.data && route.data['reuseTab'] && pathKey) {
-            this.storedRoutes[pathKey] = handle;
-        }
-    }
-    // Determines if this route (and its subtree) should be reattached.
-    shouldAttach(route) {
-        const pathKey = this.getPathKey(route);
-        return !!pathKey && !!this.storedRoutes[pathKey];
-    }
-    // Retrieves the previously stored route.
-    retrieve(route) {
-        const pathKey = this.getPathKey(route);
-        if (!pathKey || !this.storedRoutes[pathKey]) {
+class AppStateService {
+    // Inject services
+    fileManagerService = inject(CideEleFileManagerService);
+    // Private signal for current user
+    currentUserSignal = signal(null, ...(ngDevMode ? [{ debugName: "currentUserSignal" }] : []));
+    // Private signal for active module
+    activeModuleSignal = signal(null, ...(ngDevMode ? [{ debugName: "activeModuleSignal" }] : []));
+    // Private signal for active entity
+    activeEntitySignal = signal(null, ...(ngDevMode ? [{ debugName: "activeEntitySignal" }] : []));
+    // Track if entity change handler is initialized (to prevent triggering on initial load)
+    entityChangeHandlerInitialized = false;
+    // Callback registration for entity change handlers (to avoid circular dependencies)
+    entityChangeCallbacks = [];
+    // Public computed signal for current user, for other services to get the user value
+    currentUser = computed(() => this.currentUserSignal(), ...(ngDevMode ? [{ debugName: "currentUser" }] : []));
+    // Public computed signal for active module
+    activeModule = computed(() => this.activeModuleSignal(), ...(ngDevMode ? [{ debugName: "activeModule" }] : []));
+    // Public computed signal for active entity
+    activeEntity = computed(() => this.activeEntitySignal(), ...(ngDevMode ? [{ debugName: "activeEntity" }] : []));
+    // Computed signals for derived state
+    isAuthenticated = computed(() => !!this.currentUserSignal(), ...(ngDevMode ? [{ debugName: "isAuthenticated" }] : []));
+    userInfo = computed(() => {
+        const user = this.currentUserSignal();
+        if (!user)
             return null;
-        }
-        const handle = this.storedRoutes[pathKey];
-        // Verify the handle is still valid (not destroyed)
-        // If the component was destroyed, remove it from stored routes
-        if (handle && typeof handle === 'object') {
-            const handleAny = handle;
-            // Check if ComponentRef is destroyed
-            if (handleAny.destroyed === true || (handleAny.hostView && handleAny.hostView.destroyed)) {
-                console.log(`⚠️ Stored route handle for ${pathKey} is already destroyed, removing from cache`);
-                delete this.storedRoutes[pathKey];
-                return null;
+        return {
+            id: user._id,
+            name: user.user_fullname || `${user.user_firstname} ${user.user_lastname}`,
+            email: user.user_emailid,
+            role: "" // user.user_id_role
+        };
+    }, ...(ngDevMode ? [{ debugName: "userInfo" }] : []));
+    // Computed signal for active module info
+    activeModuleInfo = computed(() => {
+        const module = this.activeModuleSignal();
+        if (!module)
+            return null;
+        return {
+            id: module._id,
+            title: module.syme_title,
+            icon: module.syme_icon,
+            path: module.syme_path,
+            type: module.syme_type
+        };
+    }, ...(ngDevMode ? [{ debugName: "activeModuleInfo" }] : []));
+    constructor() {
+        // Initialize file manager base URL on app startup
+        this.fileManagerService.setBaseUrl(cidePath.join([hostManagerRoutesUrl.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.fileManager]));
+        this.fileManagerService.setObjectIdEndpoint(cidePath.join([hostManagerRoutesUrl.cideSuiteHost, commonRoutesUrl?.module, commonRoutesUrl?.generateObjectId]));
+        // Load initial state from localStorage
+        this.loadFromLocalStorage();
+        // Save to localStorage whenever state changes
+        effect(() => {
+            const currentUser = this.currentUserSignal();
+            const activeModule = this.activeModuleSignal();
+            const activeEntity = this.activeEntitySignal();
+            this.saveToLocalStorage({
+                user: currentUser,
+                activeModule: activeModule,
+                activeEntity: activeEntity
+            });
+        });
+        // Automatically update file manager user ID whenever user changes
+        effect(() => {
+            const currentUser = this.currentUserSignal();
+            console.log('🔍 [AppStateService] User changed, updating file manager user ID:', currentUser);
+            if (currentUser?._id) {
+                this.fileManagerService.setUserId(currentUser._id);
             }
-        }
-        return handle;
-    }
-    // Determines if a route should be reused.
-    shouldReuseRoute(future, curr) {
-        return future.routeConfig === curr.routeConfig;
-    }
-    // Clears a stored route, typically when a tab is closed.
-    // This method now properly destroys the component instance to prevent memory leaks
-    // and ensure old data doesn't persist when reopening the same route.
-    clearStoredRoute(pathKey) {
-        const handle = this.storedRoutes[pathKey];
-        if (handle) {
-            // Properly destroy the component instance to prevent memory leaks
-            // and ensure clean state when the route is reopened
-            try {
-                // In Angular, DetachedRouteHandle is typically a ComponentRef
-                // We need to destroy it to remove the component from DOM and clean up resources
-                // Method 1: Check if handle is a ComponentRef directly
-                if (handle && typeof handle.destroy === 'function') {
-                    const componentRef = handle;
-                    // Verify it has hostView (ComponentRef signature)
-                    if (componentRef.hostView || componentRef.location) {
-                        console.log(`🗑️ Destroying component instance (ComponentRef) for route: ${pathKey}`);
-                        componentRef.destroy();
-                    }
-                }
-                // Method 2: Check if handle is a ViewContainerRef
-                if (handle && typeof handle.clear === 'function' && typeof handle.length === 'number') {
-                    const viewContainerRef = handle;
-                    console.log(`🗑️ Clearing view container for route: ${pathKey}`);
-                    viewContainerRef.clear();
-                }
-                // Method 3: Check if handle is an object with nested ComponentRef
-                if (handle && typeof handle === 'object' && !(handle instanceof ComponentRef) && !(handle instanceof ViewContainerRef)) {
-                    const handleObj = handle;
-                    // Try to find and destroy ComponentRef from various possible properties
-                    let componentRef = null;
-                    // Check common property names
-                    if (handleObj.componentRef && typeof handleObj.componentRef.destroy === 'function') {
-                        componentRef = handleObj.componentRef;
-                    }
-                    else if (handleObj.component && typeof handleObj.component.destroy === 'function') {
-                        componentRef = handleObj.component;
-                    }
-                    else if (handleObj.context && typeof handleObj.context.destroy === 'function') {
-                        componentRef = handleObj.context;
-                    }
-                    else if (handleObj._componentRef && typeof handleObj._componentRef.destroy === 'function') {
-                        componentRef = handleObj._componentRef;
+            else {
+                this.fileManagerService.setUserId('');
+            }
+        });
+        // GLOBAL ENTITY CHANGE HANDLER: When entity changes, close all tabs and navigate to home
+        // This ensures all components are destroyed and data is refreshed for the new entity
+        // No need to inject this service in any component - it works globally
+        let previousEntityId = null;
+        effect(() => {
+            const currentEntity = this.activeEntitySignal();
+            const currentEntityId = currentEntity?._id || null;
+            // Mark handler as initialized after first run (to skip initial load from localStorage)
+            if (!this.entityChangeHandlerInitialized) {
+                previousEntityId = currentEntityId;
+                this.entityChangeHandlerInitialized = true;
+                console.log('🏢 [AppStateService] Entity change handler initialized with initial entity:', currentEntityId);
+                return; // Skip on initial load
+            }
+            // Only trigger if entity actually changed (not on initial load)
+            if (previousEntityId !== null && currentEntityId !== previousEntityId && currentEntityId !== null) {
+                console.log('🏢 [AppStateService] Entity changed - notifying registered handlers', {
+                    previousEntityId,
+                    newEntityId: currentEntityId,
+                    newEntityName: currentEntity?.syen_name
+                });
+                // Notify all registered entity change callbacks (e.g., close tabs, refresh components)
+                this.entityChangeCallbacks.forEach(callback => {
+                    try {
+                        callback(currentEntity);
                     }
-                    if (componentRef) {
-                        console.log(`🗑️ Destroying component instance from handle object for route: ${pathKey}`);
-                        componentRef.destroy();
+                    catch (error) {
+                        console.error('Error in entity change callback:', error);
                     }
-                    // Also try to clear view container if it exists
-                    if (handleObj.viewContainerRef && typeof handleObj.viewContainerRef.clear === 'function') {
-                        console.log(`🗑️ Clearing view container from handle object for route: ${pathKey}`);
-                        handleObj.viewContainerRef.clear();
+                });
+            }
+            else if (previousEntityId !== null && currentEntityId === null) {
+                // Entity was cleared - also notify callbacks
+                console.log('🏢 [AppStateService] Entity cleared - notifying registered handlers');
+                this.entityChangeCallbacks.forEach(callback => {
+                    try {
+                        callback(null);
                     }
-                    // Try to destroy any nested components
-                    if (handleObj.components && Array.isArray(handleObj.components)) {
-                        handleObj.components.forEach((comp, index) => {
-                            if (comp && typeof comp.destroy === 'function') {
-                                console.log(`🗑️ Destroying nested component ${index} for route: ${pathKey}`);
-                                comp.destroy();
-                            }
-                        });
+                    catch (error) {
+                        console.error('Error in entity change callback:', error);
                     }
-                }
-            }
-            catch (error) {
-                console.warn(`⚠️ Error destroying route handle for ${pathKey}:`, error);
+                });
             }
-            // Remove from stored routes - this ensures shouldAttach will return false for this route
-            delete this.storedRoutes[pathKey];
-            console.log(`✅ Cleared stored route: ${pathKey} (removed from storedRoutes map)`);
-        }
-        else {
-            console.log(`ℹ️ No stored route found for: ${pathKey}`);
-        }
-    }
-    // Clears all stored routes (useful for cleanup)
-    clearAllStoredRoutes() {
-        Object.keys(this.storedRoutes).forEach(pathKey => {
-            this.clearStoredRoute(pathKey);
+            // Update previous entity ID for next comparison
+            previousEntityId = currentEntityId;
         });
+        // Listen for localStorage changes from other tabs/windows
+        this.setupStorageListener();
     }
-    // Gets the count of stored routes (useful for debugging)
-    getStoredRoutesCount() {
-        return Object.keys(this.storedRoutes).length;
+    /**
+     * Set the current user
+     */
+    setUser(user) {
+        this.currentUserSignal.set(user);
+        // Note: File manager user ID is automatically updated via effect() in constructor
     }
-}
-
-/**
- * Creates the default state for a new tab.
- */
-const createDefaultComponentState = () => ({
-    sideDrawer: { isOpen: false, activeComponent: null, componentState: {} },
-    footer: { someData: '' },
-    console: { history: [] },
-});
-class TabStateService {
-    // Holds the state for all open tabs, keyed by tab ID.
-    _tabsState = new BehaviorSubject(new Map());
-    // Holds the ID of the currently active tab.
-    _activeTabId = new BehaviorSubject(null);
-    /** An observable of all open tabs. */
-    tabs$ = this._tabsState.pipe(map(tabsMap => Array.from(tabsMap.values())));
-    /** An observable of the currently active tab's ID. */
-    activeTabId$ = this._activeTabId.asObservable().pipe(distinctUntilChanged());
-    /** An observable of the state of the currently active tab. */
-    activeTabState$ = this.activeTabId$.pipe(map(activeId => (activeId ? this._tabsState.getValue().get(activeId) ?? null : null)), 
-    // Use a deep-ish comparison to prevent emissions when only the object reference changes
-    distinctUntilChanged((prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)));
-    /** An observable of just the component-specific state for the active tab. */
-    activeComponentState$ = this.activeTabState$.pipe(map(activeTab => activeTab?.componentState ?? null));
     /**
-     * Adds a new tab to the state.
-     * @param title The title for the new tab.
-     * @param id An optional unique ID. If not provided, one will be generated.
-     * @returns The ID of the newly created tab.
+     * Update user data (partial update)
      */
-    addTab(title, id) {
-        const newTabId = id || `tab_${Date.now()}_${Math.random()}`;
-        const newTab = {
-            id: newTabId,
-            title,
-            componentState: createDefaultComponentState(),
-        };
-        const currentTabs = this._tabsState.getValue();
-        const newTabs = new Map(currentTabs).set(newTabId, newTab);
-        this._tabsState.next(newTabs);
-        this.setActiveTab(newTabId);
-        return newTabId;
+    updateUser(updates) {
+        const currentUser = this.currentUserSignal();
+        if (currentUser) {
+            this.currentUserSignal.set({ ...currentUser, ...updates });
+        }
     }
     /**
-     * Removes a tab from the state.
-     * @param tabIdToRemove The ID of the tab to remove.
+     * Clear user data
      */
-    removeTab(tabIdToRemove) {
-        const currentTabs = this._tabsState.getValue();
-        if (!currentTabs.has(tabIdToRemove)) {
-            return;
-        }
-        const newTabs = new Map(currentTabs);
-        newTabs.delete(tabIdToRemove);
-        this._tabsState.next(newTabs);
+    clearUser() {
+        this.currentUserSignal.set(null);
     }
-    constructor() {
-        // You can initialize with default tabs if needed
-        // For example:
-        // this.addTab('Welcome Tab');
+    /**
+     * Get current user value (non-reactive)
+     */
+    getUserValue() {
+        return this.currentUserSignal();
     }
     /**
-     * Sets the currently active tab.
-     * @param tabId The unique identifier of the tab to activate.
+     * Set the active module
      */
-    setActiveTab(tabId) {
-        if (this._activeTabId.getValue() !== tabId) {
-            this._activeTabId.next(tabId);
-        }
+    setActiveModule(module) {
+        this.activeModuleSignal.set(module);
     }
     /**
-     * Updates the state for the currently active tab.
-     * This performs a deep merge to avoid overwriting nested state.
-     * @param partialState The partial state to update for the active tab.
+     * Get active module value (non-reactive)
      */
-    updateActiveTabState(partialState) {
-        const activeId = this._activeTabId.getValue();
-        if (!activeId) {
-            console.warn('Cannot update state, no active tab.');
-            return;
-        }
-        const tabs = this._tabsState.getValue();
-        const activeTabState = tabs.get(activeId);
-        if (activeTabState) {
-            // Use lodash merge for a deep merge
-            const updatedState = merge({}, activeTabState, { componentState: partialState });
-            const newTabsState = new Map(tabs);
-            newTabsState.set(activeId, updatedState);
-            this._tabsState.next(newTabsState);
-        }
+    getActiveModuleValue() {
+        return this.activeModuleSignal();
     }
     /**
-     * Gets an observable for a specific tab's state.
-     * @param tabId The ID of the tab to observe.
+     * Set the active entity
      */
-    getTabState(tabId) {
-        return this._tabsState.pipe(map(tabs => tabs.get(tabId)));
+    setActiveEntity(entity) {
+        this.activeEntitySignal.set(entity);
     }
     /**
-     * Determines the ID of the next tab to activate when a tab is closed.
-     * @param idToRemove The ID of the tab being removed.
-     * @returns The ID of the next tab to activate, or null if no tabs are left.
+     * Get active entity value (non-reactive)
      */
-    getNextActiveTabId(idToRemove) {
-        const tabsMap = this._tabsState.getValue();
-        if (tabsMap.size <= 1) {
-            return null;
-        }
-        const tabIds = Array.from(tabsMap.keys());
-        const removedIndex = tabIds.indexOf(idToRemove);
-        // If it's the last tab in the list, activate the one before it. Otherwise, activate the next one.
-        const nextIndex = removedIndex === tabIds.length - 1 ? removedIndex - 1 : removedIndex + 1;
-        return tabIds[nextIndex];
+    getActiveEntityValue() {
+        return this.activeEntitySignal();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: TabStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: TabStateService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: TabStateService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [] });
-
-class CideLytRequestService {
-    requestVisible = false;
-    // Modern Angular v20+ pattern: Use Signals instead of BehaviorSubject
-    tabsSignal = signal([], ...(ngDevMode ? [{ debugName: "tabsSignal" }] : []));
-    activeTabIdSignal = signal(null, ...(ngDevMode ? [{ debugName: "activeTabIdSignal" }] : []));
-    // Computed signals for derived state and public readonly access
-    tabs = computed(() => this.tabsSignal(), ...(ngDevMode ? [{ debugName: "tabs" }] : []));
-    activeTabId = computed(() => this.activeTabIdSignal(), ...(ngDevMode ? [{ debugName: "activeTabId" }] : []));
-    activeTab = computed(() => this.tabsSignal().find(tab => tab.active), ...(ngDevMode ? [{ debugName: "activeTab" }] : []));
-    // Use inject() for all dependencies
-    router = inject(Router);
-    routeReuseStrategy = inject(RouteReuseStrategy);
-    tabStateService = inject(TabStateService);
-    sidedrawerService = inject(CideLytSidedrawerService);
-    sharedService = inject(CideLytSharedService);
-    floatingContainerService = inject(CideEleFloatingContainerService);
-    constructor() {
-        // Initialize router
-        this.router = inject(Router);
-        this.router.routeReuseStrategy = new CustomRouteReuseStrategy();
-        // Register tab management callback with shared service to avoid circular dependency
-        this.sharedService.registerTabManagement(this.handleRouteBasedTabManagement.bind(this));
-        // Register request visibility callback
-        this.sharedService.registerRequestVisibility(this.handleRequestVisibility.bind(this));
+    /**
+     * Register a callback to be called when entity changes
+     * This allows other services to react to entity changes without creating circular dependencies
+     * @param callback Function to call when entity changes, receives the new entity (or null if cleared)
+     */
+    registerEntityChangeHandler(callback) {
+        this.entityChangeCallbacks.push(callback);
+        console.log('📝 [AppStateService] Registered entity change handler, total handlers:', this.entityChangeCallbacks.length);
     }
     /**
-     * Handle request visibility changes from shared service
+     * Unregister an entity change callback
+     * @param callback The callback function to remove
      */
-    handleRequestVisibility(show) {
-        if (show) {
-            this.showRequest();
-        }
-        else {
-            this.hideRequest();
+    unregisterEntityChangeHandler(callback) {
+        const index = this.entityChangeCallbacks.indexOf(callback);
+        if (index > -1) {
+            this.entityChangeCallbacks.splice(index, 1);
+            console.log('📝 [AppStateService] Unregistered entity change handler, remaining handlers:', this.entityChangeCallbacks.length);
         }
     }
     /**
-     * Handle sidebar sync when tab becomes active
+     * Manually refresh state from localStorage
+     * Call this method when you need to sync with external localStorage changes
      */
-    handleSidebarSync(tabInfo) {
-        // The sidebar sync will be handled automatically by the shared service
-        // when page data is loaded, so we don't need additional logic here
-        console.log('🔗 REQUEST SERVICE: Tab activated, sidebar sync handled by shared service:', tabInfo.title);
+    refreshFromLocalStorage() {
+        this.loadFromLocalStorage();
+        // Note: File manager user ID is automatically updated via effect() when user signal changes
     }
     /**
-     * Handle route-based tab management - called by shared service
-     * This method checks for existing tabs and creates/activates as needed
+     * Check if localStorage is available (browser environment)
      */
-    handleRouteBasedTabManagement(currentRoutePath, queryParams, layout, pageData, pageCode) {
-        console.log('handleRouteBasedTabManagement', currentRoutePath, queryParams, layout, pageData, pageCode);
-        const currentTabs = this.tabsSignal();
-        const tabAlreadyExists = currentTabs.find((t) => {
-            const tRoutePath = t.route.startsWith('/') ? t.route : '/' + t.route;
-            const tParamsMatch = JSON.stringify(t.params || {}) === JSON.stringify(queryParams || {});
-            return tRoutePath === currentRoutePath && tParamsMatch;
-        });
-        console.log('tabAlreadyExists', tabAlreadyExists);
-        if (!tabAlreadyExists) {
-            const title = pageData.data?.page?.sypg_title || pageCode.toString() || 'Untitled Tab';
-            console.log(`🆕 Adding new tab: ${title}`);
-            this.addTab(title, currentRoutePath, queryParams, layout);
-        }
-        else if (tabAlreadyExists && !tabAlreadyExists.active) {
-            console.log(`🔄 Activating existing tab: ${tabAlreadyExists.title}`);
-            this.activateTab(tabAlreadyExists.id);
-        }
-        else if (tabAlreadyExists && tabAlreadyExists.active) {
-            console.log(`🔄 Activating existing tab: ${tabAlreadyExists.title}`);
-            this.activateTab(tabAlreadyExists.id);
-        }
-    }
-    addTab(title, route, params, layout) {
-        console.log('addTab', title, route, params, layout);
-        const id = this.generateId();
-        const currentTabs = this.tabsSignal();
-        console.log('currentTabs', currentTabs, route);
-        // Tab reuse disabled - always create new tab
-        // Removed existing tab check to prevent tab reuse
-        // Create new tab
-        const newTab = {
-            id,
-            title,
-            route,
-            params,
-            active: true,
-            layout,
-            sytm_page_id_sypg: '',
-            themeId: ''
-        };
-        // Deactivate all other tabs
-        currentTabs.forEach((tab) => tab.active = false);
-        console.log('currentTabs after deactivate', currentTabs, 'activateTab', id);
-        // Add new tab
-        this.tabsSignal.set([...currentTabs, newTab]);
-        this.activeTabIdSignal.set(id);
-        // Sync with TabStateService
-        this.tabStateService.addTab(title, id);
-        // Request visibility is now controlled by layout configuration in setPageData
-        // No need to automatically show request wrapper here
-        // Navigate to the new route
-        if (params) {
-            this.router.navigate([route], { queryParams: params });
+    isLocalStorageAvailable() {
+        try {
+            return typeof window !== 'undefined' && typeof localStorage !== 'undefined';
         }
-        else {
-            this.router.navigate([route]);
+        catch {
+            return false;
         }
-        return id;
     }
-    activateTab(tabId) {
-        console.log('🔍 REQUEST SERVICE: Activating tab:', tabId);
-        const tabs = this.tabsSignal();
-        const tabToActivate = tabs.find(tab => tab.id === tabId);
-        if (!tabToActivate) {
-            console.warn('⚠️ Tab not found:', tabId);
+    /**
+     * Save state to localStorage
+     */
+    saveToLocalStorage(data) {
+        if (!this.isLocalStorageAvailable()) {
             return;
         }
-        // Before navigating, ensure the route is fresh by clearing any cached state
-        // This prevents old component data from persisting when reopening a tab
-        if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
-            let pathKey = tabToActivate.route.startsWith('/') ? tabToActivate.route.substring(1) : tabToActivate.route;
-            if (tabToActivate.params && Object.keys(tabToActivate.params).length > 0) {
-                const queryParamsString = Object.keys(tabToActivate.params)
-                    .sort()
-                    .map(key => `${key}=${tabToActivate.params[key]}`)
-                    .join('&');
-                pathKey += '?' + queryParamsString;
-            }
-            // Clear any cached route to ensure fresh component state
-            this.routeReuseStrategy.clearStoredRoute(pathKey);
-            console.log(`🔄 REQUEST SERVICE: Cleared cached route ${pathKey} before activating tab`);
+        try {
+            if (data.user !== undefined) {
+                if (data.user) {
+                    localStorage.setItem('cide_auth_user', JSON.stringify(data.user));
+                }
+                else {
+                    localStorage.removeItem('cide_auth_user');
+                }
+            }
+            if (data.activeModule !== undefined) {
+                if (data.activeModule) {
+                    localStorage.setItem('cide_active_module', JSON.stringify(data.activeModule));
+                }
+                else {
+                    localStorage.removeItem('cide_active_module');
+                }
+            }
+            if (data.activeEntity !== undefined) {
+                if (data.activeEntity) {
+                    localStorage.setItem('cide_active_entity', JSON.stringify(data.activeEntity));
+                }
+                else {
+                    localStorage.removeItem('cide_active_entity');
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error saving to localStorage:', error);
         }
-        // Update tabs: deactivate all, then activate the target
-        const updatedTabs = tabs.map(tab => ({
-            ...tab,
-            active: tab.id === tabId
-        }));
-        this.tabsSignal.set(updatedTabs);
-        this.activeTabIdSignal.set(tabId);
-        console.log('✅ REQUEST SERVICE: Tab activated:', tabToActivate.title);
-        // Navigate to the tab's route
-        this.router.navigate([tabToActivate.route], {
-            queryParams: tabToActivate.params || {},
-            replaceUrl: false
-        });
-        // Trigger sidebar sync for the activated tab by calling shared service
-        // The shared service will handle the sidebar sync when the route loads
-        console.log('🔗 REQUEST SERVICE: Sidebar sync will be handled by route change');
     }
-    closeTab(id) {
-        const currentTabs = this.tabsSignal();
-        const tabIndex = currentTabs.findIndex((tab) => tab.id === id);
-        if (tabIndex === -1)
+    /**
+     * Load state from localStorage
+     */
+    loadFromLocalStorage() {
+        if (!this.isLocalStorageAvailable()) {
             return;
-        const tabToClose = currentTabs[tabIndex];
-        const wasActive = tabToClose.active;
-        // Sync with TabStateService by removing the tab state
-        this.tabStateService.removeTab(id);
-        // Clear stored route from strategy and ensure proper component cleanup
-        if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
-            // Generate pathKey in the same format as CustomRouteReuseStrategy.getPathKey()
-            // Remove leading slash to match the format used by getPathKey
-            let pathKey = tabToClose.route.startsWith('/') ? tabToClose.route.substring(1) : tabToClose.route;
-            // Only add query params if the route is marked for reuse (matching getPathKey logic)
-            // But we'll try to clear with both formats to be safe
-            if (tabToClose.params && Object.keys(tabToClose.params).length > 0) {
-                const queryParamsString = Object.keys(tabToClose.params)
-                    .sort()
-                    .map(key => `${key}=${tabToClose.params[key]}`)
-                    .join('&');
-                pathKey += '?' + queryParamsString;
+        }
+        try {
+            const userData = localStorage.getItem('cide_auth_user');
+            if (userData) {
+                const user = JSON.parse(userData);
+                this.currentUserSignal.set(user);
             }
-            // Clear the stored route and destroy the component instance
-            this.routeReuseStrategy.clearStoredRoute(pathKey);
-            // Also try clearing without query params in case the route wasn't marked for reuse
-            // This ensures we catch all possible pathKey variations
-            const pathKeyWithoutParams = tabToClose.route.startsWith('/') ? tabToClose.route.substring(1) : tabToClose.route;
-            if (pathKeyWithoutParams !== pathKey) {
-                this.routeReuseStrategy.clearStoredRoute(pathKeyWithoutParams);
+            const moduleData = localStorage.getItem('cide_active_module');
+            if (moduleData) {
+                const module = JSON.parse(moduleData);
+                this.activeModuleSignal.set(module);
             }
-            // Force a route refresh to ensure clean component state
-            // This prevents old data from persisting when the same route is reopened
-            console.log(`🧹 REQUEST SERVICE: Cleared stored route for ${pathKey} and destroyed component instance`);
-            // If this was the active tab, navigate away to ensure component is removed from DOM
-            if (wasActive) {
-                // The navigation to the new active tab will happen below, which will properly clear the router outlet
-                // But we also want to ensure the component is removed immediately
-                console.log(`🧹 REQUEST SERVICE: Active tab closed, component will be removed on navigation`);
+            const entityData = localStorage.getItem('cide_active_entity');
+            if (entityData) {
+                const entity = JSON.parse(entityData);
+                this.activeEntitySignal.set(entity);
             }
         }
-        // Remove the tab from this service's list
-        const newTabs = currentTabs.filter((tab) => tab.id !== id);
-        // If we're closing the active tab, activate the next available tab
-        if (wasActive && newTabs.length > 0) {
-            const newActiveIndex = Math.max(0, Math.min(tabIndex, newTabs.length - 1));
-            const newActiveTab = newTabs[newActiveIndex];
-            // Update sidedrawer for the new active tab
-            this.sidedrawerService.updateDrawerItems(newActiveTab.layout);
-            newTabs[newActiveIndex].active = true;
-            this.activeTabIdSignal.set(newActiveTab.id);
-            this.tabStateService.setActiveTab(newActiveTab.id);
-            // Navigate to the new active tab's route
-            if (newActiveTab.params) {
-                this.router.navigate([newActiveTab.route], { queryParams: newActiveTab.params });
-            }
-            else {
-                this.router.navigate([newActiveTab.route]);
+        catch (error) {
+            console.error('Error loading from localStorage:', error);
+            // Clear corrupted data
+            if (this.isLocalStorageAvailable()) {
+                localStorage.removeItem('cide_auth_user');
+                localStorage.removeItem('cide_active_module');
+                localStorage.removeItem('cide_active_entity');
             }
         }
-        else if (newTabs.length === 0) {
-            this.activeTabIdSignal.set(null);
-            this.tabStateService.setActiveTab(null);
-            // Clear sidedrawer as no tabs are open
-            this.sidedrawerService.updateDrawerItems(undefined);
-            // Redirect to home screen when all tabs are closed
-            this.router.navigate(['/control-panel']);
-        }
-        this.tabsSignal.set(newTabs);
-        // Request wrapper visibility is now controlled by layout configuration
-        // The wrapper will be hidden/shown based on sytm_layout_request.status in setPageData
     }
     /**
-     * Close all tabs and navigate to home
-     * This is used when entity changes to ensure all components are destroyed and refreshed
+     * Setup storage event listener to handle external localStorage changes
      */
-    closeAllTabs() {
-        console.log('🧹 REQUEST SERVICE: Closing all tabs due to entity change');
-        const currentTabs = this.tabsSignal();
-        // Close all floating containers first
-        this.floatingContainerService.hideAll();
-        console.log('🧹 REQUEST SERVICE: Closed all floating containers');
-        // Clear all tabs from TabStateService
-        currentTabs.forEach(tab => {
-            this.tabStateService.removeTab(tab.id);
-            // Clear stored routes from route reuse strategy
-            if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
-                let pathKey = tab.route.startsWith('/') ? tab.route.substring(1) : tab.route;
-                if (tab.params && Object.keys(tab.params).length > 0) {
-                    const queryParamsString = Object.keys(tab.params)
-                        .sort()
-                        .map(key => `${key}=${tab.params[key]}`)
-                        .join('&');
-                    pathKey += '?' + queryParamsString;
+    setupStorageListener() {
+        if (!this.isLocalStorageAvailable()) {
+            return;
+        }
+        // Listen for storage events (triggered when localStorage is modified from other tabs/windows)
+        window.addEventListener('storage', (event) => {
+            if (!event.key)
+                return;
+            try {
+                // Handle user data changes
+                if (event.key === 'cide_auth_user') {
+                    if (event.newValue) {
+                        const user = JSON.parse(event.newValue);
+                        this.currentUserSignal.set(user);
+                    }
+                    else {
+                        this.currentUserSignal.set(null);
+                    }
                 }
-                this.routeReuseStrategy.clearStoredRoute(pathKey);
-                // Also clear without query params
-                const pathKeyWithoutParams = tab.route.startsWith('/') ? tab.route.substring(1) : tab.route;
-                if (pathKeyWithoutParams !== pathKey) {
-                    this.routeReuseStrategy.clearStoredRoute(pathKeyWithoutParams);
+                // Handle active module changes
+                if (event.key === 'cide_active_module') {
+                    if (event.newValue) {
+                        const module = JSON.parse(event.newValue);
+                        this.activeModuleSignal.set(module);
+                    }
+                    else {
+                        this.activeModuleSignal.set(null);
+                    }
+                }
+                // Handle active entity changes
+                if (event.key === 'cide_active_entity') {
+                    if (event.newValue) {
+                        const entity = JSON.parse(event.newValue);
+                        this.activeEntitySignal.set(entity);
+                    }
+                    else {
+                        this.activeEntitySignal.set(null);
+                    }
                 }
             }
+            catch (error) {
+                console.error('Error parsing localStorage update:', error);
+            }
         });
-        // Clear all tabs
-        this.tabsSignal.set([]);
-        this.activeTabIdSignal.set(null);
-        this.tabStateService.setActiveTab(null);
-        // Clear sidedrawer
-        this.sidedrawerService.updateDrawerItems(undefined);
-        // Navigate to home
-        this.router.navigate(['/control-panel']);
-        console.log('✅ REQUEST SERVICE: All tabs and floating containers closed, navigated to home');
-    }
-    // Hide Request
-    hideRequest() {
-        console.log('🚫 REQUEST SERVICE - Hiding request wrapper');
-        this.requestVisible = false;
-        document.querySelector(`#cide-lyt-request-wrapper`)?.classList.add('cide-lyt-request-wrapper-hide');
-        document.querySelector(`body`)?.classList.remove('cide-lyt-request-exist');
     }
-    // Show Request
-    showRequest() {
-        console.log('✅ REQUEST SERVICE - Showing request wrapper');
-        this.requestVisible = true;
-        document.querySelector(`#cide-lyt-request-wrapper`)?.classList.remove('cide-lyt-request-wrapper-hide');
-        document.querySelector(`body`)?.classList.add('cide-lyt-request-exist');
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AppStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AppStateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AppStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+class AppStateHelperService {
+    appStateService = inject(AppStateService);
+    sidebarService = inject(CideLytSidebarService);
+    // Computed signals for derived state
+    currentUser = this.appStateService.currentUser;
+    isAuthenticated = this.appStateService.isAuthenticated;
+    userInfo = this.appStateService.userInfo;
+    activeModule = this.appStateService.activeModule;
+    activeModuleInfo = this.appStateService.activeModuleInfo;
+    activeEntity = this.appStateService.activeEntity;
+    /**
+     * Get current user value (non-reactive)
+     */
+    getCurrentUser() {
+        return this.appStateService.getUserValue();
     }
-    generateId() {
-        return 'tab-' + Math.random().toString(36).substr(2, 9);
+    /**
+     * Set user data
+     */
+    setUser(user) {
+        this.appStateService.setUser(user);
     }
-    updateTabScrollPosition(tabId, scrollTop, scrollLeft) {
-        const currentTabs = this.tabsSignal();
-        const tabIndex = currentTabs.findIndex((t) => t.id === tabId);
-        if (tabIndex !== -1) {
-            const tabToUpdate = currentTabs[tabIndex];
-            tabToUpdate.scrollTop = scrollTop;
-            tabToUpdate.scrollLeft = scrollLeft;
-            // Create a new array reference to trigger change detection
-            this.tabsSignal.set([...currentTabs]);
-        }
+    /**
+     * Update user data (partial update)
+     */
+    updateUser(updates) {
+        this.appStateService.updateUser(updates);
     }
     /**
-     * Force refresh a route by clearing its cached state
-     * This is useful when you want to ensure a clean component state
-     * @param route The route path to refresh
-     * @param params Optional query parameters
+     * Clear user data
      */
-    forceRefreshRoute(route, params) {
-        if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
-            let pathKey = route.startsWith('/') ? route.substring(1) : route;
-            if (params && Object.keys(params).length > 0) {
-                const queryParamsString = Object.keys(params)
-                    .sort()
-                    .map(key => `${key}=${params[key]}`)
-                    .join('&');
-                pathKey += '?' + queryParamsString;
-            }
-            // Clear the stored route to force a fresh component instance
-            this.routeReuseStrategy.clearStoredRoute(pathKey);
-            console.log(`🔄 REQUEST SERVICE: Force refreshed route ${pathKey}`);
-        }
+    clearUser() {
+        this.appStateService.clearUser();
     }
     /**
-     * Get information about cached routes (useful for debugging)
+     * Check if user is authenticated
      */
-    getCachedRoutesInfo() {
-        if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
-            const count = this.routeReuseStrategy.getStoredRoutesCount();
-            return { count, routes: [] }; // Could be enhanced to return actual route paths
-        }
-        return { count: 0, routes: [] };
+    isUserAuthenticated() {
+        return this.appStateService.isAuthenticated();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CideLytRequestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CideLytRequestService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CideLytRequestService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [] });
-
-class AppStateService {
-    // Inject services
-    fileManagerService = inject(CideEleFileManagerService);
-    router = inject(Router);
-    requestService = inject(CideLytRequestService);
-    // Private signal for current user
-    currentUserSignal = signal(null, ...(ngDevMode ? [{ debugName: "currentUserSignal" }] : []));
-    // Private signal for active module
-    activeModuleSignal = signal(null, ...(ngDevMode ? [{ debugName: "activeModuleSignal" }] : []));
-    // Private signal for active entity
-    activeEntitySignal = signal(null, ...(ngDevMode ? [{ debugName: "activeEntitySignal" }] : []));
-    // Track if entity change handler is initialized (to prevent triggering on initial load)
-    entityChangeHandlerInitialized = false;
-    // Public computed signal for current user, for other services to get the user value
-    currentUser = computed(() => this.currentUserSignal(), ...(ngDevMode ? [{ debugName: "currentUser" }] : []));
-    // Public computed signal for active module
-    activeModule = computed(() => this.activeModuleSignal(), ...(ngDevMode ? [{ debugName: "activeModule" }] : []));
-    // Public computed signal for active entity
-    activeEntity = computed(() => this.activeEntitySignal(), ...(ngDevMode ? [{ debugName: "activeEntity" }] : []));
-    // Computed signals for derived state
-    isAuthenticated = computed(() => !!this.currentUserSignal(), ...(ngDevMode ? [{ debugName: "isAuthenticated" }] : []));
-    userInfo = computed(() => {
-        const user = this.currentUserSignal();
-        if (!user)
-            return null;
-        return {
-            id: user._id,
-            name: user.user_fullname || `${user.user_firstname} ${user.user_lastname}`,
-            email: user.user_emailid,
-            role: "" // user.user_id_role
-        };
-    }, ...(ngDevMode ? [{ debugName: "userInfo" }] : []));
-    // Computed signal for active module info
-    activeModuleInfo = computed(() => {
-        const module = this.activeModuleSignal();
-        if (!module)
-            return null;
-        return {
-            id: module._id,
-            title: module.syme_title,
-            icon: module.syme_icon,
-            path: module.syme_path,
-            type: module.syme_type
-        };
-    }, ...(ngDevMode ? [{ debugName: "activeModuleInfo" }] : []));
-    constructor() {
-        // Initialize file manager base URL on app startup
-        this.fileManagerService.setBaseUrl(cidePath.join([hostManagerRoutesUrl.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.fileManager]));
-        this.fileManagerService.setObjectIdEndpoint(cidePath.join([hostManagerRoutesUrl.cideSuiteHost, commonRoutesUrl?.module, commonRoutesUrl?.generateObjectId]));
-        // Load initial state from localStorage
-        this.loadFromLocalStorage();
-        // Save to localStorage whenever state changes
-        effect(() => {
-            const currentUser = this.currentUserSignal();
-            const activeModule = this.activeModuleSignal();
-            const activeEntity = this.activeEntitySignal();
-            this.saveToLocalStorage({
-                user: currentUser,
-                activeModule: activeModule,
-                activeEntity: activeEntity
-            });
-        });
-        // Automatically update file manager user ID whenever user changes
-        effect(() => {
-            const currentUser = this.currentUserSignal();
-            console.log('🔍 [AppStateService] User changed, updating file manager user ID:', currentUser);
-            if (currentUser?._id) {
-                this.fileManagerService.setUserId(currentUser._id);
-            }
-            else {
-                this.fileManagerService.setUserId('');
-            }
-        });
-        // GLOBAL ENTITY CHANGE HANDLER: When entity changes, close all tabs and navigate to home
-        // This ensures all components are destroyed and data is refreshed for the new entity
-        // No need to inject this service in any component - it works globally
-        let previousEntityId = null;
-        effect(() => {
-            const currentEntity = this.activeEntitySignal();
-            const currentEntityId = currentEntity?._id || null;
-            // Mark handler as initialized after first run (to skip initial load from localStorage)
-            if (!this.entityChangeHandlerInitialized) {
-                previousEntityId = currentEntityId;
-                this.entityChangeHandlerInitialized = true;
-                console.log('🏢 [AppStateService] Entity change handler initialized with initial entity:', currentEntityId);
-                return; // Skip on initial load
-            }
-            // Only trigger if entity actually changed (not on initial load)
-            if (previousEntityId !== null && currentEntityId !== previousEntityId && currentEntityId !== null) {
-                console.log('🏢 [AppStateService] Entity changed - closing all tabs and navigating to home', {
-                    previousEntityId,
-                    newEntityId: currentEntityId,
-                    newEntityName: currentEntity?.syen_name
-                });
-                // Close all tabs - this will destroy all components and navigate to home
-                this.requestService.closeAllTabs();
-            }
-            else if (previousEntityId !== null && currentEntityId === null) {
-                // Entity was cleared - also close tabs
-                console.log('🏢 [AppStateService] Entity cleared - closing all tabs');
-                this.requestService.closeAllTabs();
-            }
-            // Update previous entity ID for next comparison
-            previousEntityId = currentEntityId;
-        });
-        // Listen for localStorage changes from other tabs/windows
-        this.setupStorageListener();
+    /**
+     * Get user info object
+     */
+    getUserInfo() {
+        return this.appStateService.userInfo();
     }
     /**
-     * Set the current user
+     * Get user ID
      */
-    setUser(user) {
-        this.currentUserSignal.set(user);
-        // Note: File manager user ID is automatically updated via effect() in constructor
+    getUserId() {
+        const user = this.getCurrentUser();
+        return user?._id || null;
     }
     /**
-     * Update user data (partial update)
+     * Get user name
      */
-    updateUser(updates) {
-        const currentUser = this.currentUserSignal();
-        if (currentUser) {
-            this.currentUserSignal.set({ ...currentUser, ...updates });
-        }
+    getUserName() {
+        const userInfo = this.getUserInfo();
+        return userInfo?.name || null;
     }
     /**
-     * Clear user data
+     * Get user email
      */
-    clearUser() {
-        this.currentUserSignal.set(null);
+    getUserEmail() {
+        const userInfo = this.getUserInfo();
+        return userInfo?.email || null;
     }
     /**
-     * Get current user value (non-reactive)
+     * Get user username
      */
-    getUserValue() {
-        return this.currentUserSignal();
+    getUserUsername() {
+        const user = this.getCurrentUser();
+        return user?.user_username || null;
     }
     /**
-     * Set the active module
+     * Get user full name
      */
-    setActiveModule(module) {
-        this.activeModuleSignal.set(module);
+    getUserFullName() {
+        const user = this.getCurrentUser();
+        return user?.user_fullname || null;
     }
     /**
-     * Get active module value (non-reactive)
+     * Get user first name
      */
-    getActiveModuleValue() {
-        return this.activeModuleSignal();
+    getUserFirstName() {
+        const user = this.getCurrentUser();
+        return user?.user_firstname || null;
     }
     /**
-     * Set the active entity
+     * Get user last name
      */
-    setActiveEntity(entity) {
-        this.activeEntitySignal.set(entity);
+    getUserLastName() {
+        const user = this.getCurrentUser();
+        return user?.user_lastname || null;
     }
     /**
-     * Get active entity value (non-reactive)
+     * Get user mobile number
      */
-    getActiveEntityValue() {
-        return this.activeEntitySignal();
+    getUserMobile() {
+        const user = this.getCurrentUser();
+        return user?.user_mobileno || null;
     }
     /**
-     * Manually refresh state from localStorage
-     * Call this method when you need to sync with external localStorage changes
+     * Set the active module
      */
-    refreshFromLocalStorage() {
-        this.loadFromLocalStorage();
-        // Note: File manager user ID is automatically updated via effect() when user signal changes
+    setActiveModule(module) {
+        this.appStateService.setActiveModule(module);
     }
     /**
-     * Check if localStorage is available (browser environment)
+     * Get active module value (non-reactive)
      */
-    isLocalStorageAvailable() {
-        try {
-            return typeof window !== 'undefined' && typeof localStorage !== 'undefined';
-        }
-        catch {
-            return false;
-        }
+    getActiveModule() {
+        return this.appStateService.getActiveModuleValue();
     }
     /**
-     * Save state to localStorage
-     */
-    saveToLocalStorage(data) {
-        if (!this.isLocalStorageAvailable()) {
-            return;
-        }
-        try {
-            if (data.user !== undefined) {
-                if (data.user) {
-                    localStorage.setItem('cide_auth_user', JSON.stringify(data.user));
-                }
-                else {
-                    localStorage.removeItem('cide_auth_user');
-                }
-            }
-            if (data.activeModule !== undefined) {
-                if (data.activeModule) {
-                    localStorage.setItem('cide_active_module', JSON.stringify(data.activeModule));
-                }
-                else {
-                    localStorage.removeItem('cide_active_module');
-                }
-            }
-            if (data.activeEntity !== undefined) {
-                if (data.activeEntity) {
-                    localStorage.setItem('cide_active_entity', JSON.stringify(data.activeEntity));
-                }
-                else {
-                    localStorage.removeItem('cide_active_entity');
-                }
-            }
-        }
-        catch (error) {
-            console.error('Error saving to localStorage:', error);
-        }
-    }
-    /**
-     * Load state from localStorage
-     */
-    loadFromLocalStorage() {
-        if (!this.isLocalStorageAvailable()) {
-            return;
-        }
-        try {
-            const userData = localStorage.getItem('cide_auth_user');
-            if (userData) {
-                const user = JSON.parse(userData);
-                this.currentUserSignal.set(user);
-            }
-            const moduleData = localStorage.getItem('cide_active_module');
-            if (moduleData) {
-                const module = JSON.parse(moduleData);
-                this.activeModuleSignal.set(module);
-            }
-            const entityData = localStorage.getItem('cide_active_entity');
-            if (entityData) {
-                const entity = JSON.parse(entityData);
-                this.activeEntitySignal.set(entity);
-            }
-        }
-        catch (error) {
-            console.error('Error loading from localStorage:', error);
-            // Clear corrupted data
-            if (this.isLocalStorageAvailable()) {
-                localStorage.removeItem('cide_auth_user');
-                localStorage.removeItem('cide_active_module');
-                localStorage.removeItem('cide_active_entity');
-            }
-        }
-    }
-    /**
-     * Setup storage event listener to handle external localStorage changes
-     */
-    setupStorageListener() {
-        if (!this.isLocalStorageAvailable()) {
-            return;
-        }
-        // Listen for storage events (triggered when localStorage is modified from other tabs/windows)
-        window.addEventListener('storage', (event) => {
-            if (!event.key)
-                return;
-            try {
-                // Handle user data changes
-                if (event.key === 'cide_auth_user') {
-                    if (event.newValue) {
-                        const user = JSON.parse(event.newValue);
-                        this.currentUserSignal.set(user);
-                    }
-                    else {
-                        this.currentUserSignal.set(null);
-                    }
-                }
-                // Handle active module changes
-                if (event.key === 'cide_active_module') {
-                    if (event.newValue) {
-                        const module = JSON.parse(event.newValue);
-                        this.activeModuleSignal.set(module);
-                    }
-                    else {
-                        this.activeModuleSignal.set(null);
-                    }
-                }
-                // Handle active entity changes
-                if (event.key === 'cide_active_entity') {
-                    if (event.newValue) {
-                        const entity = JSON.parse(event.newValue);
-                        this.activeEntitySignal.set(entity);
-                    }
-                    else {
-                        this.activeEntitySignal.set(null);
-                    }
-                }
-            }
-            catch (error) {
-                console.error('Error parsing localStorage update:', error);
-            }
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AppStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AppStateService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AppStateService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [] });
-
-class AppStateHelperService {
-    appStateService = inject(AppStateService);
-    sidebarService = inject(CideLytSidebarService);
-    // Computed signals for derived state
-    currentUser = this.appStateService.currentUser;
-    isAuthenticated = this.appStateService.isAuthenticated;
-    userInfo = this.appStateService.userInfo;
-    activeModule = this.appStateService.activeModule;
-    activeModuleInfo = this.appStateService.activeModuleInfo;
-    activeEntity = this.appStateService.activeEntity;
-    /**
-     * Get current user value (non-reactive)
-     */
-    getCurrentUser() {
-        return this.appStateService.getUserValue();
-    }
-    /**
-     * Set user data
-     */
-    setUser(user) {
-        this.appStateService.setUser(user);
-    }
-    /**
-     * Update user data (partial update)
-     */
-    updateUser(updates) {
-        this.appStateService.updateUser(updates);
-    }
-    /**
-     * Clear user data
-     */
-    clearUser() {
-        this.appStateService.clearUser();
-    }
-    /**
-     * Check if user is authenticated
-     */
-    isUserAuthenticated() {
-        return this.appStateService.isAuthenticated();
-    }
-    /**
-     * Get user info object
-     */
-    getUserInfo() {
-        return this.appStateService.userInfo();
-    }
-    /**
-     * Get user ID
-     */
-    getUserId() {
-        const user = this.getCurrentUser();
-        return user?._id || null;
-    }
-    /**
-     * Get user name
-     */
-    getUserName() {
-        const userInfo = this.getUserInfo();
-        return userInfo?.name || null;
-    }
-    /**
-     * Get user email
-     */
-    getUserEmail() {
-        const userInfo = this.getUserInfo();
-        return userInfo?.email || null;
-    }
-    /**
-     * Get user username
-     */
-    getUserUsername() {
-        const user = this.getCurrentUser();
-        return user?.user_username || null;
-    }
-    /**
-     * Get user full name
-     */
-    getUserFullName() {
-        const user = this.getCurrentUser();
-        return user?.user_fullname || null;
-    }
-    /**
-     * Get user first name
-     */
-    getUserFirstName() {
-        const user = this.getCurrentUser();
-        return user?.user_firstname || null;
-    }
-    /**
-     * Get user last name
-     */
-    getUserLastName() {
-        const user = this.getCurrentUser();
-        return user?.user_lastname || null;
-    }
-    /**
-     * Get user mobile number
-     */
-    getUserMobile() {
-        const user = this.getCurrentUser();
-        return user?.user_mobileno || null;
-    }
-    /**
-     * Set the active module
-     */
-    setActiveModule(module) {
-        this.appStateService.setActiveModule(module);
-    }
-    /**
-     * Get active module value (non-reactive)
-     */
-    getActiveModule() {
-        return this.appStateService.getActiveModuleValue();
-    }
-    /**
-     * Get active module info
+     * Get active module info
      */
     getActiveModuleInfo() {
         return this.appStateService.activeModuleInfo();
@@ -1924,7 +1353,7 @@ class CideLytFloatingEntitySelectionService {
         }
         try {
             // Use relative import to avoid circular dependency
-            const module = await import('./cloud-ide-layout-floating-entity-selection.component-CGoIPT5y.mjs');
+            const module = await import('./cloud-ide-layout-floating-entity-selection.component-DteJtUqk.mjs');
             if (module.CideLytFloatingEntitySelectionComponent) {
                 this.containerService.registerComponent('entity-selection-header', module.CideLytFloatingEntitySelectionComponent);
                 console.log('✅ Entity selection component registered successfully');
@@ -4830,6 +4259,618 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImpor
                 args: ['document:click', ['$event']]
             }] } });
 
+/**
+ * A custom route reuse strategy that allows storing and retrieving routes
+ * to persist component state, especially for tabbed navigation.
+ */
+class CustomRouteReuseStrategy {
+    storedRoutes = {};
+    // Generates a unique key for a route.
+    // For routes marked with 'reuseTab', this key includes sorted query parameters
+    // to ensure distinct states for tabs differing by query params.
+    getPathKey(route) {
+        let path = route.pathFromRoot
+            .map(r => r.url.map(segment => segment.path).join('/'))
+            .filter(p => p.length > 0)
+            .join('/');
+        // If the route is marked for tab reuse and has query parameters,
+        // append them to the key in a sorted, consistent manner.
+        if (route.data && route.data['reuseTab'] && route.queryParamMap.keys.length > 0) {
+            const queryParams = route.queryParamMap.keys
+                .sort() // Ensure consistent order of query parameters
+                .map(key => `${key}=${route.queryParamMap.get(key)}`)
+                .join('&');
+            path += '?' + queryParams;
+        }
+        return path;
+    }
+    // Determines if this route (and its subtree) should be detached to be reused later.
+    shouldDetach(route) {
+        return !!(route.data && route.data['reuseTab']);
+    }
+    // Stores the detached route.
+    store(route, handle) {
+        const pathKey = this.getPathKey(route);
+        if (handle && route.data && route.data['reuseTab'] && pathKey) {
+            this.storedRoutes[pathKey] = handle;
+        }
+    }
+    // Determines if this route (and its subtree) should be reattached.
+    shouldAttach(route) {
+        const pathKey = this.getPathKey(route);
+        return !!pathKey && !!this.storedRoutes[pathKey];
+    }
+    // Retrieves the previously stored route.
+    retrieve(route) {
+        const pathKey = this.getPathKey(route);
+        if (!pathKey || !this.storedRoutes[pathKey]) {
+            return null;
+        }
+        const handle = this.storedRoutes[pathKey];
+        // Verify the handle is still valid (not destroyed)
+        // If the component was destroyed, remove it from stored routes
+        if (handle && typeof handle === 'object') {
+            const handleAny = handle;
+            // Check if ComponentRef is destroyed
+            if (handleAny.destroyed === true || (handleAny.hostView && handleAny.hostView.destroyed)) {
+                console.log(`⚠️ Stored route handle for ${pathKey} is already destroyed, removing from cache`);
+                delete this.storedRoutes[pathKey];
+                return null;
+            }
+        }
+        return handle;
+    }
+    // Determines if a route should be reused.
+    shouldReuseRoute(future, curr) {
+        return future.routeConfig === curr.routeConfig;
+    }
+    // Clears a stored route, typically when a tab is closed.
+    // This method now properly destroys the component instance to prevent memory leaks
+    // and ensure old data doesn't persist when reopening the same route.
+    clearStoredRoute(pathKey) {
+        const handle = this.storedRoutes[pathKey];
+        if (handle) {
+            // Properly destroy the component instance to prevent memory leaks
+            // and ensure clean state when the route is reopened
+            try {
+                // In Angular, DetachedRouteHandle is typically a ComponentRef
+                // We need to destroy it to remove the component from DOM and clean up resources
+                // Method 1: Check if handle is a ComponentRef directly
+                if (handle && typeof handle.destroy === 'function') {
+                    const componentRef = handle;
+                    // Verify it has hostView (ComponentRef signature)
+                    if (componentRef.hostView || componentRef.location) {
+                        console.log(`🗑️ Destroying component instance (ComponentRef) for route: ${pathKey}`);
+                        componentRef.destroy();
+                    }
+                }
+                // Method 2: Check if handle is a ViewContainerRef
+                if (handle && typeof handle.clear === 'function' && typeof handle.length === 'number') {
+                    const viewContainerRef = handle;
+                    console.log(`🗑️ Clearing view container for route: ${pathKey}`);
+                    viewContainerRef.clear();
+                }
+                // Method 3: Check if handle is an object with nested ComponentRef
+                if (handle && typeof handle === 'object' && !(handle instanceof ComponentRef) && !(handle instanceof ViewContainerRef)) {
+                    const handleObj = handle;
+                    // Try to find and destroy ComponentRef from various possible properties
+                    let componentRef = null;
+                    // Check common property names
+                    if (handleObj.componentRef && typeof handleObj.componentRef.destroy === 'function') {
+                        componentRef = handleObj.componentRef;
+                    }
+                    else if (handleObj.component && typeof handleObj.component.destroy === 'function') {
+                        componentRef = handleObj.component;
+                    }
+                    else if (handleObj.context && typeof handleObj.context.destroy === 'function') {
+                        componentRef = handleObj.context;
+                    }
+                    else if (handleObj._componentRef && typeof handleObj._componentRef.destroy === 'function') {
+                        componentRef = handleObj._componentRef;
+                    }
+                    if (componentRef) {
+                        console.log(`🗑️ Destroying component instance from handle object for route: ${pathKey}`);
+                        componentRef.destroy();
+                    }
+                    // Also try to clear view container if it exists
+                    if (handleObj.viewContainerRef && typeof handleObj.viewContainerRef.clear === 'function') {
+                        console.log(`🗑️ Clearing view container from handle object for route: ${pathKey}`);
+                        handleObj.viewContainerRef.clear();
+                    }
+                    // Try to destroy any nested components
+                    if (handleObj.components && Array.isArray(handleObj.components)) {
+                        handleObj.components.forEach((comp, index) => {
+                            if (comp && typeof comp.destroy === 'function') {
+                                console.log(`🗑️ Destroying nested component ${index} for route: ${pathKey}`);
+                                comp.destroy();
+                            }
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️ Error destroying route handle for ${pathKey}:`, error);
+            }
+            // Remove from stored routes - this ensures shouldAttach will return false for this route
+            delete this.storedRoutes[pathKey];
+            console.log(`✅ Cleared stored route: ${pathKey} (removed from storedRoutes map)`);
+        }
+        else {
+            console.log(`ℹ️ No stored route found for: ${pathKey}`);
+        }
+    }
+    // Clears all stored routes (useful for cleanup)
+    clearAllStoredRoutes() {
+        Object.keys(this.storedRoutes).forEach(pathKey => {
+            this.clearStoredRoute(pathKey);
+        });
+    }
+    // Gets the count of stored routes (useful for debugging)
+    getStoredRoutesCount() {
+        return Object.keys(this.storedRoutes).length;
+    }
+}
+
+/**
+ * Creates the default state for a new tab.
+ */
+const createDefaultComponentState = () => ({
+    sideDrawer: { isOpen: false, activeComponent: null, componentState: {} },
+    footer: { someData: '' },
+    console: { history: [] },
+});
+class TabStateService {
+    // Holds the state for all open tabs, keyed by tab ID.
+    _tabsState = new BehaviorSubject(new Map());
+    // Holds the ID of the currently active tab.
+    _activeTabId = new BehaviorSubject(null);
+    /** An observable of all open tabs. */
+    tabs$ = this._tabsState.pipe(map(tabsMap => Array.from(tabsMap.values())));
+    /** An observable of the currently active tab's ID. */
+    activeTabId$ = this._activeTabId.asObservable().pipe(distinctUntilChanged());
+    /** An observable of the state of the currently active tab. */
+    activeTabState$ = this.activeTabId$.pipe(map(activeId => (activeId ? this._tabsState.getValue().get(activeId) ?? null : null)), 
+    // Use a deep-ish comparison to prevent emissions when only the object reference changes
+    distinctUntilChanged((prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)));
+    /** An observable of just the component-specific state for the active tab. */
+    activeComponentState$ = this.activeTabState$.pipe(map(activeTab => activeTab?.componentState ?? null));
+    /**
+     * Adds a new tab to the state.
+     * @param title The title for the new tab.
+     * @param id An optional unique ID. If not provided, one will be generated.
+     * @returns The ID of the newly created tab.
+     */
+    addTab(title, id) {
+        const newTabId = id || `tab_${Date.now()}_${Math.random()}`;
+        const newTab = {
+            id: newTabId,
+            title,
+            componentState: createDefaultComponentState(),
+        };
+        const currentTabs = this._tabsState.getValue();
+        const newTabs = new Map(currentTabs).set(newTabId, newTab);
+        this._tabsState.next(newTabs);
+        this.setActiveTab(newTabId);
+        return newTabId;
+    }
+    /**
+     * Removes a tab from the state.
+     * @param tabIdToRemove The ID of the tab to remove.
+     */
+    removeTab(tabIdToRemove) {
+        const currentTabs = this._tabsState.getValue();
+        if (!currentTabs.has(tabIdToRemove)) {
+            return;
+        }
+        const newTabs = new Map(currentTabs);
+        newTabs.delete(tabIdToRemove);
+        this._tabsState.next(newTabs);
+    }
+    constructor() {
+        // You can initialize with default tabs if needed
+        // For example:
+        // this.addTab('Welcome Tab');
+    }
+    /**
+     * Sets the currently active tab.
+     * @param tabId The unique identifier of the tab to activate.
+     */
+    setActiveTab(tabId) {
+        if (this._activeTabId.getValue() !== tabId) {
+            this._activeTabId.next(tabId);
+        }
+    }
+    /**
+     * Updates the state for the currently active tab.
+     * This performs a deep merge to avoid overwriting nested state.
+     * @param partialState The partial state to update for the active tab.
+     */
+    updateActiveTabState(partialState) {
+        const activeId = this._activeTabId.getValue();
+        if (!activeId) {
+            console.warn('Cannot update state, no active tab.');
+            return;
+        }
+        const tabs = this._tabsState.getValue();
+        const activeTabState = tabs.get(activeId);
+        if (activeTabState) {
+            // Use lodash merge for a deep merge
+            const updatedState = merge({}, activeTabState, { componentState: partialState });
+            const newTabsState = new Map(tabs);
+            newTabsState.set(activeId, updatedState);
+            this._tabsState.next(newTabsState);
+        }
+    }
+    /**
+     * Gets an observable for a specific tab's state.
+     * @param tabId The ID of the tab to observe.
+     */
+    getTabState(tabId) {
+        return this._tabsState.pipe(map(tabs => tabs.get(tabId)));
+    }
+    /**
+     * Determines the ID of the next tab to activate when a tab is closed.
+     * @param idToRemove The ID of the tab being removed.
+     * @returns The ID of the next tab to activate, or null if no tabs are left.
+     */
+    getNextActiveTabId(idToRemove) {
+        const tabsMap = this._tabsState.getValue();
+        if (tabsMap.size <= 1) {
+            return null;
+        }
+        const tabIds = Array.from(tabsMap.keys());
+        const removedIndex = tabIds.indexOf(idToRemove);
+        // If it's the last tab in the list, activate the one before it. Otherwise, activate the next one.
+        const nextIndex = removedIndex === tabIds.length - 1 ? removedIndex - 1 : removedIndex + 1;
+        return tabIds[nextIndex];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: TabStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: TabStateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: TabStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class CideLytRequestService {
+    requestVisible = false;
+    // Modern Angular v20+ pattern: Use Signals instead of BehaviorSubject
+    tabsSignal = signal([], ...(ngDevMode ? [{ debugName: "tabsSignal" }] : []));
+    activeTabIdSignal = signal(null, ...(ngDevMode ? [{ debugName: "activeTabIdSignal" }] : []));
+    // Computed signals for derived state and public readonly access
+    tabs = computed(() => this.tabsSignal(), ...(ngDevMode ? [{ debugName: "tabs" }] : []));
+    activeTabId = computed(() => this.activeTabIdSignal(), ...(ngDevMode ? [{ debugName: "activeTabId" }] : []));
+    activeTab = computed(() => this.tabsSignal().find(tab => tab.active), ...(ngDevMode ? [{ debugName: "activeTab" }] : []));
+    // Use inject() for all dependencies
+    router = inject(Router);
+    routeReuseStrategy = inject(RouteReuseStrategy);
+    tabStateService = inject(TabStateService);
+    sidedrawerService = inject(CideLytSidedrawerService);
+    sharedService = inject(CideLytSharedService);
+    floatingContainerService = inject(CideEleFloatingContainerService);
+    appStateService = inject(AppStateService);
+    constructor() {
+        // Initialize router
+        this.router = inject(Router);
+        this.router.routeReuseStrategy = new CustomRouteReuseStrategy();
+        // Register tab management callback with shared service to avoid circular dependency
+        this.sharedService.registerTabManagement(this.handleRouteBasedTabManagement.bind(this));
+        // Register request visibility callback
+        this.sharedService.registerRequestVisibility(this.handleRequestVisibility.bind(this));
+        // Register entity change handler with AppStateService to close tabs when entity changes
+        // This is safe because AppStateService no longer imports CideLytRequestService
+        this.appStateService.registerEntityChangeHandler((entity) => {
+            console.log('🏢 [RequestService] Entity changed, closing all tabs:', entity?._id);
+            this.closeAllTabs();
+        });
+    }
+    /**
+     * Handle request visibility changes from shared service
+     */
+    handleRequestVisibility(show) {
+        if (show) {
+            this.showRequest();
+        }
+        else {
+            this.hideRequest();
+        }
+    }
+    /**
+     * Handle sidebar sync when tab becomes active
+     */
+    handleSidebarSync(tabInfo) {
+        // The sidebar sync will be handled automatically by the shared service
+        // when page data is loaded, so we don't need additional logic here
+        console.log('🔗 REQUEST SERVICE: Tab activated, sidebar sync handled by shared service:', tabInfo.title);
+    }
+    /**
+     * Handle route-based tab management - called by shared service
+     * This method checks for existing tabs and creates/activates as needed
+     */
+    handleRouteBasedTabManagement(currentRoutePath, queryParams, layout, pageData, pageCode) {
+        console.log('handleRouteBasedTabManagement', currentRoutePath, queryParams, layout, pageData, pageCode);
+        const currentTabs = this.tabsSignal();
+        const tabAlreadyExists = currentTabs.find((t) => {
+            const tRoutePath = t.route.startsWith('/') ? t.route : '/' + t.route;
+            const tParamsMatch = JSON.stringify(t.params || {}) === JSON.stringify(queryParams || {});
+            return tRoutePath === currentRoutePath && tParamsMatch;
+        });
+        console.log('tabAlreadyExists', tabAlreadyExists);
+        if (!tabAlreadyExists) {
+            const title = pageData.data?.page?.sypg_title || pageCode.toString() || 'Untitled Tab';
+            console.log(`🆕 Adding new tab: ${title}`);
+            this.addTab(title, currentRoutePath, queryParams, layout);
+        }
+        else if (tabAlreadyExists && !tabAlreadyExists.active) {
+            console.log(`🔄 Activating existing tab: ${tabAlreadyExists.title}`);
+            this.activateTab(tabAlreadyExists.id);
+        }
+        else if (tabAlreadyExists && tabAlreadyExists.active) {
+            console.log(`🔄 Activating existing tab: ${tabAlreadyExists.title}`);
+            this.activateTab(tabAlreadyExists.id);
+        }
+    }
+    addTab(title, route, params, layout) {
+        console.log('addTab', title, route, params, layout);
+        const id = this.generateId();
+        const currentTabs = this.tabsSignal();
+        console.log('currentTabs', currentTabs, route);
+        // Tab reuse disabled - always create new tab
+        // Removed existing tab check to prevent tab reuse
+        // Create new tab
+        const newTab = {
+            id,
+            title,
+            route,
+            params,
+            active: true,
+            layout,
+            sytm_page_id_sypg: '',
+            themeId: ''
+        };
+        // Deactivate all other tabs
+        currentTabs.forEach((tab) => tab.active = false);
+        console.log('currentTabs after deactivate', currentTabs, 'activateTab', id);
+        // Add new tab
+        this.tabsSignal.set([...currentTabs, newTab]);
+        this.activeTabIdSignal.set(id);
+        // Sync with TabStateService
+        this.tabStateService.addTab(title, id);
+        // Request visibility is now controlled by layout configuration in setPageData
+        // No need to automatically show request wrapper here
+        // Navigate to the new route
+        if (params) {
+            this.router.navigate([route], { queryParams: params });
+        }
+        else {
+            this.router.navigate([route]);
+        }
+        return id;
+    }
+    activateTab(tabId) {
+        console.log('🔍 REQUEST SERVICE: Activating tab:', tabId);
+        const tabs = this.tabsSignal();
+        const tabToActivate = tabs.find(tab => tab.id === tabId);
+        if (!tabToActivate) {
+            console.warn('⚠️ Tab not found:', tabId);
+            return;
+        }
+        // Before navigating, ensure the route is fresh by clearing any cached state
+        // This prevents old component data from persisting when reopening a tab
+        if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
+            let pathKey = tabToActivate.route.startsWith('/') ? tabToActivate.route.substring(1) : tabToActivate.route;
+            if (tabToActivate.params && Object.keys(tabToActivate.params).length > 0) {
+                const queryParamsString = Object.keys(tabToActivate.params)
+                    .sort()
+                    .map(key => `${key}=${tabToActivate.params[key]}`)
+                    .join('&');
+                pathKey += '?' + queryParamsString;
+            }
+            // Clear any cached route to ensure fresh component state
+            this.routeReuseStrategy.clearStoredRoute(pathKey);
+            console.log(`🔄 REQUEST SERVICE: Cleared cached route ${pathKey} before activating tab`);
+        }
+        // Update tabs: deactivate all, then activate the target
+        const updatedTabs = tabs.map(tab => ({
+            ...tab,
+            active: tab.id === tabId
+        }));
+        this.tabsSignal.set(updatedTabs);
+        this.activeTabIdSignal.set(tabId);
+        console.log('✅ REQUEST SERVICE: Tab activated:', tabToActivate.title);
+        // Navigate to the tab's route
+        this.router.navigate([tabToActivate.route], {
+            queryParams: tabToActivate.params || {},
+            replaceUrl: false
+        });
+        // Trigger sidebar sync for the activated tab by calling shared service
+        // The shared service will handle the sidebar sync when the route loads
+        console.log('🔗 REQUEST SERVICE: Sidebar sync will be handled by route change');
+    }
+    closeTab(id) {
+        const currentTabs = this.tabsSignal();
+        const tabIndex = currentTabs.findIndex((tab) => tab.id === id);
+        if (tabIndex === -1)
+            return;
+        const tabToClose = currentTabs[tabIndex];
+        const wasActive = tabToClose.active;
+        // Sync with TabStateService by removing the tab state
+        this.tabStateService.removeTab(id);
+        // Clear stored route from strategy and ensure proper component cleanup
+        if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
+            // Generate pathKey in the same format as CustomRouteReuseStrategy.getPathKey()
+            // Remove leading slash to match the format used by getPathKey
+            let pathKey = tabToClose.route.startsWith('/') ? tabToClose.route.substring(1) : tabToClose.route;
+            // Only add query params if the route is marked for reuse (matching getPathKey logic)
+            // But we'll try to clear with both formats to be safe
+            if (tabToClose.params && Object.keys(tabToClose.params).length > 0) {
+                const queryParamsString = Object.keys(tabToClose.params)
+                    .sort()
+                    .map(key => `${key}=${tabToClose.params[key]}`)
+                    .join('&');
+                pathKey += '?' + queryParamsString;
+            }
+            // Clear the stored route and destroy the component instance
+            this.routeReuseStrategy.clearStoredRoute(pathKey);
+            // Also try clearing without query params in case the route wasn't marked for reuse
+            // This ensures we catch all possible pathKey variations
+            const pathKeyWithoutParams = tabToClose.route.startsWith('/') ? tabToClose.route.substring(1) : tabToClose.route;
+            if (pathKeyWithoutParams !== pathKey) {
+                this.routeReuseStrategy.clearStoredRoute(pathKeyWithoutParams);
+            }
+            // Force a route refresh to ensure clean component state
+            // This prevents old data from persisting when the same route is reopened
+            console.log(`🧹 REQUEST SERVICE: Cleared stored route for ${pathKey} and destroyed component instance`);
+            // If this was the active tab, navigate away to ensure component is removed from DOM
+            if (wasActive) {
+                // The navigation to the new active tab will happen below, which will properly clear the router outlet
+                // But we also want to ensure the component is removed immediately
+                console.log(`🧹 REQUEST SERVICE: Active tab closed, component will be removed on navigation`);
+            }
+        }
+        // Remove the tab from this service's list
+        const newTabs = currentTabs.filter((tab) => tab.id !== id);
+        // If we're closing the active tab, activate the next available tab
+        if (wasActive && newTabs.length > 0) {
+            const newActiveIndex = Math.max(0, Math.min(tabIndex, newTabs.length - 1));
+            const newActiveTab = newTabs[newActiveIndex];
+            // Update sidedrawer for the new active tab
+            this.sidedrawerService.updateDrawerItems(newActiveTab.layout);
+            newTabs[newActiveIndex].active = true;
+            this.activeTabIdSignal.set(newActiveTab.id);
+            this.tabStateService.setActiveTab(newActiveTab.id);
+            // Navigate to the new active tab's route
+            if (newActiveTab.params) {
+                this.router.navigate([newActiveTab.route], { queryParams: newActiveTab.params });
+            }
+            else {
+                this.router.navigate([newActiveTab.route]);
+            }
+        }
+        else if (newTabs.length === 0) {
+            this.activeTabIdSignal.set(null);
+            this.tabStateService.setActiveTab(null);
+            // Clear sidedrawer as no tabs are open
+            this.sidedrawerService.updateDrawerItems(undefined);
+            // Redirect to home screen when all tabs are closed
+            this.router.navigate(['/control-panel']);
+        }
+        this.tabsSignal.set(newTabs);
+        // Request wrapper visibility is now controlled by layout configuration
+        // The wrapper will be hidden/shown based on sytm_layout_request.status in setPageData
+    }
+    /**
+     * Close all tabs and navigate to home
+     * This is used when entity changes to ensure all components are destroyed and refreshed
+     */
+    closeAllTabs() {
+        console.log('🧹 REQUEST SERVICE: Closing all tabs due to entity change');
+        const currentTabs = this.tabsSignal();
+        // Close all floating containers first
+        this.floatingContainerService.hideAll();
+        console.log('🧹 REQUEST SERVICE: Closed all floating containers');
+        // Clear all tabs from TabStateService
+        currentTabs.forEach(tab => {
+            this.tabStateService.removeTab(tab.id);
+            // Clear stored routes from route reuse strategy
+            if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
+                let pathKey = tab.route.startsWith('/') ? tab.route.substring(1) : tab.route;
+                if (tab.params && Object.keys(tab.params).length > 0) {
+                    const queryParamsString = Object.keys(tab.params)
+                        .sort()
+                        .map(key => `${key}=${tab.params[key]}`)
+                        .join('&');
+                    pathKey += '?' + queryParamsString;
+                }
+                this.routeReuseStrategy.clearStoredRoute(pathKey);
+                // Also clear without query params
+                const pathKeyWithoutParams = tab.route.startsWith('/') ? tab.route.substring(1) : tab.route;
+                if (pathKeyWithoutParams !== pathKey) {
+                    this.routeReuseStrategy.clearStoredRoute(pathKeyWithoutParams);
+                }
+            }
+        });
+        // Clear all tabs
+        this.tabsSignal.set([]);
+        this.activeTabIdSignal.set(null);
+        this.tabStateService.setActiveTab(null);
+        // Clear sidedrawer
+        this.sidedrawerService.updateDrawerItems(undefined);
+        // Navigate to home
+        this.router.navigate(['/control-panel']);
+        console.log('✅ REQUEST SERVICE: All tabs and floating containers closed, navigated to home');
+    }
+    // Hide Request
+    hideRequest() {
+        console.log('🚫 REQUEST SERVICE - Hiding request wrapper');
+        this.requestVisible = false;
+        document.querySelector(`#cide-lyt-request-wrapper`)?.classList.add('cide-lyt-request-wrapper-hide');
+        document.querySelector(`body`)?.classList.remove('cide-lyt-request-exist');
+    }
+    // Show Request
+    showRequest() {
+        console.log('✅ REQUEST SERVICE - Showing request wrapper');
+        this.requestVisible = true;
+        document.querySelector(`#cide-lyt-request-wrapper`)?.classList.remove('cide-lyt-request-wrapper-hide');
+        document.querySelector(`body`)?.classList.add('cide-lyt-request-exist');
+    }
+    generateId() {
+        return 'tab-' + Math.random().toString(36).substr(2, 9);
+    }
+    updateTabScrollPosition(tabId, scrollTop, scrollLeft) {
+        const currentTabs = this.tabsSignal();
+        const tabIndex = currentTabs.findIndex((t) => t.id === tabId);
+        if (tabIndex !== -1) {
+            const tabToUpdate = currentTabs[tabIndex];
+            tabToUpdate.scrollTop = scrollTop;
+            tabToUpdate.scrollLeft = scrollLeft;
+            // Create a new array reference to trigger change detection
+            this.tabsSignal.set([...currentTabs]);
+        }
+    }
+    /**
+     * Force refresh a route by clearing its cached state
+     * This is useful when you want to ensure a clean component state
+     * @param route The route path to refresh
+     * @param params Optional query parameters
+     */
+    forceRefreshRoute(route, params) {
+        if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
+            let pathKey = route.startsWith('/') ? route.substring(1) : route;
+            if (params && Object.keys(params).length > 0) {
+                const queryParamsString = Object.keys(params)
+                    .sort()
+                    .map(key => `${key}=${params[key]}`)
+                    .join('&');
+                pathKey += '?' + queryParamsString;
+            }
+            // Clear the stored route to force a fresh component instance
+            this.routeReuseStrategy.clearStoredRoute(pathKey);
+            console.log(`🔄 REQUEST SERVICE: Force refreshed route ${pathKey}`);
+        }
+    }
+    /**
+     * Get information about cached routes (useful for debugging)
+     */
+    getCachedRoutesInfo() {
+        if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
+            const count = this.routeReuseStrategy.getStoredRoutesCount();
+            return { count, routes: [] }; // Could be enhanced to return actual route paths
+        }
+        return { count: 0, routes: [] };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CideLytRequestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CideLytRequestService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CideLytRequestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
 // Type guard for setState/getState
 function hasStateMethods(instance) {
     return !!instance && typeof instance.getState === 'function' && typeof instance.setState === 'function';
@@ -4913,8 +4954,8 @@ class CideLytSidedrawerWrapperComponent {
     }
     ngOnInit() {
         // Initialize the component map (You'd likely populate this from a config or service)
-        this.componentMap['drowar_notes'] = () => import('./cloud-ide-layout-sidedrawer-notes.component-DMzp8tJc.mjs').then(m => m.CideLytSidedrawerNotesComponent);
-        this.componentMap['drawer_theme'] = () => import('./cloud-ide-layout-drawer-theme.component-J2GTGGFO.mjs').then(m => m.CideLytDrawerThemeComponent);
+        this.componentMap['drowar_notes'] = () => import('./cloud-ide-layout-sidedrawer-notes.component-C2tOsEC4.mjs').then(m => m.CideLytSidedrawerNotesComponent);
+        this.componentMap['drawer_theme'] = () => import('./cloud-ide-layout-drawer-theme.component-DV0QsDsO.mjs').then(m => m.CideLytDrawerThemeComponent);
     }
     async loadComponent(configFor) {
         console.log('🔍 SIDEDRAWER - Loading component:', configFor, 'Current tab:', this.currentTabId);
@@ -6581,7 +6622,7 @@ const layoutControlPannelChildRoutes = [{
     },
     {
         path: "home",
-        loadComponent: () => import('./cloud-ide-layout-home-wrapper.component-DaonafYv.mjs').then(c => c.CideLytHomeWrapperComponent),
+        loadComponent: () => import('./cloud-ide-layout-home-wrapper.component-DjRHVU59.mjs').then(c => c.CideLytHomeWrapperComponent),
         canActivate: [authGuard],
         data: {
             sypg_page_code: "cide_lyt_home" // Used by RequestService to fetch tab properties
@@ -6589,7 +6630,7 @@ const layoutControlPannelChildRoutes = [{
     },
     {
         path: "dashboard-manager",
-        loadComponent: () => import('./cloud-ide-layout-dashboard-manager.component-C-kubr7Z.mjs').then(c => c.DashboardManagerComponent),
+        loadComponent: () => import('./cloud-ide-layout-dashboard-manager.component-C8rnVZpP.mjs').then(c => c.DashboardManagerComponent),
         canActivate: [authGuard],
         data: {
             sypg_page_code: "cide_lyt_dashboard_manager"
@@ -8156,4 +8197,4 @@ var floatingEntityRightsSharing_component = /*#__PURE__*/Object.freeze({
  */
 
 export { AppStateHelperService as A, CideLytSharedWrapperComponent as C, ENVIRONMENT_CONFIG as E, NotificationSettingsService as N, RightsService as R, CideLytSidebarService as a, CideLytRequestService as b, CideLytSidedrawerService as c, CideLytThemeService as d, AppStateService as e, CloudIdeLayoutService as f, CloudIdeLayoutComponent as g, CideLytSharedService as h, ComponentContextService as i, layoutControlPannelChildRoutes as j, CustomRouteReuseStrategy as k, layoutRoutes as l, CideLytUserStatusService as m, CacheManagerService as n, CideLytFileManagerService as o, processThemeVariable as p, CideLytFloatingEntityRightsSharingComponent as q, CideLytFloatingEntityRightsSharingService as r, setCSSVariable as s, themeFactory as t };
-//# sourceMappingURL=cloud-ide-layout-cloud-ide-layout-DJxJ2FIt.mjs.map
+//# sourceMappingURL=cloud-ide-layout-cloud-ide-layout-DdMf1j7_.mjs.map