cloud-ide-layout 0.0.1 → 1.0.1

package/esm2022/lib/services/cache-manager/cache-manager.service.mjs

@@ -0,0 +1,112 @@
+import { Injectable, inject, computed } from '@angular/core';
+import { CideLytSharedService } from '../../layout/shared/shared.service';
+import * as i0 from "@angular/core";
+export class CacheManagerService {
+    constructor() {
+        this.sharedService = inject(CideLytSharedService);
+        // Computed cache statistics
+        this.cacheStats = computed(() => {
+            const info = this.sharedService.cacheInfo();
+            return {
+                ...info,
+                hitRatio: info.totalCached > 0 ? (info.validCached / info.totalCached) * 100 : 0,
+                memoryEstimate: this.estimateCacheMemoryUsage()
+            };
+        });
+        // Public access to cache state
+        this.isLoading = (pageCode) => this.sharedService.isLoading(pageCode);
+        this.getCachedData = (pageCode) => this.sharedService.getCachedPageData(pageCode);
+    }
+    /**
+     * Get page data with caching - this is the main method components should use
+     */
+    getPageData(pageCode, forceRefresh = false) {
+        return this.sharedService.loadAndProcessPageData({ sypg_page_code: pageCode }, { forceRefresh, setTitle: true, setSidebarContext: true, updateLayout: true });
+    }
+    /**
+     * Preload multiple pages for better performance
+     */
+    preloadPages(pageCodes) {
+        console.log(`🚀 PRELOADING: Starting preload for ${pageCodes.length} pages`);
+        this.sharedService.preloadPageData(pageCodes);
+    }
+    /**
+     * Invalidate specific page cache
+     */
+    invalidatePage(pageCode) {
+        this.sharedService.invalidateCache(pageCode);
+    }
+    /**
+     * Clear all cache
+     */
+    clearCache() {
+        this.sharedService.clearAllCache();
+    }
+    /**
+     * Get cache status for debugging
+     */
+    getCacheStatus() {
+        const cache = this.sharedService.pageDataCache();
+        const loadingStates = this.sharedService.loadingStates();
+        const allPageCodes = new Set([
+            ...Object.keys(cache),
+            ...Object.keys(loadingStates)
+        ]);
+        return Array.from(allPageCodes).map(pageCode => ({
+            pageCode,
+            cached: !!cache[pageCode],
+            expired: cache[pageCode] ? !this.isCacheValid(cache[pageCode]) : false,
+            loading: !!loadingStates[pageCode]
+        }));
+    }
+    /**
+     * Estimate memory usage of cache (rough estimate)
+     */
+    estimateCacheMemoryUsage() {
+        const cache = this.sharedService.pageDataCache();
+        const jsonString = JSON.stringify(cache);
+        const bytes = new Blob([jsonString]).size;
+        if (bytes < 1024)
+            return `${bytes} B`;
+        if (bytes < 1024 * 1024)
+            return `${(bytes / 1024).toFixed(1)} KB`;
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    }
+    /**
+     * Check if cache entry is valid
+     */
+    isCacheValid(cached) {
+        if (!cached)
+            return false;
+        return Date.now() - cached.timestamp < cached.ttl;
+    }
+    /**
+     * Export cache data for debugging or backup
+     */
+    exportCacheData() {
+        return JSON.stringify(this.sharedService.pageDataCache(), null, 2);
+    }
+    /**
+     * Get performance metrics
+     */
+    getPerformanceMetrics() {
+        const stats = this.cacheStats();
+        const loadingStates = this.sharedService.loadingStates();
+        return {
+            totalPages: stats.totalCached,
+            cachedPages: stats.validCached,
+            loadingPages: Object.keys(loadingStates).length,
+            cacheHitRatio: stats.hitRatio,
+            // averageResponseTime could be implemented with timing tracking
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CacheManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CacheManagerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CacheManagerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-manager.service.js","sourceRoot":"","sources":["../../../../../../projects/cloud-ide-layout/src/lib/services/cache-manager/cache-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject, computed } from '@angular/core';\r\nimport { CideLytSharedService } from '../../layout/shared/shared.service';\r\nimport { Observable } from 'rxjs';\r\nimport { designConfigControllerResponse } from 'cloud-ide-lms-model';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CacheManagerService {\r\n  private sharedService = inject(CideLytSharedService);\r\n\r\n  // Computed cache statistics\r\n  public readonly cacheStats = computed(() => {\r\n    const info = this.sharedService.cacheInfo();\r\n    return {\r\n      ...info,\r\n      hitRatio: info.totalCached > 0 ? (info.validCached / info.totalCached) * 100 : 0,\r\n      memoryEstimate: this.estimateCacheMemoryUsage()\r\n    };\r\n  });\r\n\r\n  // Public access to cache state\r\n  public readonly isLoading = (pageCode: string) => this.sharedService.isLoading(pageCode);\r\n  public readonly getCachedData = (pageCode: string) => this.sharedService.getCachedPageData(pageCode);\r\n\r\n  /**\r\n   * Get page data with caching - this is the main method components should use\r\n   */\r\n  getPageData(pageCode: string, forceRefresh: boolean = false): Observable<designConfigControllerResponse> {\r\n    return this.sharedService.loadAndProcessPageData(\r\n      { sypg_page_code: pageCode },\r\n      { forceRefresh, setTitle: true, setSidebarContext: true, updateLayout: true }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Preload multiple pages for better performance\r\n   */\r\n  preloadPages(pageCodes: string[]): void {\r\n    console.log(`🚀 PRELOADING: Starting preload for ${pageCodes.length} pages`);\r\n    this.sharedService.preloadPageData(pageCodes);\r\n  }\r\n\r\n  /**\r\n   * Invalidate specific page cache\r\n   */\r\n  invalidatePage(pageCode: string): void {\r\n    this.sharedService.invalidateCache(pageCode);\r\n  }\r\n\r\n  /**\r\n   * Clear all cache\r\n   */\r\n  clearCache(): void {\r\n    this.sharedService.clearAllCache();\r\n  }\r\n\r\n  /**\r\n   * Get cache status for debugging\r\n   */\r\n  getCacheStatus(): { pageCode: string; cached: boolean; expired: boolean; loading: boolean }[] {\r\n    const cache = this.sharedService.pageDataCache();\r\n    const loadingStates = this.sharedService.loadingStates();\r\n    \r\n    const allPageCodes = new Set([\r\n      ...Object.keys(cache),\r\n      ...Object.keys(loadingStates)\r\n    ]);\r\n\r\n    return Array.from(allPageCodes).map(pageCode => ({\r\n      pageCode,\r\n      cached: !!cache[pageCode],\r\n      expired: cache[pageCode] ? !this.isCacheValid(cache[pageCode]) : false,\r\n      loading: !!loadingStates[pageCode]\r\n    }));\r\n  }\r\n\r\n  /**\r\n   * Estimate memory usage of cache (rough estimate)\r\n   */\r\n  private estimateCacheMemoryUsage(): string {\r\n    const cache = this.sharedService.pageDataCache();\r\n    const jsonString = JSON.stringify(cache);\r\n    const bytes = new Blob([jsonString]).size;\r\n    \r\n    if (bytes < 1024) return `${bytes} B`;\r\n    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;\r\n    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;\r\n  }\r\n\r\n  /**\r\n   * Check if cache entry is valid\r\n   */\r\n  private isCacheValid(cached: { timestamp: number; ttl: number } | undefined): boolean {\r\n    if (!cached) return false;\r\n    return Date.now() - cached.timestamp < cached.ttl;\r\n  }\r\n\r\n  /**\r\n   * Export cache data for debugging or backup\r\n   */\r\n  exportCacheData(): string {\r\n    return JSON.stringify(this.sharedService.pageDataCache(), null, 2);\r\n  }\r\n\r\n  /**\r\n   * Get performance metrics\r\n   */\r\n  getPerformanceMetrics(): {\r\n    totalPages: number;\r\n    cachedPages: number;\r\n    loadingPages: number;\r\n    cacheHitRatio: number;\r\n    averageResponseTime?: number;\r\n  } {\r\n    const stats = this.cacheStats();\r\n    const loadingStates = this.sharedService.loadingStates();\r\n    \r\n    return {\r\n      totalPages: stats.totalCached,\r\n      cachedPages: stats.validCached,\r\n      loadingPages: Object.keys(loadingStates).length,\r\n      cacheHitRatio: stats.hitRatio,\r\n      // averageResponseTime could be implemented with timing tracking\r\n    };\r\n  }\r\n} "]}

package/esm2022/lib/services/file-manager/file-manager.service.mjs

@@ -1,15 +1,15 @@
-import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
 import { cidePath, coreRoutesUrl, hostManagerRoutesUrl } from 'cloud-ide-lms-model';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/common/http";
 export class CideLytFileManagerService {
-    constructor(http) {
-        this.http = http;
+    constructor() {
+        this.http = inject(HttpClient);
     }
     getFileDetails(body) {
         return this.http.post(cidePath.join([hostManagerRoutesUrl.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.getFileDetails]), body);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytFileManagerService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytFileManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytFileManagerService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytFileManagerService, decorators: [{
@@ -17,5 +17,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1tYW5hZ2VyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbG91ZC1pZGUtbGF5b3V0L3NyYy9saWIvc2VydmljZXMvZmlsZS1tYW5hZ2VyL2ZpbGUtbWFuYWdlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxhQUFhLEVBQUUsb0JBQW9CLEVBQStDLE1BQU0scUJBQXFCLENBQUM7OztBQUtqSSxNQUFNLE9BQU8seUJBQXlCO0lBRXBDLFlBQW9CLElBQWdCO1FBQWhCLFNBQUksR0FBSixJQUFJLENBQVk7SUFBSSxDQUFDO0lBRXpDLGNBQWMsQ0FBQyxJQUFrQjtRQUMvQixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxvQkFBb0IsQ0FBQyxhQUFhLEVBQUUsYUFBYSxFQUFFLE1BQU0sRUFBRSxhQUFhLEVBQUUsY0FBYyxDQUFDLENBQUMsRUFBRSxJQUFJLENBQThDLENBQUM7SUFDdEwsQ0FBQzs4R0FOVSx5QkFBeUI7a0hBQXpCLHlCQUF5QixjQUZ4QixNQUFNOzsyRkFFUCx5QkFBeUI7a0JBSHJDLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cENsaWVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcclxuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBjaWRlUGF0aCwgY29yZVJvdXRlc1VybCwgaG9zdE1hbmFnZXJSb3V0ZXNVcmwsIE1GaWxlTWFuYWdlciwgZmlsZU1hbmFnZXJDb250cm9sbGVyUmVzcG9uc2UgfSBmcm9tICdjbG91ZC1pZGUtbG1zLW1vZGVsJztcclxuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDaWRlTHl0RmlsZU1hbmFnZXJTZXJ2aWNlIHtcclxuXHJcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBodHRwOiBIdHRwQ2xpZW50KSB7IH1cclxuXHJcbiAgZ2V0RmlsZURldGFpbHMoYm9keTogTUZpbGVNYW5hZ2VyKTogT2JzZXJ2YWJsZTxmaWxlTWFuYWdlckNvbnRyb2xsZXJSZXNwb25zZT4ge1xyXG4gICAgcmV0dXJuIHRoaXMuaHR0cC5wb3N0KGNpZGVQYXRoLmpvaW4oW2hvc3RNYW5hZ2VyUm91dGVzVXJsLmNpZGVTdWl0ZUhvc3QsIGNvcmVSb3V0ZXNVcmw/Lm1vZHVsZSwgY29yZVJvdXRlc1VybD8uZ2V0RmlsZURldGFpbHNdKSwgYm9keSkgYXMgT2JzZXJ2YWJsZTxmaWxlTWFuYWdlckNvbnRyb2xsZXJSZXNwb25zZT47XHJcbiAgfVxyXG59XHJcbiJdfQ==
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1tYW5hZ2VyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbG91ZC1pZGUtbGF5b3V0L3NyYy9saWIvc2VydmljZXMvZmlsZS1tYW5hZ2VyL2ZpbGUtbWFuYWdlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUNsRCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQUUsUUFBUSxFQUFFLGFBQWEsRUFBRSxvQkFBb0IsRUFBK0MsTUFBTSxxQkFBcUIsQ0FBQzs7QUFLakksTUFBTSxPQUFPLHlCQUF5QjtJQUh0QztRQUlVLFNBQUksR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUM7S0FLbkM7SUFIQyxjQUFjLENBQUMsSUFBa0I7UUFDL0IsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUMsb0JBQW9CLENBQUMsYUFBYSxFQUFFLGFBQWEsRUFBRSxNQUFNLEVBQUUsYUFBYSxFQUFFLGNBQWMsQ0FBQyxDQUFDLEVBQUUsSUFBSSxDQUE4QyxDQUFDO0lBQ3RMLENBQUM7OEdBTFUseUJBQXlCO2tIQUF6Qix5QkFBeUIsY0FGeEIsTUFBTTs7MkZBRVAseUJBQXlCO2tCQUhyQyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEh0dHBDbGllbnQgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQgeyBJbmplY3RhYmxlLCBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IGNpZGVQYXRoLCBjb3JlUm91dGVzVXJsLCBob3N0TWFuYWdlclJvdXRlc1VybCwgTUZpbGVNYW5hZ2VyLCBmaWxlTWFuYWdlckNvbnRyb2xsZXJSZXNwb25zZSB9IGZyb20gJ2Nsb3VkLWlkZS1sbXMtbW9kZWwnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgQ2lkZUx5dEZpbGVNYW5hZ2VyU2VydmljZSB7XG4gIHByaXZhdGUgaHR0cCA9IGluamVjdChIdHRwQ2xpZW50KTtcblxuICBnZXRGaWxlRGV0YWlscyhib2R5OiBNRmlsZU1hbmFnZXIpOiBPYnNlcnZhYmxlPGZpbGVNYW5hZ2VyQ29udHJvbGxlclJlc3BvbnNlPiB7XG4gICAgcmV0dXJuIHRoaXMuaHR0cC5wb3N0KGNpZGVQYXRoLmpvaW4oW2hvc3RNYW5hZ2VyUm91dGVzVXJsLmNpZGVTdWl0ZUhvc3QsIGNvcmVSb3V0ZXNVcmw/Lm1vZHVsZSwgY29yZVJvdXRlc1VybD8uZ2V0RmlsZURldGFpbHNdKSwgYm9keSkgYXMgT2JzZXJ2YWJsZTxmaWxlTWFuYWdlckNvbnRyb2xsZXJSZXNwb25zZT47XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/services/tab-state.service.mjs

@@ -0,0 +1,128 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { merge } from 'lodash';
+import * as i0 from "@angular/core";
+/**
+ * Creates the default state for a new tab.
+ */
+const createDefaultComponentState = () => ({
+    sideDrawer: { isOpen: false, activeComponent: null, componentState: {} },
+    footer: { someData: '' },
+    console: { history: [] },
+});
+export class TabStateService {
+    /**
+     * 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() {
+        // Holds the state for all open tabs, keyed by tab ID.
+        this._tabsState = new BehaviorSubject(new Map());
+        // Holds the ID of the currently active tab.
+        this._activeTabId = new BehaviorSubject(null);
+        /** An observable of all open tabs. */
+        this.tabs$ = this._tabsState.pipe(map(tabsMap => Array.from(tabsMap.values())));
+        /** An observable of the currently active tab's ID. */
+        this.activeTabId$ = this._activeTabId.asObservable().pipe(distinctUntilChanged());
+        /** An observable of the state of the currently active tab. */
+        this.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. */
+        this.activeComponentState$ = this.activeTabState$.pipe(map(activeTab => activeTab?.componentState ?? null));
+        // 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 { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: TabStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: TabStateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: TabStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-state.service.js","sourceRoot":"","sources":["../../../../../projects/cloud-ide-layout/src/lib/services/tab-state.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { BehaviorSubject, Observable } from 'rxjs';\r\nimport { distinctUntilChanged, map } from 'rxjs/operators';\r\nimport { merge } from 'lodash';\r\n\r\n/**\r\n * Defines the shape of the state for components that need to persist\r\n * data on a per-tab basis. Using Partial<> for flexibility.\r\n */\r\nexport interface PerTabState {\r\n  sideDrawer?: {\r\n    isOpen: boolean;\r\n    activeComponent: string | null;\r\n    componentState?: { [componentKey: string]: unknown };\r\n  };\r\n  footer?: {\r\n    someData?: string;\r\n  };\r\n  console?: {\r\n    history: string[];\r\n  };\r\n}\r\n\r\n/**\r\n * Represents the entire state for a single tab, including its metadata\r\n * and the state of various components.\r\n */\r\nexport interface TabState {\r\n  id: string;\r\n  title: string;\r\n  componentState: PerTabState;\r\n}\r\n\r\n/**\r\n * Creates the default state for a new tab.\r\n */\r\nconst createDefaultComponentState = (): PerTabState => ({\r\n  sideDrawer: { isOpen: false, activeComponent: null, componentState: {} },\r\n  footer: { someData: '' },\r\n  console: { history: [] },\r\n});\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class TabStateService {\r\n  // Holds the state for all open tabs, keyed by tab ID.\r\n  private readonly _tabsState = new BehaviorSubject<Map<string, TabState>>(new Map());\r\n\r\n  // Holds the ID of the currently active tab.\r\n  private readonly _activeTabId = new BehaviorSubject<string | null>(null);\r\n\r\n  /** An observable of all open tabs. */\r\n  public readonly tabs$: Observable<TabState[]> = this._tabsState.pipe(\r\n    map(tabsMap => Array.from(tabsMap.values()))\r\n  );\r\n\r\n  /** An observable of the currently active tab's ID. */\r\n  public readonly activeTabId$ = this._activeTabId.asObservable().pipe(distinctUntilChanged());\r\n\r\n  /** An observable of the state of the currently active tab. */\r\n  public readonly activeTabState$: Observable<TabState | null> = this.activeTabId$.pipe(\r\n    map(activeId => (activeId ? this._tabsState.getValue().get(activeId) ?? null : null)),\r\n    // Use a deep-ish comparison to prevent emissions when only the object reference changes\r\n    distinctUntilChanged((prev, curr) => JSON.stringify(prev) === JSON.stringify(curr))\r\n  );\r\n\r\n  /** An observable of just the component-specific state for the active tab. */\r\n  public readonly activeComponentState$: Observable<PerTabState | null> = this.activeTabState$.pipe(\r\n    map(activeTab => activeTab?.componentState ?? null)\r\n  );\r\n\r\n  /**\r\n   * Adds a new tab to the state.\r\n   * @param title The title for the new tab.\r\n   * @param id An optional unique ID. If not provided, one will be generated.\r\n   * @returns The ID of the newly created tab.\r\n   */\r\n  public addTab(title: string, id?: string): string {\r\n    const newTabId = id || `tab_${Date.now()}_${Math.random()}`;\r\n    const newTab: TabState = {\r\n      id: newTabId,\r\n      title,\r\n      componentState: createDefaultComponentState(),\r\n    };\r\n\r\n    const currentTabs = this._tabsState.getValue();\r\n    const newTabs = new Map(currentTabs).set(newTabId, newTab);\r\n    this._tabsState.next(newTabs);\r\n    this.setActiveTab(newTabId);\r\n\r\n    return newTabId;\r\n  }\r\n\r\n  /**\r\n   * Removes a tab from the state.\r\n   * @param tabIdToRemove The ID of the tab to remove.\r\n   */\r\n  public removeTab(tabIdToRemove: string): void {\r\n    const currentTabs = this._tabsState.getValue();\r\n    if (!currentTabs.has(tabIdToRemove)) {\r\n      return;\r\n    }\r\n\r\n    const newTabs = new Map(currentTabs);\r\n    newTabs.delete(tabIdToRemove);\r\n    this._tabsState.next(newTabs);\r\n  }\r\n\r\n  constructor() {\r\n    // You can initialize with default tabs if needed\r\n    // For example:\r\n    // this.addTab('Welcome Tab');\r\n  }\r\n\r\n  /**\r\n   * Sets the currently active tab.\r\n   * @param tabId The unique identifier of the tab to activate.\r\n   */\r\n  public setActiveTab(tabId: string | null): void {\r\n    if (this._activeTabId.getValue() !== tabId) {\r\n      this._activeTabId.next(tabId);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Updates the state for the currently active tab.\r\n   * This performs a deep merge to avoid overwriting nested state.\r\n   * @param partialState The partial state to update for the active tab.\r\n   */\r\n  public updateActiveTabState(partialState: Partial<PerTabState>): void {\r\n    const activeId = this._activeTabId.getValue();\r\n    if (!activeId) {\r\n      console.warn('Cannot update state, no active tab.');\r\n      return;\r\n    }\r\n\r\n    const tabs = this._tabsState.getValue();\r\n    const activeTabState = tabs.get(activeId);\r\n\r\n    if (activeTabState) {\r\n      // Use lodash merge for a deep merge\r\n      const updatedState = merge({}, activeTabState, { componentState: partialState });\r\n      const newTabsState = new Map(tabs);\r\n      newTabsState.set(activeId, updatedState);\r\n      this._tabsState.next(newTabsState);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Gets an observable for a specific tab's state.\r\n   * @param tabId The ID of the tab to observe.\r\n   */\r\n  public getTabState(tabId: string): Observable<TabState | undefined> {\r\n    return this._tabsState.pipe(map(tabs => tabs.get(tabId)));\r\n  }\r\n\r\n  /**\r\n   * Determines the ID of the next tab to activate when a tab is closed.\r\n   * @param idToRemove The ID of the tab being removed.\r\n   * @returns The ID of the next tab to activate, or null if no tabs are left.\r\n   */\r\n  private getNextActiveTabId(idToRemove: string): string | null {\r\n    const tabsMap = this._tabsState.getValue();\r\n    if (tabsMap.size <= 1) {\r\n      return null;\r\n    }\r\n\r\n    const tabIds = Array.from(tabsMap.keys());\r\n    const removedIndex = tabIds.indexOf(idToRemove);\r\n\r\n    // If it's the last tab in the list, activate the one before it. Otherwise, activate the next one.\r\n    const nextIndex = removedIndex === tabIds.length - 1 ? removedIndex - 1 : removedIndex + 1;\r\n    return tabIds[nextIndex];\r\n  }\r\n}"]}

package/esm2022/lib/services/theme/theme.service.mjs

@@ -0,0 +1,151 @@
+import { Injectable, PLATFORM_ID, InjectionToken, signal, inject } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { tap } from 'rxjs/operators';
+import { of } from 'rxjs';
+import { cidePath, designConfigRoutesUrl, hostManagerRoutesUrl } from 'cloud-ide-lms-model';
+import { isPlatformBrowser } from '@angular/common';
+import * as i0 from "@angular/core";
+// Define an InjectionToken for the environment configuration
+// This is needed to inject environment variables into services provided in 'root'
+export const ENVIRONMENT_CONFIG = new InjectionToken('ENVIRONMENT_CONFIG');
+/**
+ * Utility function to convert database format keys to CSS format and handle units
+ * @param key - The database format key (e.g., 'font_size_xxxl')
+ * @param value - The value to be set
+ * @returns Object with cssVarName and processed value
+ */
+export function processThemeVariable(key, value) {
+    // 1. Convert the key from the DB format to the CSS format.
+    const cssVarName = `${key.replace(/_/g, '-')}`;
+    // 2. Append the font_size and line_height value to rem
+    let processedValue = value;
+    if (cssVarName.includes('font-size') || cssVarName.includes('line-height')) {
+        processedValue = parseFloat(value) + 'rem';
+    }
+    return { cssVarName, processedValue: processedValue };
+}
+/**
+ * Sets a single CSS variable on the document root element
+ * @param key - The database format key (e.g., 'font_size_xxxl')
+ * @param value - The value to be set
+ * @param platformId - Platform ID for browser check
+ */
+export function setCSSVariable(key, value, platformId) {
+    if (isPlatformBrowser(platformId)) {
+        const { cssVarName, processedValue } = processThemeVariable(key, value);
+        const root = document.documentElement;
+        root.style.setProperty(cssVarName, processedValue);
+    }
+}
+export class CideLytThemeService {
+    constructor() {
+        // Modern Angular signals for reactive state management
+        this.selectedThemeSignal = signal("");
+        this.selectedTheme = this.selectedThemeSignal.asReadonly();
+        // Modern dependency injection
+        this.http = inject(HttpClient);
+        this.platformId = inject(PLATFORM_ID);
+        this.environment = inject(ENVIRONMENT_CONFIG);
+    }
+    /**
+     * Fetches the theme from the API and applies it to the document.
+     * This method is intended to be called when the theme should actually be applied.
+     */
+    fetchAndApplyTheme() {
+        console.log('Fetching and applying theme via CideLytThemeService...');
+        return this.loadTheme(); // Use the existing loadTheme logic
+    }
+    /**
+     * Fetches the list of system themes from the API.
+     */
+    fetchSystemThemesList() {
+        return this.http.get(cidePath.join([
+            hostManagerRoutesUrl.cideSuiteHost,
+            designConfigRoutesUrl?.module,
+            designConfigRoutesUrl?.getSystemThemesList
+        ]));
+    }
+    /**
+     * Internal method to fetch the theme from the API and apply it.
+     */
+    loadTheme() {
+        return this.http.post(cidePath.join([hostManagerRoutesUrl.cideSuiteHost, designConfigRoutesUrl?.module, designConfigRoutesUrl?.getSystemTheme]), { syupth_user_id_user: "659a7ea0a1f0e08246661766" }).pipe(tap(theme => {
+            console.log("Applying theme:", theme);
+            this.applyTheme(theme?.data);
+        }));
+    }
+    /**
+     * Sets the CSS variables on the root element.
+     * @param theme - An object where keys are CSS variable names (e.g., '--color-text-body')
+     * and values are the color strings (e.g., '#ffffff').
+     */
+    applyTheme(theme) {
+        console.log("Applying theme:", theme);
+        let merged = {};
+        if (theme?.core_system_themes?.syth_properties) {
+            merged = { ...merged, ...theme.core_system_themes.syth_properties };
+            this.selectedThemeSignal.set(theme.core_system_themes._id);
+        }
+        if (theme?.core_system_organization_themes?.syoth_overrides) {
+            merged = { ...merged, ...theme.core_system_organization_themes.syoth_overrides };
+        }
+        if (theme?.core_system_theme_user_preferences?.syupth_overrides) {
+            merged = { ...merged, ...theme.core_system_theme_user_preferences.syupth_overrides };
+        }
+        console.log("Merged theme:", merged);
+        // Check if the code is running in a browser environment.
+        if (isPlatformBrowser(this.platformId)) {
+            const root = document.documentElement;
+            for (const [key, value] of Object.entries(merged)) {
+                const { cssVarName, processedValue } = processThemeVariable(key, value);
+                // Set the CSS custom property on the root element.
+                root.style.setProperty(cssVarName, processedValue);
+            }
+        }
+    }
+    /**
+     * Saves the system theme user preferences.
+     * @param themeVars - The theme variables to save.
+     * @returns An observable of the system theme user preferences.
+     */
+    saveSystemThemeUserPreferences(themeVars) {
+        return this.http.post(cidePath.join([hostManagerRoutesUrl.cideSuiteHost, designConfigRoutesUrl?.module, designConfigRoutesUrl?.systemThemeUserPreferences]), themeVars);
+    }
+    /**
+     * Updates a single CSS variable using the utility function
+     * @param key - The database format key (e.g., 'font_size_xxxl')
+     * @param value - The value to be set
+     */
+    updateCSSVariable(key, value) {
+        setCSSVariable(key, value, this.platformId);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytThemeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+/**
+ * Factory function for APP_INITIALIZER.
+ * This function is used in your app.config.ts.
+ * It conditionally triggers theme loading based on the environment setting.
+ */
+export function themeFactory(themeService, environmentConfig) {
+    return () => {
+        if (!environmentConfig.applyThemeOnLogin) {
+            // If theme should be applied on app initialize, fetch and apply it.
+            console.log('APP_INITIALIZER: Applying theme...');
+            return themeService.fetchAndApplyTheme();
+        }
+        else {
+            // If theme should be applied on login, APP_INITIALIZER does nothing for the theme.
+            // We return an observable that immediately completes.
+            console.log('APP_INITIALIZER: Theme application deferred to after login (per environment config).');
+            return of(undefined); // Return an observable that completes immediately
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"theme.service.js","sourceRoot":"","sources":["../../../../../../projects/cloud-ide-layout/src/lib/services/theme/theme.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACxF,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAc,EAAE,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,qBAAqB,EAAE,oBAAoB,EAAkN,MAAM,qBAAqB,CAAC;AAC5S,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;;AAEpD,6DAA6D;AAC7D,kFAAkF;AAClF,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,cAAc,CAAqB,oBAAoB,CAAC,CAAC;AAO/F;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAW,EAAE,KAAa;IAC7D,2DAA2D;IAC3D,MAAM,UAAU,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;IAE/C,uDAAuD;IACvD,IAAI,cAAc,GAAG,KAAK,CAAC;IAC3B,IAAI,UAAU,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;QAC3E,cAAc,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;IAC7C,CAAC;IAED,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC;AACxD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,GAAW,EAAE,KAAa,EAAE,UAAkB;IAC3E,IAAI,iBAAiB,CAAC,UAAU,CAAC,EAAE,CAAC;QAClC,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,GAAG,oBAAoB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACxE,MAAM,IAAI,GAAG,QAAQ,CAAC,eAAe,CAAC;QACtC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;IACrD,CAAC;AACH,CAAC;AAKD,MAAM,OAAO,mBAAmB;IAHhC;QAIE,uDAAuD;QAC/C,wBAAmB,GAAG,MAAM,CAAS,EAAE,CAAC,CAAC;QAC1C,kBAAa,GAAG,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,CAAC;QAE7D,8BAA8B;QACtB,SAAI,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAC1B,eAAU,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;QACjC,gBAAW,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAC;KAmFlD;IAjFC;;;OAGG;IACI,kBAAkB;QACvB,OAAO,CAAC,GAAG,CAAC,wDAAwD,CAAC,CAAC;QACtE,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,mCAAmC;IAC9D,CAAC;IAED;;OAEG;IACI,qBAAqB;QAC1B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAClB,QAAQ,CAAC,IAAI,CAAC;YACZ,oBAAoB,CAAC,aAAa;YAClC,qBAAqB,EAAE,MAAM;YAC7B,qBAAqB,EAAE,mBAAmB;SAC3C,CAAC,CAAC,CAAC;IACR,CAAC;IAED;;OAEG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAiC,QAAQ,CAAC,IAAI,CAAC,CAAC,oBAAoB,CAAC,aAAa,EAAE,qBAAqB,EAAE,MAAM,EAAE,qBAAqB,EAAE,cAAc,CAAC,CAAC,EAAE,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,CAAC,CAAC,IAAI,CACxO,GAAG,CAAC,KAAK,CAAC,EAAE;YACV,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;YACtC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,IAA0C,CAAC,CAAC;QACrE,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACK,UAAU,CAAC,KAAyC;QAC1D,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;QACtC,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,IAAI,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,CAAC;YAC/C,MAAM,GAAG,EAAE,GAAG,MAAM,EAAE,GAAG,KAAK,CAAC,kBAAkB,CAAC,eAAe,EAAE,CAAC;YACpE,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,KAAK,CAAC,kBAAkB,CAAC,GAAa,CAAC,CAAC;QACvE,CAAC;QACD,IAAI,KAAK,EAAE,+BAA+B,EAAE,eAAe,EAAE,CAAC;YAC5D,MAAM,GAAG,EAAE,GAAG,MAAM,EAAE,GAAG,KAAK,CAAC,+BAA+B,CAAC,eAAe,EAAE,CAAC;QACnF,CAAC;QACD,IAAI,KAAK,EAAE,kCAAkC,EAAE,gBAAgB,EAAE,CAAC;YAChE,MAAM,GAAG,EAAE,GAAG,MAAM,EAAE,GAAG,KAAK,CAAC,kCAAkC,CAAC,gBAAgB,EAAE,CAAC;QACvF,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;QACrC,yDAAyD;QACzD,IAAI,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACvC,MAAM,IAAI,GAAG,QAAQ,CAAC,eAAe,CAAC;YAEtC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;gBAClD,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,GAAG,oBAAoB,CAAC,GAAG,EAAE,KAAe,CAAC,CAAC;gBAClF,mDAAmD;gBACnD,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;YACrD,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,8BAA8B,CAAC,SAA6C;QAC1E,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAgD,QAAQ,CAAC,IAAI,CAAC,CAAC,oBAAoB,CAAC,aAAa,EAAE,qBAAqB,EAAE,MAAM,EAAE,qBAAqB,EAAE,0BAA0B,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;IACzN,CAAC;IAED;;;;OAIG;IACH,iBAAiB,CAAC,GAAW,EAAE,KAAa;QAC1C,cAAc,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC9C,CAAC;8GA1FU,mBAAmB;kHAAnB,mBAAmB,cAFlB,MAAM;;2FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;AA8FD;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,YAAiC,EAAE,iBAAqC;IACnG,OAAO,GAAG,EAAE;QACV,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,CAAC;YACzC,oEAAoE;YACpE,OAAO,CAAC,GAAG,CAAC,oCAAoC,CAAC,CAAC;YAClD,OAAO,YAAY,CAAC,kBAAkB,EAAE,CAAC;QAC3C,CAAC;aAAM,CAAC;YACN,mFAAmF;YACnF,sDAAsD;YACtD,OAAO,CAAC,GAAG,CAAC,sFAAsF,CAAC,CAAC;YACpG,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,kDAAkD;QAC1E,CAAC;IACH,CAAC,CAAC;AACJ,CAAC","sourcesContent":["\nimport { Injectable, PLATFORM_ID, InjectionToken, signal, inject } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { tap } from 'rxjs/operators';\nimport { Observable, of } from 'rxjs';\nimport { cidePath, designConfigRoutesUrl, hostManagerRoutesUrl, SystemThemeControllerRespoonse, SystemThemesListControllerRespoonse, IEnvironmentConfig, SystemThemeUserPreferencesControllerRespoonse, MSystemThemeUserPreferencesRequest, SystemThemeControllerRespoonseData } from 'cloud-ide-lms-model';\nimport { isPlatformBrowser } from '@angular/common';\n\n// Define an InjectionToken for the environment configuration\n// This is needed to inject environment variables into services provided in 'root'\nexport const ENVIRONMENT_CONFIG = new InjectionToken<IEnvironmentConfig>('ENVIRONMENT_CONFIG');\n\n// Define an interface for your theme for type safety\nexport interface Theme {\n  [key: string]: string; // Allows any string key, e.g., 'color-text-body'\n}\n\n/**\n * Utility function to convert database format keys to CSS format and handle units\n * @param key - The database format key (e.g., 'font_size_xxxl')\n * @param value - The value to be set\n * @returns Object with cssVarName and processed value\n */\nexport function processThemeVariable(key: string, value: string): { cssVarName: string; processedValue: string } {\n  // 1. Convert the key from the DB format to the CSS format.\n  const cssVarName = `${key.replace(/_/g, '-')}`;\n\n  // 2. Append the font_size and line_height value to rem\n  let processedValue = value;\n  if (cssVarName.includes('font-size') || cssVarName.includes('line-height')) {\n    processedValue = parseFloat(value) + 'rem';\n  }\n\n  return { cssVarName, processedValue: processedValue };\n}\n\n/**\n * Sets a single CSS variable on the document root element\n * @param key - The database format key (e.g., 'font_size_xxxl')\n * @param value - The value to be set\n * @param platformId - Platform ID for browser check\n */\nexport function setCSSVariable(key: string, value: string, platformId: object): void {\n  if (isPlatformBrowser(platformId)) {\n    const { cssVarName, processedValue } = processThemeVariable(key, value);\n    const root = document.documentElement;\n    root.style.setProperty(cssVarName, processedValue);\n  }\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class CideLytThemeService {\n  // Modern Angular signals for reactive state management\n  private selectedThemeSignal = signal<string>(\"\");\n  public selectedTheme = this.selectedThemeSignal.asReadonly();\n  \n  // Modern dependency injection\n  private http = inject(HttpClient);\n  private platformId = inject(PLATFORM_ID);\n  private environment = inject(ENVIRONMENT_CONFIG);\n\n  /**\n   * Fetches the theme from the API and applies it to the document.\n   * This method is intended to be called when the theme should actually be applied.\n   */\n  public fetchAndApplyTheme(): Observable<SystemThemeControllerRespoonse> {\n    console.log('Fetching and applying theme via CideLytThemeService...');\n    return this.loadTheme(); // Use the existing loadTheme logic\n  }\n\n  /**\n   * Fetches the list of system themes from the API.\n   */\n  public fetchSystemThemesList(): Observable<SystemThemesListControllerRespoonse> {\n    return this.http.get<SystemThemesListControllerRespoonse>(\n      cidePath.join([\n        hostManagerRoutesUrl.cideSuiteHost,\n        designConfigRoutesUrl?.module,\n        designConfigRoutesUrl?.getSystemThemesList\n      ]));\n  }\n\n  /**\n   * Internal method to fetch the theme from the API and apply it.\n   */\n  loadTheme() {\n    return this.http.post<SystemThemeControllerRespoonse>(cidePath.join([hostManagerRoutesUrl.cideSuiteHost, designConfigRoutesUrl?.module, designConfigRoutesUrl?.getSystemTheme]), { syupth_user_id_user: \"659a7ea0a1f0e08246661766\" }).pipe(\n      tap(theme => {\n        console.log(\"Applying theme:\", theme);\n        this.applyTheme(theme?.data as SystemThemeControllerRespoonseData);\n      })\n    );\n  }\n\n  /**\n   * Sets the CSS variables on the root element.\n   * @param theme - An object where keys are CSS variable names (e.g., '--color-text-body')\n   * and values are the color strings (e.g., '#ffffff').\n   */\n  private applyTheme(theme: SystemThemeControllerRespoonseData): void {\n    console.log(\"Applying theme:\", theme);\n    let merged = {};\n    if (theme?.core_system_themes?.syth_properties) {\n      merged = { ...merged, ...theme.core_system_themes.syth_properties };\n      this.selectedThemeSignal.set(theme.core_system_themes._id as string);\n    }\n    if (theme?.core_system_organization_themes?.syoth_overrides) {\n      merged = { ...merged, ...theme.core_system_organization_themes.syoth_overrides };\n    }\n    if (theme?.core_system_theme_user_preferences?.syupth_overrides) {\n      merged = { ...merged, ...theme.core_system_theme_user_preferences.syupth_overrides };\n    }\n    console.log(\"Merged theme:\", merged);\n    // Check if the code is running in a browser environment.\n    if (isPlatformBrowser(this.platformId)) {\n      const root = document.documentElement;\n\n      for (const [key, value] of Object.entries(merged)) {\n        const { cssVarName, processedValue } = processThemeVariable(key, value as string);\n        // Set the CSS custom property on the root element.\n        root.style.setProperty(cssVarName, processedValue);\n      }\n    }\n  }\n\n  /**\n   * Saves the system theme user preferences.\n   * @param themeVars - The theme variables to save.\n   * @returns An observable of the system theme user preferences.\n   */\n  saveSystemThemeUserPreferences(themeVars: MSystemThemeUserPreferencesRequest): Observable<SystemThemeUserPreferencesControllerRespoonse> {\n    return this.http.post<SystemThemeUserPreferencesControllerRespoonse>(cidePath.join([hostManagerRoutesUrl.cideSuiteHost, designConfigRoutesUrl?.module, designConfigRoutesUrl?.systemThemeUserPreferences]), themeVars);\n  }\n\n  /**\n   * Updates a single CSS variable using the utility function\n   * @param key - The database format key (e.g., 'font_size_xxxl')\n   * @param value - The value to be set\n   */\n  updateCSSVariable(key: string, value: string): void {\n    setCSSVariable(key, value, this.platformId);\n  }\n}\n\n/**\n * Factory function for APP_INITIALIZER.\n * This function is used in your app.config.ts.\n * It conditionally triggers theme loading based on the environment setting.\n */\nexport function themeFactory(themeService: CideLytThemeService, environmentConfig: IEnvironmentConfig): () => Observable<SystemThemeControllerRespoonse | undefined> {\n  return () => {\n    if (!environmentConfig.applyThemeOnLogin) {\n      // If theme should be applied on app initialize, fetch and apply it.\n      console.log('APP_INITIALIZER: Applying theme...');\n      return themeService.fetchAndApplyTheme();\n    } else {\n      // If theme should be applied on login, APP_INITIALIZER does nothing for the theme.\n      // We return an observable that immediately completes.\n      console.log('APP_INITIALIZER: Theme application deferred to after login (per environment config).');\n      return of(undefined); // Return an observable that completes immediately\n    }\n  };\n}"]}