cloud-ide-layout 1.0.178 → 1.0.180

package/fesm2022/{cloud-ide-layout-cloud-ide-layout-Dmny5YH7.mjs → cloud-ide-layout-cloud-ide-layout-W4WjBty3.mjs}

@@ -4734,11 +4734,82 @@ class CustomRouteReuseStrategy {
     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];
+    /**
+     * 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];
         if (handle) {
             // Properly destroy the component instance to prevent memory leaks
             // and ensure clean state when the route is reopened
@@ -4750,14 +4821,14 @@ class CustomRouteReuseStrategy {
                     const componentRef = handle;
                     // Verify it has hostView (ComponentRef signature)
                     if (componentRef.hostView || componentRef.location) {
-                        console.log(`🗑️ Destroying component instance (ComponentRef) for route: ${pathKey}`);
+                        console.log(`🗑️ Destroying component instance (ComponentRef) for route: ${key}`);
                         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}`);
+                    console.log(`🗑️ Clearing view container for route: ${key}`);
                     viewContainerRef.clear();
                 }
                 // Method 3: Check if handle is an object with nested ComponentRef
@@ -4779,19 +4850,19 @@ class CustomRouteReuseStrategy {
                         componentRef = handleObj._componentRef;
                     }
                     if (componentRef) {
-                        console.log(`🗑️ Destroying component instance from handle object for route: ${pathKey}`);
+                        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: ${pathKey}`);
+                        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: ${pathKey}`);
+                                console.log(`🗑️ Destroying nested component ${index} for route: ${key}`);
                                 comp.destroy();
                             }
                         });
@@ -4799,21 +4870,41 @@ class CustomRouteReuseStrategy {
                 }
             }
             catch (error) {
-                console.warn(`⚠️ Error destroying route handle for ${pathKey}:`, error);
+                console.warn(`⚠️ Error destroying route handle for ${key}:`, 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)`);
+            delete this.storedRoutes[key];
+            console.log(`✅ Cleared stored route: ${key} (removed from storedRoutes map)`);
         }
         else {
-            console.log(`ℹ️ No stored route found for: ${pathKey}`);
+            console.log(`ℹ️ No stored route found for: ${key}`);
         }
     }
+    /**
+     * 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() {
-        Object.keys(this.storedRoutes).forEach(pathKey => {
+        const routeKeys = Object.keys(this.storedRoutes);
+        console.log(`🧹 [RouteReuseStrategy] Clearing ${routeKeys.length} stored route(s) to remove components from DOM`);
+        routeKeys.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() {
@@ -5069,18 +5160,12 @@ class CideLytRequestService {
         }
         // Before navigating, ensure the route is fresh by clearing any cached state
         // This prevents old component data from persisting when reopening a tab
+        // 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`);
+            // Use the new robust clearRoute method
+            this.routeReuseStrategy.clearRoute(tabToActivate.route, tabToActivate.params);
+            console.log(`🔄 REQUEST SERVICE: Cleared cached route for ${tabToActivate.title} before activating tab`);
         }
         // Update tabs: deactivate all, then activate the target
         const updatedTabs = tabs.map(tab => ({
@@ -5109,30 +5194,11 @@ 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) {
-            // 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`);
+            // 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
@@ -5165,7 +5231,8 @@ class CideLytRequestService {
             // 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']);
+            // 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
@@ -5174,6 +5241,10 @@ class CideLytRequestService {
     /**
      * 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');
@@ -5181,35 +5252,26 @@ class CideLytRequestService {
         // Close all floating containers first
         this.floatingContainerService.hideAll();
         console.log('🧹 REQUEST SERVICE: Closed all floating containers');
-        // Clear all tabs from TabStateService
+        // Clear all tabs from TabStateService first
         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
+        // 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.router.navigate(['/control-panel']);
+        // 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
@@ -5248,17 +5310,8 @@ class CideLytRequestService {
      */
     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}`);
+            this.routeReuseStrategy.clearRoute(route, params);
+            console.log(`🔄 REQUEST SERVICE: Force refreshed route ${route}`);
         }
     }
     /**
@@ -5364,8 +5417,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-c7SI5coP.mjs').then(m => m.CideLytSidedrawerNotesComponent);
-        this.componentMap['drawer_theme'] = () => import('./cloud-ide-layout-drawer-theme.component-B08bRsuV.mjs').then(m => m.CideLytDrawerThemeComponent);
+        this.componentMap['drowar_notes'] = () => import('./cloud-ide-layout-sidedrawer-notes.component-D4zenTjI.mjs').then(m => m.CideLytSidedrawerNotesComponent);
+        this.componentMap['drawer_theme'] = () => import('./cloud-ide-layout-drawer-theme.component-DywE01AM.mjs').then(m => m.CideLytDrawerThemeComponent);
     }
     async loadComponent(configFor) {
         console.log('🔍 SIDEDRAWER - Loading component:', configFor, 'Current tab:', this.currentTabId);
@@ -7057,7 +7110,7 @@ const layoutControlPannelChildRoutes = [{
     },
     {
         path: "home",
-        loadComponent: () => import('./cloud-ide-layout-home-wrapper.component-Cmq9HGPt.mjs').then(c => c.CideLytHomeWrapperComponent),
+        loadComponent: () => import('./cloud-ide-layout-home-wrapper.component-DTKumUOV.mjs').then(c => c.CideLytHomeWrapperComponent),
         canActivate: [authGuard],
         data: {
             sypg_page_code: "cide_lyt_home" // Used by RequestService to fetch tab properties
@@ -7065,7 +7118,7 @@ const layoutControlPannelChildRoutes = [{
     },
     {
         path: "dashboard-manager",
-        loadComponent: () => import('./cloud-ide-layout-dashboard-manager.component-VUHtS7Oq.mjs').then(c => c.DashboardManagerComponent),
+        loadComponent: () => import('./cloud-ide-layout-dashboard-manager.component-BVtdt1TW.mjs').then(c => c.DashboardManagerComponent),
         canActivate: [authGuard],
         data: {
             sypg_page_code: "cide_lyt_dashboard_manager"
@@ -8889,4 +8942,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-Dmny5YH7.mjs.map
+//# sourceMappingURL=cloud-ide-layout-cloud-ide-layout-W4WjBty3.mjs.map