cloud-ide-layout 0.0.1 → 1.0.0

package/esm2022/lib/services/user-status/user-status.service.mjs

@@ -0,0 +1,135 @@
+import { Injectable, signal, computed } from '@angular/core';
+import { BehaviorSubject, interval } from 'rxjs';
+import * as i0 from "@angular/core";
+export class CideLytUserStatusService {
+    constructor() {
+        // Modern Angular Signals pattern
+        this._userStatus = signal({
+            status: 'online',
+            lastActive: new Date(),
+            message: undefined
+        });
+        // Public readonly access to status
+        this.userStatus = this._userStatus.asReadonly();
+        // Computed properties
+        this.isOnline = computed(() => this._userStatus().status !== 'offline');
+        this.statusColor = computed(() => this.getStatusColor(this._userStatus().status));
+        this.statusText = computed(() => this.getStatusText(this._userStatus().status));
+        // Legacy observable for compatibility
+        this.statusSubject = new BehaviorSubject(this._userStatus());
+        this.status$ = this.statusSubject.asObservable();
+        // Auto-away functionality
+        this.lastActivityTime = Date.now();
+        this.autoAwayTimeout = 5 * 60 * 1000; // 5 minutes
+        this.autoAwayEnabled = true;
+        this.initializeActivityTracking();
+        this.startAutoAwayTimer();
+    }
+    /**
+     * Sets the user status
+     * @param status The new status to set
+     * @param message Optional custom status message
+     */
+    setStatus(status, message) {
+        const statusData = {
+            status,
+            lastActive: new Date(),
+            message
+        };
+        this._userStatus.set(statusData);
+        this.statusSubject.next(statusData);
+        this.lastActivityTime = Date.now();
+    }
+    /**
+     * Marks user as active (resets away timer)
+     */
+    markUserActive() {
+        this.lastActivityTime = Date.now();
+        // If user was away, bring them back to online
+        if (this._userStatus().status === 'away') {
+            this.setStatus('online');
+        }
+    }
+    /**
+     * Gets CSS class for status color
+     */
+    getStatusColor(status) {
+        switch (status) {
+            case 'online': return 'tw-bg-green-500';
+            case 'away': return 'tw-bg-yellow-500';
+            case 'busy': return 'tw-bg-orange-500';
+            case 'do-not-disturb': return 'tw-bg-red-500';
+            case 'offline': return 'tw-bg-gray-400';
+            default: return 'tw-bg-gray-400';
+        }
+    }
+    /**
+     * Gets human-readable status text
+     */
+    getStatusText(status) {
+        const current = this._userStatus();
+        const baseText = this.getBaseStatusText(status);
+        return current.message ? `${baseText} - ${current.message}` : baseText;
+    }
+    getBaseStatusText(status) {
+        switch (status) {
+            case 'online': return 'Online';
+            case 'away': return 'Away';
+            case 'busy': return 'Busy';
+            case 'do-not-disturb': return 'Do not disturb';
+            case 'offline': return 'Offline';
+            default: return 'Unknown';
+        }
+    }
+    /**
+     * Initialize activity tracking for auto-away
+     */
+    initializeActivityTracking() {
+        if (typeof window === 'undefined')
+            return;
+        const events = ['mousedown', 'mousemove', 'keypress', 'scroll', 'touchstart', 'click'];
+        events.forEach(event => {
+            document.addEventListener(event, () => {
+                this.markUserActive();
+            }, { passive: true });
+        });
+    }
+    /**
+     * Start the auto-away timer
+     */
+    startAutoAwayTimer() {
+        if (!this.autoAwayEnabled)
+            return;
+        interval(30000).subscribe({
+            next: () => {
+                const now = Date.now();
+                const timeSinceActivity = now - this.lastActivityTime;
+                if (timeSinceActivity > this.autoAwayTimeout &&
+                    this._userStatus().status === 'online') {
+                    this.setStatus('away', 'Auto-away due to inactivity');
+                }
+            }
+        });
+    }
+    /**
+     * Enable or disable auto-away functionality
+     */
+    setAutoAwayEnabled(enabled) {
+        this.autoAwayEnabled = enabled;
+    }
+    /**
+     * Set the auto-away timeout (in milliseconds)
+     */
+    setAutoAwayTimeout(timeout) {
+        this.autoAwayTimeout = timeout;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytUserStatusService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytUserStatusService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytUserStatusService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-status.service.js","sourceRoot":"","sources":["../../../../../../projects/cloud-ide-layout/src/lib/services/user-status/user-status.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, computed } from '@angular/core';\r\nimport { BehaviorSubject, interval } from 'rxjs';\r\n\r\nexport type UserStatus = 'online' | 'offline' | 'away' | 'busy' | 'do-not-disturb';\r\n\r\nexport interface UserStatusData {\r\n  status: UserStatus;\r\n  lastActive: Date;\r\n  message?: string;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CideLytUserStatusService {\r\n  // Modern Angular Signals pattern\r\n  private _userStatus = signal<UserStatusData>({\r\n    status: 'online',\r\n    lastActive: new Date(),\r\n    message: undefined\r\n  });\r\n\r\n  // Public readonly access to status\r\n  public readonly userStatus = this._userStatus.asReadonly();\r\n\r\n  // Computed properties\r\n  public readonly isOnline = computed(() => this._userStatus().status !== 'offline');\r\n  public readonly statusColor = computed(() => this.getStatusColor(this._userStatus().status));\r\n  public readonly statusText = computed(() => this.getStatusText(this._userStatus().status));\r\n\r\n  // Legacy observable for compatibility\r\n  private statusSubject = new BehaviorSubject<UserStatusData>(this._userStatus());\r\n  public readonly status$ = this.statusSubject.asObservable();\r\n\r\n  // Auto-away functionality\r\n  private lastActivityTime = Date.now();\r\n  private autoAwayTimeout = 5 * 60 * 1000; // 5 minutes\r\n  private autoAwayEnabled = true;\r\n\r\n  constructor() {\r\n    this.initializeActivityTracking();\r\n    this.startAutoAwayTimer();\r\n  }\r\n\r\n  /**\r\n   * Sets the user status\r\n   * @param status The new status to set\r\n   * @param message Optional custom status message\r\n   */\r\n  setStatus(status: UserStatus, message?: string): void {\r\n    const statusData: UserStatusData = {\r\n      status,\r\n      lastActive: new Date(),\r\n      message\r\n    };\r\n    \r\n    this._userStatus.set(statusData);\r\n    this.statusSubject.next(statusData);\r\n    this.lastActivityTime = Date.now();\r\n  }\r\n\r\n  /**\r\n   * Marks user as active (resets away timer)\r\n   */\r\n  markUserActive(): void {\r\n    this.lastActivityTime = Date.now();\r\n    \r\n    // If user was away, bring them back to online\r\n    if (this._userStatus().status === 'away') {\r\n      this.setStatus('online');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Gets CSS class for status color\r\n   */\r\n  private getStatusColor(status: UserStatus): string {\r\n    switch (status) {\r\n      case 'online': return 'tw-bg-green-500';\r\n      case 'away': return 'tw-bg-yellow-500';\r\n      case 'busy': return 'tw-bg-orange-500';\r\n      case 'do-not-disturb': return 'tw-bg-red-500';\r\n      case 'offline': return 'tw-bg-gray-400';\r\n      default: return 'tw-bg-gray-400';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Gets human-readable status text\r\n   */\r\n  private getStatusText(status: UserStatus): string {\r\n    const current = this._userStatus();\r\n    const baseText = this.getBaseStatusText(status);\r\n    \r\n    return current.message ? `${baseText} - ${current.message}` : baseText;\r\n  }\r\n\r\n  private getBaseStatusText(status: UserStatus): string {\r\n    switch (status) {\r\n      case 'online': return 'Online';\r\n      case 'away': return 'Away';\r\n      case 'busy': return 'Busy';\r\n      case 'do-not-disturb': return 'Do not disturb';\r\n      case 'offline': return 'Offline';\r\n      default: return 'Unknown';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Initialize activity tracking for auto-away\r\n   */\r\n  private initializeActivityTracking(): void {\r\n    if (typeof window === 'undefined') return;\r\n\r\n    const events = ['mousedown', 'mousemove', 'keypress', 'scroll', 'touchstart', 'click'];\r\n    \r\n    events.forEach(event => {\r\n      document.addEventListener(event, () => {\r\n        this.markUserActive();\r\n      }, { passive: true });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Start the auto-away timer\r\n   */\r\n  private startAutoAwayTimer(): void {\r\n    if (!this.autoAwayEnabled) return;\r\n\r\n    interval(30000).subscribe({\r\n      next: () => { // Check every 30 seconds\r\n        const now = Date.now();\r\n        const timeSinceActivity = now - this.lastActivityTime;\r\n        \r\n        if (timeSinceActivity > this.autoAwayTimeout && \r\n            this._userStatus().status === 'online') {\r\n          this.setStatus('away', 'Auto-away due to inactivity');\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Enable or disable auto-away functionality\r\n   */\r\n  setAutoAwayEnabled(enabled: boolean): void {\r\n    this.autoAwayEnabled = enabled;\r\n  }\r\n\r\n  /**\r\n   * Set the auto-away timeout (in milliseconds)\r\n   */\r\n  setAutoAwayTimeout(timeout: number): void {\r\n    this.autoAwayTimeout = timeout;\r\n  }\r\n} "]}

package/esm2022/lib/utils/custom-route-reuse-strategy.mjs

@@ -0,0 +1,61 @@
+/**
+ * A custom route reuse strategy that allows storing and retrieving routes
+ * to persist component state, especially for tabbed navigation.
+ */
+export class CustomRouteReuseStrategy {
+    constructor() {
+        this.storedRoutes = {};
+    }
+    // Generates a unique key for a route.
+    // For routes marked with 'reuseTab', this key includes sorted query parameters
+    // to ensure distinct states for tabs differing by query params.
+    getPathKey(route) {
+        let path = route.pathFromRoot
+            .map(r => r.url.map(segment => segment.path).join('/'))
+            .filter(p => p.length > 0)
+            .join('/');
+        // If the route is marked for tab reuse and has query parameters,
+        // append them to the key in a sorted, consistent manner.
+        if (route.data && route.data['reuseTab'] && route.queryParamMap.keys.length > 0) {
+            const queryParams = route.queryParamMap.keys
+                .sort() // Ensure consistent order of query parameters
+                .map(key => `${key}=${route.queryParamMap.get(key)}`)
+                .join('&');
+            path += '?' + queryParams;
+        }
+        return path;
+    }
+    // Determines if this route (and its subtree) should be detached to be reused later.
+    shouldDetach(route) {
+        return !!(route.data && route.data['reuseTab']);
+    }
+    // Stores the detached route.
+    store(route, handle) {
+        const pathKey = this.getPathKey(route);
+        if (handle && route.data && route.data['reuseTab'] && pathKey) {
+            this.storedRoutes[pathKey] = handle;
+        }
+    }
+    // Determines if this route (and its subtree) should be reattached.
+    shouldAttach(route) {
+        const pathKey = this.getPathKey(route);
+        return !!pathKey && !!this.storedRoutes[pathKey];
+    }
+    // Retrieves the previously stored route.
+    retrieve(route) {
+        const pathKey = this.getPathKey(route);
+        if (!pathKey || !this.storedRoutes[pathKey]) {
+            return null;
+        }
+        return this.storedRoutes[pathKey];
+    }
+    // Determines if a route should be reused.
+    shouldReuseRoute(future, curr) {
+        return future.routeConfig === curr.routeConfig;
+    }
+    // Clears a stored route, typically when a tab is closed.
+    clearStoredRoute(pathKey) {
+        delete this.storedRoutes[pathKey];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public-api.mjs

@@ -6,4 +6,9 @@ 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';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2Nsb3VkLWlkZS1sYXlvdXQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyw2REFBNkQsQ0FBQztBQUM1RSxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsK0JBQStCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxyXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgY2xvdWQtaWRlLWxheW91dFxyXG4gKi9cclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Nsb3VkLWlkZS1sYXlvdXQuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Nsb3VkLWlkZS1sYXlvdXQuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbGF5b3V0L3NoYXJlZC9zaGFyZWQtd3JhcHBlci9zaGFyZWQtd3JhcHBlci5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9sYXlvdXQvc2hhcmVkL3NoYXJlZC5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY2xvdWQtaWRlLWxheW91dC5yb3V0ZXMnOyJdfQ==
+// App State Management
+export * from './lib/services/app-state';
+export * from './lib/services/user-status/user-status.service';
+// Modern Page Data Management (Legacy code removed)
+export * from './lib/services/cache-manager/cache-manager.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2Nsb3VkLWlkZS1sYXlvdXQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyw2REFBNkQsQ0FBQztBQUM1RSxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsK0JBQStCLENBQUM7QUFFOUMsdUJBQXVCO0FBQ3ZCLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxnREFBZ0QsQ0FBQztBQUUvRCxvREFBb0Q7QUFDcEQsY0FBYyxvREFBb0QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgY2xvdWQtaWRlLWxheW91dFxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2Nsb3VkLWlkZS1sYXlvdXQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jbG91ZC1pZGUtbGF5b3V0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9sYXlvdXQvc2hhcmVkL3NoYXJlZC13cmFwcGVyL3NoYXJlZC13cmFwcGVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9sYXlvdXQvc2hhcmVkL3NoYXJlZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Nsb3VkLWlkZS1sYXlvdXQucm91dGVzJztcblxuLy8gQXBwIFN0YXRlIE1hbmFnZW1lbnRcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzL2FwcC1zdGF0ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcy91c2VyLXN0YXR1cy91c2VyLXN0YXR1cy5zZXJ2aWNlJztcblxuLy8gTW9kZXJuIFBhZ2UgRGF0YSBNYW5hZ2VtZW50IChMZWdhY3kgY29kZSByZW1vdmVkKVxuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvY2FjaGUtbWFuYWdlci9jYWNoZS1tYW5hZ2VyLnNlcnZpY2UnOyJdfQ==