cloud-ide-layout 1.0.182 → 1.0.184

package/fesm2022/{cloud-ide-layout-cloud-ide-layout-l6s-ph1q.mjs → cloud-ide-layout-cloud-ide-layout-BvT1pY8z.mjs}

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, signal, computed, effect, DestroyRef, Component, Injector, runInInjectionContext, ViewChild, ElementRef, HostListener, ChangeDetectionStrategy, ComponentRef, ViewContainerRef, ViewChildren, viewChild, input, InjectionToken, PLATFORM_ID, output } from '@angular/core';
+import { Injectable, inject, signal, computed, effect, DestroyRef, Component, Injector, runInInjectionContext, ViewChild, ElementRef, HostListener, ChangeDetectionStrategy, 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 { BehaviorSubject, Observable, throwError, of, interval, take as take$1, firstValueFrom } from 'rxjs';
@@ -4716,195 +4716,49 @@ class CustomRouteReuseStrategy {
         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;
+        return this.storedRoutes[pathKey];
     }
     // Determines if a route should be reused.
     shouldReuseRoute(future, curr) {
         return future.routeConfig === curr.routeConfig;
     }
-    /**
-     * Clears a stored route by path and optional parameters.
-     * This method attempts to find a matching stored route using a robust matching algorithm.
-     */
-    clearRoute(path, params) {
-        // 1. Try to construct the exact key first
-        let exactKey = path;
-        // Normalize path: remove leading slash if present
-        if (exactKey.startsWith('/')) {
-            exactKey = exactKey.substring(1);
-        }
-        // Attempt to construct key with params if they exist
-        let exactKeyWithParams = exactKey;
-        if (params && Object.keys(params).length > 0) {
-            const queryParams = Object.keys(params)
-                .sort()
-                .map(key => `${key}=${params[key]}`)
-                .join('&');
-            exactKeyWithParams += '?' + queryParams;
-        }
-        // Check strict match first
-        if (this.storedRoutes[exactKeyWithParams]) {
-            console.log(`🎯 [RouteReuseStrategy] Found exact match for clearing: ${exactKeyWithParams}`);
-            this.destroyAndRemove(exactKeyWithParams);
-            return;
-        }
-        // Check if the key exists without params (sometimes stored without them if no reuseTab data at that moment)
-        if (this.storedRoutes[exactKey]) {
-            console.log(`🎯 [RouteReuseStrategy] Found path-only match for clearing: ${exactKey}`);
-            this.destroyAndRemove(exactKey);
-            return;
-        }
-        // 2. Fuzzy Match: Iterate through all keys to find a substantial match
-        // This handles cases where params might be string vs number, or order differences not caught by simple sort
-        console.log(`🔍 [RouteReuseStrategy] No exact match for ${exactKeyWithParams}. Searching candidates...`);
-        const candidates = Object.keys(this.storedRoutes);
-        for (const startKey of candidates) {
-            // Check if the path part matches
-            const [storedPath, storedQuery] = startKey.split('?');
-            if (storedPath === exactKey || storedPath === '/' + exactKey) {
-                // Path matches. Now check params if requested
-                if (!params || Object.keys(params).length === 0) {
-                    // If we didn't ask for specific params, and we found a path match, this is likely it
-                    // BUT be careful not to delete a specific parameterized tab if we meant a generic one
-                    // For safety, if the stored route HAS params, but we didn't specify any, strictness might be needed.
-                    // For now, let's assume if path matches and we have no params, it's a match.
-                    console.log(`⚠️ [RouteReuseStrategy] Fuzzy match (Path match, input has no params): ${startKey}`);
-                    this.destroyAndRemove(startKey);
-                    return;
-                }
-                // Both have params, compare them
-                if (storedQuery) {
-                    const storedParams = new URLSearchParams(storedQuery);
-                    let allParamsMatch = true;
-                    for (const key of Object.keys(params)) {
-                        const val = params[key];
-                        const storedVal = storedParams.get(key);
-                        // Loose equality for string/number match
-                        if (storedVal != val) {
-                            allParamsMatch = false;
-                            break;
-                        }
-                    }
-                    if (allParamsMatch) {
-                        console.log(`⚠️ [RouteReuseStrategy] Fuzzy match (Params match loose equality): ${startKey}`);
-                        this.destroyAndRemove(startKey);
-                        return;
-                    }
-                }
-            }
-        }
-        console.warn(`❌ [RouteReuseStrategy] Could not find route to clear for: ${path}`, params);
-    }
-    // Private helper to destroy component and remove from map
-    destroyAndRemove(key) {
-        const handle = this.storedRoutes[key];
+    // 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: ${key}`);
+                // The handle contains the component instance and view container
+                // We need to destroy it properly to clean up resources
+                if (handle && typeof handle === 'object' && 'componentRef' in handle) {
+                    const componentRef = handle.componentRef;
+                    if (componentRef && typeof componentRef.destroy === 'function') {
                         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: ${key}`);
-                    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: ${key}`);
-                        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: ${key}`);
-                        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: ${key}`);
-                                comp.destroy();
-                            }
-                        });
+                // Also destroy the view container if it exists
+                if (handle && typeof handle === 'object' && 'viewContainerRef' in handle) {
+                    const viewContainerRef = handle.viewContainerRef;
+                    if (viewContainerRef && typeof viewContainerRef.clear === 'function') {
+                        viewContainerRef.clear();
                     }
                 }
             }
             catch (error) {
-                console.warn(`⚠️ Error destroying route handle for ${key}:`, error);
+                console.warn('Error destroying route handle:', error);
             }
