cloud-ide-layout 0.0.1 → 1.0.1

package/esm2022/lib/services/app-state/app-state-helper.service.mjs

@@ -0,0 +1,222 @@
+import { Injectable, inject } from '@angular/core';
+import { AppStateService } from './app-state.service';
+import { CideLytSidebarService } from '../../layout/sidebar/sidebar.service';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class AppStateHelperService {
+    constructor() {
+        this.appStateService = inject(AppStateService);
+        this.sidebarService = inject(CideLytSidebarService);
+        // Computed signals for derived state
+        this.currentUser = this.appStateService.currentUser;
+        this.isAuthenticated = this.appStateService.isAuthenticated;
+        this.userInfo = this.appStateService.userInfo;
+        this.activeModule = this.appStateService.activeModule;
+        this.activeModuleInfo = this.appStateService.activeModuleInfo;
+        this.activeEntity = this.appStateService.activeEntity;
+    }
+    /**
+     * Get current user value (non-reactive)
+     */
+    getCurrentUser() {
+        return this.appStateService.getUserValue();
+    }
+    /**
+     * Set user data
+     */
+    setUser(user) {
+        this.appStateService.setUser(user);
+    }
+    /**
+     * Update user data (partial update)
+     */
+    updateUser(updates) {
+        this.appStateService.updateUser(updates);
+    }
+    /**
+     * Clear user data
+     */
+    clearUser() {
+        this.appStateService.clearUser();
+    }
+    /**
+     * Check if user is authenticated
+     */
+    isUserAuthenticated() {
+        return this.appStateService.isAuthenticated();
+    }
+    /**
+     * Get user info object
+     */
+    getUserInfo() {
+        return this.appStateService.userInfo();
+    }
+    /**
+     * Get user ID
+     */
+    getUserId() {
+        const user = this.getCurrentUser();
+        return user?._id || null;
+    }
+    /**
+     * Get user name
+     */
+    getUserName() {
+        const userInfo = this.getUserInfo();
+        return userInfo?.name || null;
+    }
+    /**
+     * Get user email
+     */
+    getUserEmail() {
+        const userInfo = this.getUserInfo();
+        return userInfo?.email || null;
+    }
+    /**
+     * Get user username
+     */
+    getUserUsername() {
+        const user = this.getCurrentUser();
+        return user?.user_username || null;
+    }
+    /**
+     * Get user full name
+     */
+    getUserFullName() {
+        const user = this.getCurrentUser();
+        return user?.user_fullname || null;
+    }
+    /**
+     * Get user first name
+     */
+    getUserFirstName() {
+        const user = this.getCurrentUser();
+        return user?.user_firstname || null;
+    }
+    /**
+     * Get user last name
+     */
+    getUserLastName() {
+        const user = this.getCurrentUser();
+        return user?.user_lastname || null;
+    }
+    /**
+     * Get user mobile number
+     */
+    getUserMobile() {
+        const user = this.getCurrentUser();
+        return user?.user_mobileno || null;
+    }
+    /**
+     * Set the active module
+     */
+    setActiveModule(module) {
+        this.appStateService.setActiveModule(module);
+    }
+    /**
+     * Get active module value (non-reactive)
+     */
+    getActiveModule() {
+        return this.appStateService.getActiveModuleValue();
+    }
+    /**
+     * Get active module info
+     */
+    getActiveModuleInfo() {
+        return this.appStateService.activeModuleInfo();
+    }
+    /**
+     * Get active module ID
+     */
+    getActiveModuleId() {
+        const module = this.getActiveModule();
+        return module?._id || null;
+    }
+    /**
+     * Get active module title
+     */
+    getActiveModuleTitle() {
+        const moduleInfo = this.getActiveModuleInfo();
+        return moduleInfo?.title || null;
+    }
+    /**
+     * Get active module icon
+     */
+    getActiveModuleIcon() {
+        const moduleInfo = this.getActiveModuleInfo();
+        return moduleInfo?.icon || null;
+    }
+    /**
+     * Set a module as active by its ID
+     * This replaces the previous isModuleActive method to use setActiveModule instead of getActiveModuleId
+     */
+    setActiveModuleById(moduleId) {
+        return this.sidebarService.getSidebarMenues({ syme_type: "module", sort: 'asc', syme_title: "" }).pipe(map(response => {
+            const modules = response?.data || [];
+            const targetModule = modules.find(module => module._id === moduleId);
+            if (targetModule) {
+                this.setActiveModule(targetModule);
+                return true;
+            }
+            else {
+                console.warn(`Module with ID "${moduleId}" not found`);
+                return false;
+            }
+        }));
+    }
+    /**
+     * Check if a module is active (keeping the original functionality for backward compatibility)
+     */
+    isModuleActive(moduleId) {
+        const activeModuleId = this.getActiveModuleId();
+        return activeModuleId === moduleId;
+    }
+    /**
+     * Set the active entity
+     */
+    setActiveEntity(entity) {
+        this.appStateService.setActiveEntity(entity);
+    }
+    /**
+     * Get active entity value (non-reactive)
+     */
+    getActiveEntity() {
+        return this.appStateService.getActiveEntityValue();
+    }
+    /**
+     * Get active entity ID
+     */
+    getActiveEntityId() {
+        const entity = this.getActiveEntity();
+        return entity?._id || '';
+    }
+    /**
+     * Get active entity name
+     */
+    getActiveEntityName() {
+        const entity = this.getActiveEntity();
+        return entity?.syen_name || null;
+    }
+    /**
+     * Get active entity code
+     */
+    getActiveEntityCode() {
+        const entity = this.getActiveEntity();
+        return entity?.syen_entity_code || null;
+    }
+    /**
+     * Manually refresh state from localStorage
+     */
+    refreshFromLocalStorage() {
+        this.appStateService.refreshFromLocalStorage();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AppStateHelperService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AppStateHelperService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AppStateHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-state-helper.service.js","sourceRoot":"","sources":["../../../../../../projects/cloud-ide-layout/src/lib/services/app-state/app-state-helper.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { AppStateService } from './app-state.service';\nimport { IUser, menuResponseData, ICoreSyen } from 'cloud-ide-lms-model';\nimport { CideLytSidebarService } from '../../layout/sidebar/sidebar.service';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AppStateHelperService {\n  private appStateService = inject(AppStateService);\n  private sidebarService = inject(CideLytSidebarService);\n\n  // Computed signals for derived state\n  public readonly currentUser = this.appStateService.currentUser;\n  public readonly isAuthenticated = this.appStateService.isAuthenticated;\n  public readonly userInfo = this.appStateService.userInfo;\n  public readonly activeModule = this.appStateService.activeModule;\n  public readonly activeModuleInfo = this.appStateService.activeModuleInfo;\n  public readonly activeEntity = this.appStateService.activeEntity;\n\n  /**\n   * Get current user value (non-reactive)\n   */\n  getCurrentUser(): IUser | null {\n    return this.appStateService.getUserValue();\n  }\n\n  /**\n   * Set user data\n   */\n  setUser(user: IUser | null): void {\n    this.appStateService.setUser(user);\n  }\n\n  /**\n   * Update user data (partial update)\n   */\n  updateUser(updates: Partial<IUser>): void {\n    this.appStateService.updateUser(updates);\n  }\n\n  /**\n   * Clear user data\n   */\n  clearUser(): void {\n    this.appStateService.clearUser();\n  }\n\n  /**\n   * Check if user is authenticated\n   */\n  isUserAuthenticated(): boolean {\n    return this.appStateService.isAuthenticated();\n  }\n\n  /**\n   * Get user info object\n   */\n  getUserInfo() {\n    return this.appStateService.userInfo();\n  }\n\n  /**\n   * Get user ID\n   */\n  getUserId(): string | null {\n    const user = this.getCurrentUser();\n    return user?._id || null;\n  }\n\n  /**\n   * Get user name\n   */\n  getUserName(): string | null {\n    const userInfo = this.getUserInfo();\n    return userInfo?.name || null;\n  }\n\n  /**\n   * Get user email\n   */\n  getUserEmail(): string | null {\n    const userInfo = this.getUserInfo();\n    return userInfo?.email || null;\n  }\n\n\n\n  /**\n   * Get user username\n   */\n  getUserUsername(): string | null {\n    const user = this.getCurrentUser();\n    return user?.user_username || null;\n  }\n\n  /**\n   * Get user full name\n   */\n  getUserFullName(): string | null {\n    const user = this.getCurrentUser();\n    return user?.user_fullname || null;\n  }\n\n  /**\n   * Get user first name\n   */\n  getUserFirstName(): string | null {\n    const user = this.getCurrentUser();\n    return user?.user_firstname || null;\n  }\n\n  /**\n   * Get user last name\n   */\n  getUserLastName(): string | null {\n    const user = this.getCurrentUser();\n    return user?.user_lastname || null;\n  }\n\n  /**\n   * Get user mobile number\n   */\n  getUserMobile(): number | null {\n    const user = this.getCurrentUser();\n    return user?.user_mobileno || null;\n  }\n\n  /**\n   * Set the active module\n   */\n  setActiveModule(module: menuResponseData | null): void {\n    this.appStateService.setActiveModule(module);\n  }\n\n  /**\n   * Get active module value (non-reactive)\n   */\n  getActiveModule(): menuResponseData | null {\n    return this.appStateService.getActiveModuleValue();\n  }\n\n  /**\n   * Get active module info\n   */\n  getActiveModuleInfo() {\n    return this.appStateService.activeModuleInfo();\n  }\n\n  /**\n   * Get active module ID\n   */\n  getActiveModuleId(): string | null {\n    const module = this.getActiveModule();\n    return module?._id || null;\n  }\n\n  /**\n   * Get active module title\n   */\n  getActiveModuleTitle(): string | null {\n    const moduleInfo = this.getActiveModuleInfo();\n    return moduleInfo?.title || null;\n  }\n\n  /**\n   * Get active module icon\n   */\n  getActiveModuleIcon(): string | null {\n    const moduleInfo = this.getActiveModuleInfo();\n    return moduleInfo?.icon || null;\n  }\n\n  /**\n   * Set a module as active by its ID\n   * This replaces the previous isModuleActive method to use setActiveModule instead of getActiveModuleId\n   */\n  setActiveModuleById(moduleId: string): Observable<boolean> {\n    return this.sidebarService.getSidebarMenues({ syme_type: \"module\", sort: 'asc', syme_title: \"\" }).pipe(\n      map(response => {\n        const modules = response?.data || [];\n        const targetModule = modules.find(module => module._id === moduleId);\n        \n        if (targetModule) {\n          this.setActiveModule(targetModule);\n          return true;\n        } else {\n          console.warn(`Module with ID \"${moduleId}\" not found`);\n          return false;\n        }\n      })\n    );\n  }\n\n  /**\n   * Check if a module is active (keeping the original functionality for backward compatibility)\n   */\n  isModuleActive(moduleId: string): boolean {\n    const activeModuleId = this.getActiveModuleId();\n    return activeModuleId === moduleId;\n  }\n\n  /**\n   * Set the active entity\n   */\n  setActiveEntity(entity: ICoreSyen | null): void {\n    this.appStateService.setActiveEntity(entity);\n  }\n\n  /**\n   * Get active entity value (non-reactive)\n   */\n  getActiveEntity(): ICoreSyen | null {\n    return this.appStateService.getActiveEntityValue();\n  }\n\n  /**\n   * Get active entity ID\n   */\n  getActiveEntityId(): string {\n    const entity = this.getActiveEntity();\n    return entity?._id || '';\n  }\n\n  /**\n   * Get active entity name\n   */\n  getActiveEntityName(): string | null {\n    const entity = this.getActiveEntity();\n    return entity?.syen_name || null;\n  }\n\n  /**\n   * Get active entity code\n   */\n  getActiveEntityCode(): string | null {\n    const entity = this.getActiveEntity();\n    return entity?.syen_entity_code || null;\n  }\n\n  /**\n   * Manually refresh state from localStorage\n   */\n  refreshFromLocalStorage(): void {\n    this.appStateService.refreshFromLocalStorage();\n  }\n} "]}

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

@@ -0,0 +1,256 @@
+import { Injectable, signal, computed, effect } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AppStateService {
+    constructor() {
+        // Private signal for current user
+        this.currentUserSignal = signal(null);
+        // Private signal for active module
+        this.activeModuleSignal = signal(null);
+        // Private signal for active entity
+        this.activeEntitySignal = signal(null);
+        // Public computed signal for current user, for other services to get the user value
+        this.currentUser = computed(() => this.currentUserSignal());
+        // Public computed signal for active module
+        this.activeModule = computed(() => this.activeModuleSignal());
+        // Public computed signal for active entity
+        this.activeEntity = computed(() => this.activeEntitySignal());
+        // Computed signals for derived state
+        this.isAuthenticated = computed(() => !!this.currentUserSignal());
+        this.userInfo = computed(() => {
+            const user = this.currentUserSignal();
+            if (!user)
+                return null;
+            return {
+                id: user._id,
+                name: user.user_fullname || `${user.user_firstname} ${user.user_lastname}`,
+                email: user.user_emailid,
+                role: user.user_id_role
+            };
+        });
+        // Computed signal for active module info
+        this.activeModuleInfo = computed(() => {
+            const module = this.activeModuleSignal();
+            if (!module)
+                return null;
+            return {
+                id: module._id,
+                title: module.syme_title,
+                icon: module.syme_icon,
+                path: module.syme_path,
+                type: module.syme_type
+            };
+        });
+        // Load initial state from localStorage
+        this.loadFromLocalStorage();
+        // Save to localStorage whenever state changes
+        effect(() => {
+            const currentUser = this.currentUserSignal();
+            const activeModule = this.activeModuleSignal();
+            const activeEntity = this.activeEntitySignal();
+            this.saveToLocalStorage({
+                user: currentUser,
+                activeModule: activeModule,
+                activeEntity: activeEntity
+            });
+        });
+        // Listen for localStorage changes from other tabs/windows
+        this.setupStorageListener();
+    }
+    /**
+     * Set the current user
+     */
+    setUser(user) {
+        this.currentUserSignal.set(user);
+    }
+    /**
+     * Update user data (partial update)
+     */
+    updateUser(updates) {
+        const currentUser = this.currentUserSignal();
+        if (currentUser) {
+            this.currentUserSignal.set({ ...currentUser, ...updates });
+        }
+    }
+    /**
+     * Clear user data
+     */
+    clearUser() {
+        this.currentUserSignal.set(null);
+    }
+    /**
+     * Get current user value (non-reactive)
+     */
+    getUserValue() {
+        return this.currentUserSignal();
+    }
+    /**
+     * Set the active module
+     */
+    setActiveModule(module) {
+        this.activeModuleSignal.set(module);
+    }
+    /**
+     * Get active module value (non-reactive)
+     */
+    getActiveModuleValue() {
+        return this.activeModuleSignal();
+    }
+    /**
+     * Set the active entity
+     */
+    setActiveEntity(entity) {
+        this.activeEntitySignal.set(entity);
+    }
+    /**
+     * Get active entity value (non-reactive)
+     */
+    getActiveEntityValue() {
+        return this.activeEntitySignal();
+    }
+    /**
+     * Manually refresh state from localStorage
+     * Call this method when you need to sync with external localStorage changes
+     */
+    refreshFromLocalStorage() {
+        this.loadFromLocalStorage();
+    }
+    /**
+     * Check if localStorage is available (browser environment)
+     */
+    isLocalStorageAvailable() {
+        try {
+            return typeof window !== 'undefined' && typeof localStorage !== 'undefined';
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Save state to localStorage
+     */
+    saveToLocalStorage(data) {
+        if (!this.isLocalStorageAvailable()) {
+            return;
+        }
+        try {
+            if (data.user !== undefined) {
+                if (data.user) {
+                    localStorage.setItem('cide_auth_user', JSON.stringify(data.user));
+                }
+                else {
+                    localStorage.removeItem('cide_auth_user');
+                }
+            }
+            if (data.activeModule !== undefined) {
+                if (data.activeModule) {
+                    localStorage.setItem('cide_active_module', JSON.stringify(data.activeModule));
+                }
+                else {
+                    localStorage.removeItem('cide_active_module');
+                }
+            }
+            if (data.activeEntity !== undefined) {
+                if (data.activeEntity) {
+                    localStorage.setItem('cide_active_entity', JSON.stringify(data.activeEntity));
+                }
+                else {
+                    localStorage.removeItem('cide_active_entity');
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error saving to localStorage:', error);
+        }
+    }
+    /**
+     * Load state from localStorage
+     */
+    loadFromLocalStorage() {
+        if (!this.isLocalStorageAvailable()) {
+            return;
+        }
+        try {
+            const userData = localStorage.getItem('cide_auth_user');
+            if (userData) {
+                const user = JSON.parse(userData);
+                this.currentUserSignal.set(user);
+            }
+            const moduleData = localStorage.getItem('cide_active_module');
+            if (moduleData) {
+                const module = JSON.parse(moduleData);
+                this.activeModuleSignal.set(module);
+            }
+            const entityData = localStorage.getItem('cide_active_entity');
+            if (entityData) {
+                const entity = JSON.parse(entityData);
+                this.activeEntitySignal.set(entity);
+            }
+        }
+        catch (error) {
+            console.error('Error loading from localStorage:', error);
+            // Clear corrupted data
+            if (this.isLocalStorageAvailable()) {
+                localStorage.removeItem('cide_auth_user');
+                localStorage.removeItem('cide_active_module');
+                localStorage.removeItem('cide_active_entity');
+            }
+        }
+    }
+    /**
+     * Setup storage event listener to handle external localStorage changes
+     */
+    setupStorageListener() {
+        if (!this.isLocalStorageAvailable()) {
+            return;
+        }
+        // Listen for storage events (triggered when localStorage is modified from other tabs/windows)
+        window.addEventListener('storage', (event) => {
+            if (!event.key)
+                return;
+            try {
+                // Handle user data changes
+                if (event.key === 'cide_auth_user') {
+                    if (event.newValue) {
+                        const user = JSON.parse(event.newValue);
+                        this.currentUserSignal.set(user);
+                    }
+                    else {
+                        this.currentUserSignal.set(null);
+                    }
+                }
+                // Handle active module changes
+                if (event.key === 'cide_active_module') {
+                    if (event.newValue) {
+                        const module = JSON.parse(event.newValue);
+                        this.activeModuleSignal.set(module);
+                    }
+                    else {
+                        this.activeModuleSignal.set(null);
+                    }
+                }
+                // Handle active entity changes
+                if (event.key === 'cide_active_entity') {
+                    if (event.newValue) {
+                        const entity = JSON.parse(event.newValue);
+                        this.activeEntitySignal.set(entity);
+                    }
+                    else {
+                        this.activeEntitySignal.set(null);
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Error parsing localStorage update:', error);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AppStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AppStateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AppStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-state.service.js","sourceRoot":"","sources":["../../../../../../projects/cloud-ide-layout/src/lib/services/app-state/app-state.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, computed, effect } from '@angular/core';\nimport { IUser, menuResponseData, ICoreSyen } from 'cloud-ide-lms-model';\n\nexport interface AppState {\n  currentUser: IUser | null;\n  activeModule: menuResponseData | null;\n  activeEntity: ICoreSyen | null;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AppStateService {\n  // Private signal for current user\n  private currentUserSignal = signal<IUser | null>(null);\n\n  // Private signal for active module\n  private activeModuleSignal = signal<menuResponseData | null>(null);\n\n  // Private signal for active entity\n  private activeEntitySignal = signal<ICoreSyen | null>(null);\n\n  // Public computed signal for current user, for other services to get the user value\n  public readonly currentUser = computed(() => this.currentUserSignal());\n\n  // Public computed signal for active module\n  public readonly activeModule = computed(() => this.activeModuleSignal());\n\n  // Public computed signal for active entity\n  public readonly activeEntity = computed(() => this.activeEntitySignal());\n\n  // Computed signals for derived state\n  public readonly isAuthenticated = computed(() => !!this.currentUserSignal());\n  public readonly userInfo = computed(() => {\n    const user = this.currentUserSignal();\n    if (!user) return null;\n    \n    return {\n      id: user._id,\n      name: user.user_fullname || `${user.user_firstname} ${user.user_lastname}`,\n      email: user.user_emailid,\n      role: user.user_id_role\n    };\n  });\n\n  // Computed signal for active module info\n  public readonly activeModuleInfo = computed(() => {\n    const module = this.activeModuleSignal();\n    if (!module) return null;\n    \n    return {\n      id: module._id,\n      title: module.syme_title,\n      icon: module.syme_icon,\n      path: module.syme_path,\n      type: module.syme_type\n    };\n  });\n\n  constructor() {\n    // Load initial state from localStorage\n    this.loadFromLocalStorage();\n    \n    // Save to localStorage whenever state changes\n    effect(() => {\n      const currentUser = this.currentUserSignal();\n      const activeModule = this.activeModuleSignal();\n      const activeEntity = this.activeEntitySignal();\n      this.saveToLocalStorage({\n        user: currentUser,\n        activeModule: activeModule,\n        activeEntity: activeEntity\n      });\n    });\n\n    // Listen for localStorage changes from other tabs/windows\n    this.setupStorageListener();\n  }\n\n  /**\n   * Set the current user\n   */\n  setUser(user: IUser | null): void {\n    this.currentUserSignal.set(user);\n  }\n\n  /**\n   * Update user data (partial update)\n   */\n  updateUser(updates: Partial<IUser>): void {\n    const currentUser = this.currentUserSignal();\n    if (currentUser) {\n      this.currentUserSignal.set({ ...currentUser, ...updates });\n    }\n  }\n\n  /**\n   * Clear user data\n   */\n  clearUser(): void {\n    this.currentUserSignal.set(null);\n  }\n\n  /**\n   * Get current user value (non-reactive)\n   */\n  getUserValue(): IUser | null {\n    return this.currentUserSignal();\n  }\n\n  /**\n   * Set the active module\n   */\n  setActiveModule(module: menuResponseData | null): void {\n    this.activeModuleSignal.set(module);\n  }\n\n  /**\n   * Get active module value (non-reactive)\n   */\n  getActiveModuleValue(): menuResponseData | null {\n    return this.activeModuleSignal();\n  }\n\n  /**\n   * Set the active entity\n   */\n  setActiveEntity(entity: ICoreSyen | null): void {\n    this.activeEntitySignal.set(entity);\n  }\n\n  /**\n   * Get active entity value (non-reactive)\n   */\n  getActiveEntityValue(): ICoreSyen | null {\n    return this.activeEntitySignal();\n  }\n\n  /**\n   * Manually refresh state from localStorage\n   * Call this method when you need to sync with external localStorage changes\n   */\n  refreshFromLocalStorage(): void {\n    this.loadFromLocalStorage();\n  }\n\n  /**\n   * Check if localStorage is available (browser environment)\n   */\n  private isLocalStorageAvailable(): boolean {\n    try {\n      return typeof window !== 'undefined' && typeof localStorage !== 'undefined';\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Save state to localStorage\n   */\n  private saveToLocalStorage(data: {\n    user?: IUser | null;\n    activeModule?: menuResponseData | null;\n    activeEntity?: ICoreSyen | null;\n  }): void {\n    if (!this.isLocalStorageAvailable()) {\n      return;\n    }\n\n    try {\n      if (data.user !== undefined) {\n        if (data.user) {\n          localStorage.setItem('cide_auth_user', JSON.stringify(data.user));\n        } else {\n          localStorage.removeItem('cide_auth_user');\n        }\n      }\n\n      if (data.activeModule !== undefined) {\n        if (data.activeModule) {\n          localStorage.setItem('cide_active_module', JSON.stringify(data.activeModule));\n        } else {\n          localStorage.removeItem('cide_active_module');\n        }\n      }\n\n      if (data.activeEntity !== undefined) {\n        if (data.activeEntity) {\n          localStorage.setItem('cide_active_entity', JSON.stringify(data.activeEntity));\n        } else {\n          localStorage.removeItem('cide_active_entity');\n        }\n      }\n    } catch (error) {\n      console.error('Error saving to localStorage:', error);\n    }\n  }\n\n  /**\n   * Load state from localStorage\n   */\n  private loadFromLocalStorage(): void {\n    if (!this.isLocalStorageAvailable()) {\n      return;\n    }\n\n    try {\n      const userData = localStorage.getItem('cide_auth_user');\n      if (userData) {\n        const user = JSON.parse(userData) as IUser;\n        this.currentUserSignal.set(user);\n      }\n\n      const moduleData = localStorage.getItem('cide_active_module');\n      if (moduleData) {\n        const module = JSON.parse(moduleData) as menuResponseData;\n        this.activeModuleSignal.set(module);\n      }\n\n      const entityData = localStorage.getItem('cide_active_entity');\n      if (entityData) {\n        const entity = JSON.parse(entityData) as ICoreSyen;\n        this.activeEntitySignal.set(entity);\n      }\n    } catch (error) {\n      console.error('Error loading from localStorage:', error);\n      // Clear corrupted data\n      if (this.isLocalStorageAvailable()) {\n        localStorage.removeItem('cide_auth_user');\n        localStorage.removeItem('cide_active_module');\n        localStorage.removeItem('cide_active_entity');\n      }\n    }\n  }\n\n  /**\n   * Setup storage event listener to handle external localStorage changes\n   */\n  private setupStorageListener(): void {\n    if (!this.isLocalStorageAvailable()) {\n      return;\n    }\n\n    // Listen for storage events (triggered when localStorage is modified from other tabs/windows)\n    window.addEventListener('storage', (event) => {\n      if (!event.key) return;\n\n      try {\n        // Handle user data changes\n        if (event.key === 'cide_auth_user') {\n          if (event.newValue) {\n            const user = JSON.parse(event.newValue) as IUser;\n            this.currentUserSignal.set(user);\n          } else {\n            this.currentUserSignal.set(null);\n          }\n        }\n\n        // Handle active module changes\n        if (event.key === 'cide_active_module') {\n          if (event.newValue) {\n            const module = JSON.parse(event.newValue) as menuResponseData;\n            this.activeModuleSignal.set(module);\n          } else {\n            this.activeModuleSignal.set(null);\n          }\n        }\n\n        // Handle active entity changes\n        if (event.key === 'cide_active_entity') {\n          if (event.newValue) {\n            const entity = JSON.parse(event.newValue) as ICoreSyen;\n            this.activeEntitySignal.set(entity);\n          } else {\n            this.activeEntitySignal.set(null);\n          }\n        }\n      } catch (error) {\n        console.error('Error parsing localStorage update:', error);\n      }\n    });\n  }\n} "]}

package/esm2022/lib/services/app-state/index.mjs

@@ -0,0 +1,3 @@
+export { AppStateService } from './app-state.service';
+export { AppStateHelperService } from './app-state-helper.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbG91ZC1pZGUtbGF5b3V0L3NyYy9saWIvc2VydmljZXMvYXBwLXN0YXRlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN0RCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IEFwcFN0YXRlU2VydmljZSB9IGZyb20gJy4vYXBwLXN0YXRlLnNlcnZpY2UnO1xyXG5leHBvcnQgeyBBcHBTdGF0ZUhlbHBlclNlcnZpY2UgfSBmcm9tICcuL2FwcC1zdGF0ZS1oZWxwZXIuc2VydmljZSc7XHJcbmV4cG9ydCB0eXBlIHsgQXBwU3RhdGUgfSBmcm9tICcuL2FwcC1zdGF0ZS5zZXJ2aWNlJzsgIl19