cloud-ide-layout 1.0.184 → 1.0.186

package/fesm2022/{cloud-ide-layout-cloud-ide-layout-BvT1pY8z.mjs → cloud-ide-layout-cloud-ide-layout-BCJjrfC0.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, 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, 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 { BehaviorSubject, Observable, throwError, of, interval, take as take$1, firstValueFrom } from 'rxjs';
@@ -4716,7 +4716,19 @@ class CustomRouteReuseStrategy {
         if (!pathKey || !this.storedRoutes[pathKey]) {
             return null;
         }
-        return this.storedRoutes[pathKey];
+        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) {
@@ -4731,34 +4743,90 @@ class CustomRouteReuseStrategy {
             // Properly destroy the component instance to prevent memory leaks
             // and ensure clean state when the route is reopened
             try {
-                // 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') {
+                // 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();
                     }
                 }
-                // 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();
+                // 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:', error);
+                console.warn(`⚠️ Error destroying route handle for ${pathKey}:`, error);
             }
-            // Remove from stored routes
+            // 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)
+    // 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() {
@@ -4904,6 +4972,8 @@ class CideLytRequestService {
     tabStateService = inject(TabStateService);
     sidedrawerService = inject(CideLytSidedrawerService);
     sharedService = inject(CideLytSharedService);
+    floatingContainerService = inject(CideEleFloatingContainerService);
+    appStateService = inject(AppStateService);
     constructor() {
         // Initialize router
         this.router = inject(Router);
@@ -4912,6 +4982,12 @@ 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
@@ -4964,16 +5040,8 @@ class CideLytRequestService {
         const id = this.generateId();
         const currentTabs = this.tabsSignal();
         console.log('currentTabs', currentTabs, route);
-        // 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;
-        }
+        // Tab reuse disabled - always create new tab
+        // Removed existing tab check to prevent tab reuse
         // Create new tab
         const newTab = {
             id,
@@ -5012,21 +5080,10 @@ class CideLytRequestService {
             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`);
-        }
+        // DO NOT clear the route when activating a tab!
+        // We want to REUSE the stored component to preserve state (form data, scroll position, etc.)
+        // Route clearing should ONLY happen when explicitly closing a tab (see closeTab method)
+        console.log(`🔄 REQUEST SERVICE: Activating tab "${tabToActivate.title}" - will reuse existing component state`);
         // Update tabs: deactivate all, then activate the target
         const updatedTabs = tabs.map(tab => ({
             ...tab,
@@ -5055,7 +5112,11 @@ class CideLytRequestService {
         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()
@@ -5065,9 +5126,21 @@ class CideLytRequestService {
             }
             // 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);
@@ -5093,11 +5166,50 @@ 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');
@@ -5250,8 +5362,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-Cg9oFVf0.mjs').then(m => m.CideLytSidedrawerNotesComponent);
-        this.componentMap['drawer_theme'] = () => import('./cloud-ide-layout-drawer-theme.component-yixL0kiC.mjs').then(m => m.CideLytDrawerThemeComponent);
+        this.componentMap['drowar_notes'] = () => import('./cloud-ide-layout-sidedrawer-notes.component-DJxIg1zW.mjs').then(m => m.CideLytSidedrawerNotesComponent);
+        this.componentMap['drawer_theme'] = () => import('./cloud-ide-layout-drawer-theme.component-BNhurhcP.mjs').then(m => m.CideLytDrawerThemeComponent);
     }
     async loadComponent(configFor) {
         console.log('🔍 SIDEDRAWER - Loading component:', configFor, 'Current tab:', this.currentTabId);
@@ -6943,7 +7055,7 @@ const layoutControlPannelChildRoutes = [{
     },
     {
         path: "home",
-        loadComponent: () => import('./cloud-ide-layout-home-wrapper.component-DoPrXEV9.mjs').then(c => c.CideLytHomeWrapperComponent),
+        loadComponent: () => import('./cloud-ide-layout-home-wrapper.component-zMo-VP1V.mjs').then(c => c.CideLytHomeWrapperComponent),
         canActivate: [authGuard],
         data: {
             sypg_page_code: "cide_lyt_home" // Used by RequestService to fetch tab properties
@@ -6951,7 +7063,7 @@ const layoutControlPannelChildRoutes = [{
     },
     {
         path: "dashboard-manager",
-        loadComponent: () => import('./cloud-ide-layout-dashboard-manager.component-DYixwEQa.mjs').then(c => c.DashboardManagerComponent),
+        loadComponent: () => import('./cloud-ide-layout-dashboard-manager.component-DjW9OfwB.mjs').then(c => c.DashboardManagerComponent),
         canActivate: [authGuard],
         data: {
             sypg_page_code: "cide_lyt_dashboard_manager"
@@ -8775,4 +8887,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-BvT1pY8z.mjs.map
+//# sourceMappingURL=cloud-ide-layout-cloud-ide-layout-BCJjrfC0.mjs.map