-            // Remove from stored routes - this ensures shouldAttach will return false for this route
-            delete this.storedRoutes[key];
-            console.log(`✅ Cleared stored route: ${key} (removed from storedRoutes map)`);
-        }
-        else {
-            console.log(`ℹ️ No stored route found for: ${key}`);
+            // Remove from stored routes
+            delete this.storedRoutes[pathKey];
         }
     }
-    /**
-     * Legacy method for backward compatibility, redirects to new clearRoute or destroys directly if key provided
-     * @deprecated Use clearRoute instead
-     */
-    clearStoredRoute(pathKey) {
-        this.destroyAndRemove(pathKey);
-    }
     // Clears all stored routes (useful for cleanup)
-    // This method ensures all component instances are destroyed and removed from DOM
     clearAllStoredRoutes() {
-        const routeKeys = Object.keys(this.storedRoutes);
-        console.log(`🧹 [RouteReuseStrategy] Clearing ${routeKeys.length} stored route(s) to remove components from DOM`);
-        routeKeys.forEach(pathKey => {
+        Object.keys(this.storedRoutes).forEach(pathKey => {
             this.clearStoredRoute(pathKey);
         });
-        // Double-check that all routes are cleared
-        const remainingRoutes = Object.keys(this.storedRoutes).length;
-        if (remainingRoutes > 0) {
-            console.warn(`⚠️ [RouteReuseStrategy] ${remainingRoutes} route(s) still remain after clearing. Force clearing...`);
-            // Force clear any remaining routes
-            Object.keys(this.storedRoutes).forEach(pathKey => {
-                delete this.storedRoutes[pathKey];
-            });
-        }
-        console.log(`✅ [RouteReuseStrategy] All stored routes cleared. Components should be removed from DOM.`);
     }
     // Gets the count of stored routes (useful for debugging)
     getStoredRoutesCount() {
@@ -5050,8 +4904,6 @@ class CideLytRequestService {
     tabStateService = inject(TabStateService);
     sidedrawerService = inject(CideLytSidedrawerService);
     sharedService = inject(CideLytSharedService);
-    floatingContainerService = inject(CideEleFloatingContainerService);
-    appStateService = inject(AppStateService);
     constructor() {
         // Initialize router
         this.router = inject(Router);
@@ -5060,12 +4912,6 @@ class CideLytRequestService {
         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
@@ -5118,8 +4964,16 @@ class CideLytRequestService {
         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
+        // Check if a tab with the same route and params already exists
+        const existingTab = currentTabs.find((tab) => {
+            const paramsMatch = JSON.stringify(tab.params || {}) === JSON.stringify(params || {});
+            return tab.route === route && paramsMatch;
+        });
+        console.log('existingTab', existingTab);
+        if (existingTab) {
+            this.activateTab(existingTab.id);
+            return existingTab.id;
+        }
         // Create new tab
         const newTab = {
             id,
@@ -5158,10 +5012,21 @@ class CideLytRequestService {
             console.warn('⚠️ Tab not found:', tabId);
             return;
         }
-        // NOTE: Removed route clearing on activation.
-        // We want to reuse the stored component state when switching tabs.
-        // Clearing is only done when EXPLICITLY closing a tab or force refreshing.
-        console.log(`🔄 REQUEST SERVICE: Resuming tab ${tabToActivate.title}`);
+        // 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,
@@ -5189,17 +5054,20 @@ class CideLytRequestService {
         // Sync with TabStateService by removing the tab state
         this.tabStateService.removeTab(id);
         // Clear stored route from strategy and ensure proper component cleanup
-        // Clear stored route from strategy and ensure proper component cleanup
         if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
-            // Use the new robust clearRoute method
-            this.routeReuseStrategy.clearRoute(tabToClose.route, tabToClose.params);
-            console.log(`🧹 REQUEST SERVICE: Cleared stored route for closed tab ${tabToClose.title}`);
-            // 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`);
-            }
+            let pathKey = tabToClose.route.startsWith('/') ? tabToClose.route.substring(1) : tabToClose.route;
+            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);
+            // 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`);
         }
         // Remove the tab from this service's list
         const newTabs = currentTabs.filter((tab) => tab.id !== id);
@@ -5225,50 +5093,11 @@ class CideLytRequestService {
             this.tabStateService.setActiveTab(null);
             // Clear sidedrawer as no tabs are open
             this.sidedrawerService.updateDrawerItems(undefined);
-            // Redirect to home screen when all tabs are closed
-            // Use replaceUrl to prevent back navigation to closed tabs and ensure clean state
-            this.router.navigate(['/control-panel'], { replaceUrl: true });
         }
         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
-     * IMPORTANT: This method ensures all tab components are removed from DOM by:
-     * 1. Clearing all stored routes from route reuse strategy (destroys component instances)
-     * 2. Clearing all tabs from TabStateService
-     * 3. Navigating to home to clear router outlet
-     */
-    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 first
-        currentTabs.forEach(tab => {
-            this.tabStateService.removeTab(tab.id);
-        });
-        // Clear ALL stored routes from route reuse strategy
-        // This ensures all component instances are destroyed and removed from DOM
-        if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
-            console.log('🧹 REQUEST SERVICE: Clearing all stored routes to remove components from DOM');
-            this.routeReuseStrategy.clearAllStoredRoutes();
-            console.log('✅ REQUEST SERVICE: All stored routes cleared, components destroyed');
-        }
-        // Clear all tabs from signals
-        this.tabsSignal.set([]);
-        this.activeTabIdSignal.set(null);
-        this.tabStateService.setActiveTab(null);
-        // Clear sidedrawer
-        this.sidedrawerService.updateDrawerItems(undefined);
-        // Navigate to home - this ensures router outlet is cleared and any remaining components are removed
-        // Use replaceUrl to prevent back navigation to closed tabs
-        this.router.navigate(['/control-panel'], { replaceUrl: true });
-        console.log('✅ REQUEST SERVICE: All tabs and floating containers closed, navigated to home');
-    }
     // Hide Request
     hideRequest() {
         console.log('🚫 REQUEST SERVICE - Hiding request wrapper');
@@ -5305,8 +5134,17 @@ class CideLytRequestService {
      */
     forceRefreshRoute(route, params) {
         if (this.routeReuseStrategy instanceof CustomRouteReuseStrategy) {
-            this.routeReuseStrategy.clearRoute(route, params);
-            console.log(`🔄 REQUEST SERVICE: Force refreshed route ${route}`);
+            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}`);
         }
     }
     /**
@@ -5412,8 +5250,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-9ZGNNWMi.mjs').then(m => m.CideLytSidedrawerNotesComponent);
-        this.componentMap['drawer_theme'] = () => import('./cloud-ide-layout-drawer-theme.component-HsFPpuk1.mjs').then(m => m.CideLytDrawerThemeComponent);
+        this.componentMap['drowar_notes'] = () => import('./cloud-ide-layout-sidedrawer-notes.component-Cg9oFVf0.mjs').then(m => m.CideLytSidedrawerNotesComponent);
+        this.componentMap['drawer_theme'] = () => import('./cloud-ide-layout-drawer-theme.component-yixL0kiC.mjs').then(m => m.CideLytDrawerThemeComponent);
     }
     async loadComponent(configFor) {
         console.log('🔍 SIDEDRAWER - Loading component:', configFor, 'Current tab:', this.currentTabId);
@@ -7105,7 +6943,7 @@ const layoutControlPannelChildRoutes = [{
     },
     {
         path: "home",
-        loadComponent: () => import('./cloud-ide-layout-home-wrapper.component-C9F3Ph0U.mjs').then(c => c.CideLytHomeWrapperComponent),
+        loadComponent: () => import('./cloud-ide-layout-home-wrapper.component-DoPrXEV9.mjs').then(c => c.CideLytHomeWrapperComponent),
         canActivate: [authGuard],
         data: {
             sypg_page_code: "cide_lyt_home" // Used by RequestService to fetch tab properties
@@ -7113,7 +6951,7 @@ const layoutControlPannelChildRoutes = [{
     },
     {
         path: "dashboard-manager",
-        loadComponent: () => import('./cloud-ide-layout-dashboard-manager.component-BFmWPx5q.mjs').then(c => c.DashboardManagerComponent),
+        loadComponent: () => import('./cloud-ide-layout-dashboard-manager.component-DYixwEQa.mjs').then(c => c.DashboardManagerComponent),
         canActivate: [authGuard],
         data: {
             sypg_page_code: "cide_lyt_dashboard_manager"
@@ -8937,4 +8775,4 @@ var floatingEntitySelection_component = /*#__PURE__*/Object.freeze({
  */
 
 export { AppStateHelperService as A, CideLytSharedWrapperComponent as C, ENVIRONMENT_CONFIG as E, NotificationSettingsService as N, RightsService as R, CideLytSidebarService as a, CideLytSidedrawerService as b, CideLytThemeService as c, CloudIdeLayoutService as d, CloudIdeLayoutComponent as e, CideLytSharedService as f, ComponentContextService as g, layoutControlPannelChildRoutes as h, CustomRouteReuseStrategy as i, AppStateService as j, CideLytUserStatusService as k, layoutRoutes as l, CacheManagerService as m, CideLytFileManagerService as n, CideLytFloatingEntityRightsSharingComponent as o, processThemeVariable as p, CideLytFloatingEntityRightsSharingService as q, CideLytFloatingEntitySelectionComponent as r, setCSSVariable as s, themeFactory as t, CideLytFloatingEntitySelectionService as u };
-//# sourceMappingURL=cloud-ide-layout-cloud-ide-layout-l6s-ph1q.mjs.map
+//# sourceMappingURL=cloud-ide-layout-cloud-ide-layout-BvT1pY8z.mjs.map