cloud-ide-layout 0.0.1 → 1.0.0

package/lib/services/app-state/app-state-helper.service.d.ts

@@ -0,0 +1,150 @@
+import { IUser, menuResponseData, ICoreSyen } from 'cloud-ide-lms-model';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class AppStateHelperService {
+    private appStateService;
+    private sidebarService;
+    readonly currentUser: import("@angular/core").Signal<IUser | null>;
+    readonly isAuthenticated: import("@angular/core").Signal<boolean>;
+    readonly userInfo: import("@angular/core").Signal<{
+        id: string | undefined;
+        name: string;
+        email: string | undefined;
+        role: string | undefined;
+    } | null>;
+    readonly activeModule: import("@angular/core").Signal<menuResponseData | null>;
+    readonly activeModuleInfo: import("@angular/core").Signal<{
+        id: string;
+        title: string;
+        icon: string;
+        path: string;
+        type: string;
+    } | null>;
+    readonly activeEntity: import("@angular/core").Signal<ICoreSyen | null>;
+    /**
+     * Get current user value (non-reactive)
+     */
+    getCurrentUser(): IUser | null;
+    /**
+     * Set user data
+     */
+    setUser(user: IUser | null): void;
+    /**
+     * Update user data (partial update)
+     */
+    updateUser(updates: Partial<IUser>): void;
+    /**
+     * Clear user data
+     */
+    clearUser(): void;
+    /**
+     * Check if user is authenticated
+     */
+    isUserAuthenticated(): boolean;
+    /**
+     * Get user info object
+     */
+    getUserInfo(): {
+        id: string | undefined;
+        name: string;
+        email: string | undefined;
+        role: string | undefined;
+    } | null;
+    /**
+     * Get user ID
+     */
+    getUserId(): string | null;
+    /**
+     * Get user name
+     */
+    getUserName(): string | null;
+    /**
+     * Get user email
+     */
+    getUserEmail(): string | null;
+    /**
+     * Get user username
+     */
+    getUserUsername(): string | null;
+    /**
+     * Get user full name
+     */
+    getUserFullName(): string | null;
+    /**
+     * Get user first name
+     */
+    getUserFirstName(): string | null;
+    /**
+     * Get user last name
+     */
+    getUserLastName(): string | null;
+    /**
+     * Get user mobile number
+     */
+    getUserMobile(): number | null;
+    /**
+     * Set the active module
+     */
+    setActiveModule(module: menuResponseData | null): void;
+    /**
+     * Get active module value (non-reactive)
+     */
+    getActiveModule(): menuResponseData | null;
+    /**
+     * Get active module info
+     */
+    getActiveModuleInfo(): {
+        id: string;
+        title: string;
+        icon: string;
+        path: string;
+        type: string;
+    } | null;
+    /**
+     * Get active module ID
+     */
+    getActiveModuleId(): string | null;
+    /**
+     * Get active module title
+     */
+    getActiveModuleTitle(): string | null;
+    /**
+     * Get active module icon
+     */
+    getActiveModuleIcon(): string | null;
+    /**
+     * Set a module as active by its ID
+     * This replaces the previous isModuleActive method to use setActiveModule instead of getActiveModuleId
+     */
+    setActiveModuleById(moduleId: string): Observable<boolean>;
+    /**
+     * Check if a module is active (keeping the original functionality for backward compatibility)
+     */
+    isModuleActive(moduleId: string): boolean;
+    /**
+     * Set the active entity
+     */
+    setActiveEntity(entity: ICoreSyen | null): void;
+    /**
+     * Get active entity value (non-reactive)
+     */
+    getActiveEntity(): ICoreSyen | null;
+    /**
+     * Get active entity ID
+     */
+    getActiveEntityId(): string;
+    /**
+     * Get active entity name
+     */
+    getActiveEntityName(): string | null;
+    /**
+     * Get active entity code
+     */
+    getActiveEntityCode(): string | null;
+    /**
+     * Manually refresh state from localStorage
+     */
+    refreshFromLocalStorage(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppStateHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppStateHelperService>;
+}

package/lib/services/app-state/app-state.service.d.ts

@@ -0,0 +1,85 @@
+import { IUser, menuResponseData, ICoreSyen } from 'cloud-ide-lms-model';
+import * as i0 from "@angular/core";
+export interface AppState {
+    currentUser: IUser | null;
+    activeModule: menuResponseData | null;
+    activeEntity: ICoreSyen | null;
+}
+export declare class AppStateService {
+    private currentUserSignal;
+    private activeModuleSignal;
+    private activeEntitySignal;
+    readonly currentUser: import("@angular/core").Signal<IUser | null>;
+    readonly activeModule: import("@angular/core").Signal<menuResponseData | null>;
+    readonly activeEntity: import("@angular/core").Signal<ICoreSyen | null>;
+    readonly isAuthenticated: import("@angular/core").Signal<boolean>;
+    readonly userInfo: import("@angular/core").Signal<{
+        id: string | undefined;
+        name: string;
+        email: string | undefined;
+        role: string | undefined;
+    } | null>;
+    readonly activeModuleInfo: import("@angular/core").Signal<{
+        id: string;
+        title: string;
+        icon: string;
+        path: string;
+        type: string;
+    } | null>;
+    constructor();
+    /**
+     * Set the current user
+     */
+    setUser(user: IUser | null): void;
+    /**
+     * Update user data (partial update)
+     */
+    updateUser(updates: Partial<IUser>): void;
+    /**
+     * Clear user data
+     */
+    clearUser(): void;
+    /**
+     * Get current user value (non-reactive)
+     */
+    getUserValue(): IUser | null;
+    /**
+     * Set the active module
+     */
+    setActiveModule(module: menuResponseData | null): void;
+    /**
+     * Get active module value (non-reactive)
+     */
+    getActiveModuleValue(): menuResponseData | null;
+    /**
+     * Set the active entity
+     */
+    setActiveEntity(entity: ICoreSyen | null): void;
+    /**
+     * Get active entity value (non-reactive)
+     */
+    getActiveEntityValue(): ICoreSyen | null;
+    /**
+     * Manually refresh state from localStorage
+     * Call this method when you need to sync with external localStorage changes
+     */
+    refreshFromLocalStorage(): void;
+    /**
+     * Check if localStorage is available (browser environment)
+     */
+    private isLocalStorageAvailable;
+    /**
+     * Save state to localStorage
+     */
+    private saveToLocalStorage;
+    /**
+     * Load state from localStorage
+     */
+    private loadFromLocalStorage;
+    /**
+     * Setup storage event listener to handle external localStorage changes
+     */
+    private setupStorageListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppStateService>;
+}

package/lib/services/app-state/index.d.ts

@@ -0,0 +1,3 @@
+export { AppStateService } from './app-state.service';
+export { AppStateHelperService } from './app-state-helper.service';
+export type { AppState } from './app-state.service';

package/lib/services/cache-manager/cache-manager.service.d.ts

@@ -0,0 +1,64 @@
+import { Observable } from 'rxjs';
+import { designConfigControllerResponse } from 'cloud-ide-lms-model';
+import * as i0 from "@angular/core";
+export declare class CacheManagerService {
+    private sharedService;
+    readonly cacheStats: import("@angular/core").Signal<{
+        hitRatio: number;
+        memoryEstimate: string;
+        totalCached: number;
+        validCached: number;
+        expiredCached: number;
+    }>;
+    readonly isLoading: (pageCode: string) => boolean;
+    readonly getCachedData: (pageCode: string) => designConfigControllerResponse | null;
+    /**
+     * Get page data with caching - this is the main method components should use
+     */
+    getPageData(pageCode: string, forceRefresh?: boolean): Observable<designConfigControllerResponse>;
+    /**
+     * Preload multiple pages for better performance
+     */
+    preloadPages(pageCodes: string[]): void;
+    /**
+     * Invalidate specific page cache
+     */
+    invalidatePage(pageCode: string): void;
+    /**
+     * Clear all cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache status for debugging
+     */
+    getCacheStatus(): {
+        pageCode: string;
+        cached: boolean;
+        expired: boolean;
+        loading: boolean;
+    }[];
+    /**
+     * Estimate memory usage of cache (rough estimate)
+     */
+    private estimateCacheMemoryUsage;
+    /**
+     * Check if cache entry is valid
+     */
+    private isCacheValid;
+    /**
+     * Export cache data for debugging or backup
+     */
+    exportCacheData(): string;
+    /**
+     * Get performance metrics
+     */
+    getPerformanceMetrics(): {
+        totalPages: number;
+        cachedPages: number;
+        loadingPages: number;
+        cacheHitRatio: number;
+        averageResponseTime?: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CacheManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CacheManagerService>;
+}

package/lib/services/file-manager/file-manager.service.d.ts

@@ -1,10 +1,8 @@
-import { HttpClient } from '@angular/common/http';
 import { MFileManager, fileManagerControllerResponse } from 'cloud-ide-lms-model';
 import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class CideLytFileManagerService {
     private http;
-    constructor(http: HttpClient);
     getFileDetails(body: MFileManager): Observable<fileManagerControllerResponse>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CideLytFileManagerService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CideLytFileManagerService>;

package/lib/services/tab-state.service.d.ts

@@ -0,0 +1,79 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Defines the shape of the state for components that need to persist
+ * data on a per-tab basis. Using Partial<> for flexibility.
+ */
+export interface PerTabState {
+    sideDrawer?: {
+        isOpen: boolean;
+        activeComponent: string | null;
+        componentState?: {
+            [componentKey: string]: unknown;
+        };
+    };
+    footer?: {
+        someData?: string;
+    };
+    console?: {
+        history: string[];
+    };
+}
+/**
+ * Represents the entire state for a single tab, including its metadata
+ * and the state of various components.
+ */
+export interface TabState {
+    id: string;
+    title: string;
+    componentState: PerTabState;
+}
+export declare class TabStateService {
+    private readonly _tabsState;
+    private readonly _activeTabId;
+    /** An observable of all open tabs. */
+    readonly tabs$: Observable<TabState[]>;
+    /** An observable of the currently active tab's ID. */
+    readonly activeTabId$: Observable<string | null>;
+    /** An observable of the state of the currently active tab. */
+    readonly activeTabState$: Observable<TabState | null>;
+    /** An observable of just the component-specific state for the active tab. */
+    readonly activeComponentState$: Observable<PerTabState | null>;
+    /**
+     * Adds a new tab to the state.
+     * @param title The title for the new tab.
+     * @param id An optional unique ID. If not provided, one will be generated.
+     * @returns The ID of the newly created tab.
+     */
+    addTab(title: string, id?: string): string;
+    /**
+     * Removes a tab from the state.
+     * @param tabIdToRemove The ID of the tab to remove.
+     */
+    removeTab(tabIdToRemove: string): void;
+    constructor();
+    /**
+     * Sets the currently active tab.
+     * @param tabId The unique identifier of the tab to activate.
+     */
+    setActiveTab(tabId: string | null): void;
+    /**
+     * 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: Partial<PerTabState>): void;
+    /**
+     * Gets an observable for a specific tab's state.
+     * @param tabId The ID of the tab to observe.
+     */
+    getTabState(tabId: string): Observable<TabState | undefined>;
+    /**
+     * 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.
+     */
+    private getNextActiveTabId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TabStateService>;
+}

package/lib/services/theme/theme.service.d.ts

@@ -0,0 +1,71 @@
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { SystemThemeControllerRespoonse, SystemThemesListControllerRespoonse, IEnvironmentConfig, SystemThemeUserPreferencesControllerRespoonse, MSystemThemeUserPreferencesRequest } from 'cloud-ide-lms-model';
+import * as i0 from "@angular/core";
+export declare const ENVIRONMENT_CONFIG: InjectionToken<IEnvironmentConfig>;
+export interface Theme {
+    [key: string]: string;
+}
+/**
+ * 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 declare function processThemeVariable(key: string, value: string): {
+    cssVarName: string;
+    processedValue: string;
+};
+/**
+ * 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 declare function setCSSVariable(key: string, value: string, platformId: object): void;
+export declare class CideLytThemeService {
+    private selectedThemeSignal;
+    selectedTheme: import("@angular/core").Signal<string>;
+    private http;
+    private platformId;
+    private environment;
+    /**
+     * 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(): Observable<SystemThemeControllerRespoonse>;
+    /**
+     * Fetches the list of system themes from the API.
+     */
+    fetchSystemThemesList(): Observable<SystemThemesListControllerRespoonse>;
+    /**
+     * Internal method to fetch the theme from the API and apply it.
+     */
+    loadTheme(): Observable<SystemThemeControllerRespoonse>;
+    /**
+     * 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').
+     */
+    private applyTheme;
+    /**
+     * Saves the system theme user preferences.
+     * @param themeVars - The theme variables to save.
+     * @returns An observable of the system theme user preferences.
+     */
+    saveSystemThemeUserPreferences(themeVars: MSystemThemeUserPreferencesRequest): Observable<SystemThemeUserPreferencesControllerRespoonse>;
+    /**
+     * 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: string, value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideLytThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CideLytThemeService>;
+}
+/**
+ * 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 declare function themeFactory(themeService: CideLytThemeService, environmentConfig: IEnvironmentConfig): () => Observable<SystemThemeControllerRespoonse | undefined>;

package/lib/services/user-status/user-status.service.d.ts

@@ -0,0 +1,57 @@
+import * as i0 from "@angular/core";
+export type UserStatus = 'online' | 'offline' | 'away' | 'busy' | 'do-not-disturb';
+export interface UserStatusData {
+    status: UserStatus;
+    lastActive: Date;
+    message?: string;
+}
+export declare class CideLytUserStatusService {
+    private _userStatus;
+    readonly userStatus: import("@angular/core").Signal<UserStatusData>;
+    readonly isOnline: import("@angular/core").Signal<boolean>;
+    readonly statusColor: import("@angular/core").Signal<string>;
+    readonly statusText: import("@angular/core").Signal<string>;
+    private statusSubject;
+    readonly status$: import("rxjs").Observable<UserStatusData>;
+    private lastActivityTime;
+    private autoAwayTimeout;
+    private autoAwayEnabled;
+    constructor();
+    /**
+     * Sets the user status
+     * @param status The new status to set
+     * @param message Optional custom status message
+     */
+    setStatus(status: UserStatus, message?: string): void;
+    /**
+     * Marks user as active (resets away timer)
+     */
+    markUserActive(): void;
+    /**
+     * Gets CSS class for status color
+     */
+    private getStatusColor;
+    /**
+     * Gets human-readable status text
+     */
+    private getStatusText;
+    private getBaseStatusText;
+    /**
+     * Initialize activity tracking for auto-away
+     */
+    private initializeActivityTracking;
+    /**
+     * Start the auto-away timer
+     */
+    private startAutoAwayTimer;
+    /**
+     * Enable or disable auto-away functionality
+     */
+    setAutoAwayEnabled(enabled: boolean): void;
+    /**
+     * Set the auto-away timeout (in milliseconds)
+     */
+    setAutoAwayTimeout(timeout: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideLytUserStatusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CideLytUserStatusService>;
+}

package/lib/utils/custom-route-reuse-strategy.d.ts

@@ -0,0 +1,15 @@
+import { ActivatedRouteSnapshot, DetachedRouteHandle, RouteReuseStrategy } from '@angular/router';
+/**
+ * A custom route reuse strategy that allows storing and retrieving routes
+ * to persist component state, especially for tabbed navigation.
+ */
+export declare class CustomRouteReuseStrategy implements RouteReuseStrategy {
+    private storedRoutes;
+    private getPathKey;
+    shouldDetach(route: ActivatedRouteSnapshot): boolean;
+    store(route: ActivatedRouteSnapshot, handle: DetachedRouteHandle | null): void;
+    shouldAttach(route: ActivatedRouteSnapshot): boolean;
+    retrieve(route: ActivatedRouteSnapshot): DetachedRouteHandle | null;
+    shouldReuseRoute(future: ActivatedRouteSnapshot, curr: ActivatedRouteSnapshot): boolean;
+    clearStoredRoute(pathKey: string): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloud-ide-layout",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "peerDependencies": {
     "@angular/common": "^18.0.0",
     "@angular/core": "^18.0.0"
@@ -10,7 +10,7 @@
   },
   "sideEffects": false,
   "exports": {
-    "style": {
+    "./style": {
       "sass": "./lib/assets/css/cide-lyt-variable.scss"
     },
     "./package.json": {

package/public-api.d.ts

@@ -3,3 +3,6 @@ export * from './lib/cloud-ide-layout.component';
 export * from './lib/layout/shared/shared-wrapper/shared-wrapper.component';
 export * from './lib/layout/shared/shared.service';
 export * from './lib/cloud-ide-layout.routes';
+export * from './lib/services/app-state';
+export * from './lib/services/user-status/user-status.service';
+export * from './lib/services/cache-manager/cache-manager.service';