@c8y/ngx-components 1021.13.3 → 1021.21.0

package/esm2022/core/dashboard/widget-auto-refresh-context/widget-global-auto-refresh.service.mjs

@@ -0,0 +1,233 @@
+import { inject, Injectable, signal } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { distinctUntilChanged, filter, map, skip, switchMap, tap } from 'rxjs/operators';
+import { DEFAULT_INTERVAL_STATE, DEFAULT_INTERVAL_VALUE, GLOBAL_CONTEXT_AUTO_REFRESH } from './widget-auto-refresh-context.model';
+import { ActivatedRoute, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export class WidgetGlobalAutoRefreshService {
+    constructor() {
+        /**
+         * A BehaviorSubject that tracks the number of loading operations in progress.
+         * Initialized with a count of 0.
+         */
+        this.loadingCount$ = new BehaviorSubject(0);
+        /**
+         * An Observable that emits a boolean indicating whether any widgets with global refresh option are currently loading.
+         * The value is true if the loading count is non-zero, and false if the loading count is zero.
+         * Uses distinctUntilChanged() to emit only when the boolean value changes.
+         */
+        this.isLoadingWidgets$ = this.loadingCount$.pipe(distinctUntilChanged(), map(count => count !== 0));
+        /**
+         * Object containing behavior subjects for managing auto-refresh settings.
+         */
+        this.autoRefreshSettings = {
+            /**
+             * BehaviorSubject that emits the current state of auto-refresh button.
+             * Defaults to DEFAULT_INTERVAL_STATE.
+             */
+            isEnabled$: new BehaviorSubject(DEFAULT_INTERVAL_STATE),
+            /**
+             * BehaviorSubject that emits the current auto-refresh interval value.
+             * Defaults to DEFAULT_INTERVAL_VALUE.
+             */
+            refreshInterval$: new BehaviorSubject(DEFAULT_INTERVAL_VALUE),
+            /**
+             * BehaviorSubject that emits whether auto-refresh has been manually disabled by the user.
+             * Defaults to false.
+             */
+            userDisabledManually$: new BehaviorSubject(false)
+        };
+        /**
+         * Object containing subjects for managing countdown actions.
+         */
+        this.countdownActions = {
+            /**
+             * Subject used to stop the countdown.
+             */
+            stop$: new Subject(),
+            /**
+             * Subject used to reset the countdown.
+             */
+            reset$: new Subject(),
+            /**
+             * Subject that emits when the countdown has ended.
+             */
+            countdownEnded$: new Subject()
+        };
+        /**
+         * Subject that emits when a dashboard save operation is triggered.
+         */
+        this.onDashboardSave$ = new Subject();
+        /**
+         * A signal representing the number of widgets with the global auto-refresh option enabled.
+         */
+        this.globalRefreshWidgetsCount = signal(0);
+        /**
+         * Tracks the navigation state.
+         *
+         * The signal returns a boolean indicating whether a navigation operation is currently in progress.
+         * It initializes with a default value of `false` and can be toggled to `true` during navigation events from `handleNavigationInProgress$`.
+         */
+        this.navigationInProgress = signal(false);
+        this.router = inject(Router);
+        this.activatedRoute = inject(ActivatedRoute);
+    }
+    /**
+     * Increments the loading count by 1.
+     */
+    incrementLoading() {
+        this.loadingCount$.next(this.loadingCount$.value + 1);
+    }
+    /**
+     * Decrements the loading count by 1.
+     */
+    decrementLoading() {
+        this.loadingCount$.next(this.loadingCount$.value - 1);
+    }
+    /**
+     * Retrieves an observable that emits the value of a Global Auto Refresh query parameter
+     * whenever it changes. The query parameter being tracked is determined by
+     * `GlobalAutoRefreshName.GLOBAL_CONTEXT_AUTO_REFRESH`.
+     *
+     * @returns An observable that emits the parsed value of the `GLOBAL_CONTEXT_AUTO_REFRESH` query parameter.
+     */
+    getQueryParamChangeValue$() {
+        return this.activatedRoute.queryParams.pipe(map(params => params[GLOBAL_CONTEXT_AUTO_REFRESH]), map(this.parseGlobalAutoRefreshParam));
+    }
+    /**
+     * Monitors router navigation events and updates the navigation progress state.
+     *
+     * @returns An Observable that emits router events of types NavigationStart, NavigationEnd,
+     *          NavigationCancel, and NavigationError.
+     */
+    handleNavigationInProgress$() {
+        return this.router.events.pipe(filter(event => event instanceof NavigationStart ||
+            event instanceof NavigationEnd ||
+            event instanceof NavigationCancel ||
+            event instanceof NavigationError), tap(e => this.navigationInProgress.set(e instanceof NavigationStart)));
+    }
+    /**
+     * Sets the global auto-refresh query parameter in the current route.
+     *
+     * @param queryParams - An object representing the query parameters to set for the global auto-refresh option.
+     *                      The existing query parameters will be merged with these.
+     */
+    async setAutoRefreshQueryParam(queryParams) {
+        if (this.navigationInProgress()) {
+            return;
+        }
+        this.navigationInProgress.set(true);
+        await this.router.navigate([], {
+            relativeTo: this.activatedRoute,
+            queryParams,
+            queryParamsHandling: 'merge'
+        });
+        this.navigationInProgress.set(false);
+    }
+    /**
+     * Handles changes to the edit mode and updates the isEnabled$ variable.
+     *
+     * - If auto-refresh was manually disabled by the user (`userDisabledManually$` is `true`), auto-refresh will remain disabled regardless of the edit mode state.
+     * - If auto-refresh was not manually disabled, it will be disabled when entering edit mode and enabled when exiting edit mode.
+     *
+     * @param editMode - A boolean indicating the current state of edit mode (`true` if edit mode is active, `false` otherwise).
+     */
+    onEditModeChange(editMode) {
+        if (this.autoRefreshSettings.userDisabledManually$.getValue()) {
+            this.autoRefreshSettings.isEnabled$.next(false);
+            return;
+        }
+        this.autoRefreshSettings.isEnabled$.next(!editMode);
+    }
+    /**
+     * Returns an Observable that triggers the countdown reset action when loading completes.
+     *
+     * This method creates an Observable that:
+     * - Skips a specified number of initial emissions from `isLoadingWidgets$` based on the `skipInitialBehaviorSubjectEmission$` method.
+     * - Filters out emissions where the loading state is true.
+     * - On emission where the loading state is false, it triggers a countdown reset action.
+     *
+     */
+    resetCountdownOnLoadingComplete$() {
+        return switchMap(() => this.isLoadingWidgets$.pipe(tap(isLoading => isLoading && this.countdownActions.stop$.next()), filter(loading => !loading), tap(() => this.resetCountdown())));
+    }
+    /**
+     * Resets the service's settings and parameters to their default values.
+     */
+    resetServiceToDefaults() {
+        setTimeout(() => !this.navigationInProgress() && this.clearQueryParam());
+        this.autoRefreshSettings.refreshInterval$.next(DEFAULT_INTERVAL_VALUE);
+        this.autoRefreshSettings.userDisabledManually$.next(false);
+        setTimeout(() => {
+            this.autoRefreshSettings.isEnabled$.next(DEFAULT_INTERVAL_STATE);
+            this.resetLoadingToZero();
+            this.navigationInProgress.set(false);
+        });
+    }
+    /**
+     * Resets the countdown timer by emitting a reset action after a short delay.
+     */
+    resetCountdown() {
+        queueMicrotask(() => this.countdownActions.reset$.next());
+    }
+    /**
+     * Initializes the auto-refresh countdown logic based on the widget loading state and edit mode.
+     *
+     * This method returns an observable that monitors the widget loading state and triggers specific actions
+     * related to the countdown process. It performs the following steps:
+     *
+     * 1. Skips the initial loading state emitted by `isLoadingWidgets$`.
+     * 2. Stops the countdown if the widgets are currently loading.
+     * 3. Filters out cases where widgets are loading or the application is in edit mode.
+     * 4. Resets the countdown when widgets are not loading and the application is not in edit mode.
+     *
+     * @param editMode$ - A `BehaviorSubject` representing whether the application is currently in edit mode.
+     *
+     * @returns An `Observable<boolean>` that emits the loading state of the widgets after the initialization steps.
+     */
+    initializeAutoRefreshCountdownLoading$(editMode$) {
+        return this.isLoadingWidgets$.pipe(skip(1), tap(isLoading => isLoading && this.countdownActions.stop$.next()), filter(isWidgetsLoading => !isWidgetsLoading && !editMode$.getValue()), tap(() => this.resetCountdown()));
+    }
+    /**
+     * Parses a string representation of global auto-refresh parameter into a boolean or null.
+     *
+     * Converts the provided `globalAutoRefresh` string into a boolean value or null based on its content:
+     * - Returns `true` if `globalAutoRefresh` is 'true'.
+     * - Returns `false` if `globalAutoRefresh` is 'false'.
+     * - Returns `null` if `globalAutoRefresh` is neither 'true' nor 'false'.
+     *
+     * @param globalAutoRefresh - The string representation of the global auto-refresh parameter.
+     *
+     * @returns A boolean value corresponding to the parsed global auto-refresh state, or null if the input is not 'true' or 'false'.
+     */
+    parseGlobalAutoRefreshParam(globalAutoRefresh) {
+        return globalAutoRefresh === 'false' ? false : globalAutoRefresh === 'true' ? true : null;
+    }
+    /**
+     * Resets the loading count to zero.
+     */
+    resetLoadingToZero() {
+        this.loadingCount$.next(0);
+    }
+    /**
+     * Clears the global auto-refresh query parameter by navigating to the current route with the parameter set to null.
+     *
+     */
+    clearQueryParam() {
+        const queryParams = {
+            globalContextAutoRefresh: null
+        };
+        this.router.navigate([], {
+            relativeTo: this.activatedRoute,
+            queryParams,
+            queryParamsHandling: 'merge'
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: WidgetGlobalAutoRefreshService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: WidgetGlobalAutoRefreshService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: WidgetGlobalAutoRefreshService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-global-auto-refresh.service.js","sourceRoot":"","sources":["../../../../../core/dashboard/widget-auto-refresh-context/widget-global-auto-refresh.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable, signal } from '@angular/core';\nimport { BehaviorSubject, MonoTypeOperatorFunction, Observable, Subject } from 'rxjs';\nimport { distinctUntilChanged, filter, map, skip, switchMap, tap } from 'rxjs/operators';\nimport {\n  DEFAULT_INTERVAL_STATE,\n  DEFAULT_INTERVAL_VALUE,\n  GLOBAL_CONTEXT_AUTO_REFRESH,\n  GlobalAutoRefreshQueryParam\n} from './widget-auto-refresh-context.model';\nimport {\n  ActivatedRoute,\n  Event,\n  NavigationCancel,\n  NavigationEnd,\n  NavigationError,\n  NavigationStart,\n  Router\n} from '@angular/router';\n\n@Injectable({ providedIn: 'root' })\nexport class WidgetGlobalAutoRefreshService {\n  /**\n   * A BehaviorSubject that tracks the number of loading operations in progress.\n   * Initialized with a count of 0.\n   */\n  private loadingCount$ = new BehaviorSubject<number>(0);\n\n  /**\n   * An Observable that emits a boolean indicating whether any widgets with global refresh option are currently loading.\n   * The value is true if the loading count is non-zero, and false if the loading count is zero.\n   * Uses distinctUntilChanged() to emit only when the boolean value changes.\n   */\n  private isLoadingWidgets$: Observable<boolean> = this.loadingCount$.pipe(\n    distinctUntilChanged(),\n    map(count => count !== 0)\n  );\n\n  /**\n   * Object containing behavior subjects for managing auto-refresh settings.\n   */\n  autoRefreshSettings = {\n    /**\n     * BehaviorSubject that emits the current state of auto-refresh button.\n     * Defaults to DEFAULT_INTERVAL_STATE.\n     */\n    isEnabled$: new BehaviorSubject<boolean>(DEFAULT_INTERVAL_STATE),\n    /**\n     * BehaviorSubject that emits the current auto-refresh interval value.\n     * Defaults to DEFAULT_INTERVAL_VALUE.\n     */\n    refreshInterval$: new BehaviorSubject<number>(DEFAULT_INTERVAL_VALUE),\n    /**\n     * BehaviorSubject that emits whether auto-refresh has been manually disabled by the user.\n     * Defaults to false.\n     */\n    userDisabledManually$: new BehaviorSubject(false)\n  };\n\n  /**\n   * Object containing subjects for managing countdown actions.\n   */\n  countdownActions = {\n    /**\n     * Subject used to stop the countdown.\n     */\n    stop$: new Subject<void>(),\n    /**\n     * Subject used to reset the countdown.\n     */\n    reset$: new Subject<void>(),\n    /**\n     * Subject that emits when the countdown has ended.\n     */\n    countdownEnded$: new Subject<void>()\n  };\n\n  /**\n   * Subject that emits when a dashboard save operation is triggered.\n   */\n  onDashboardSave$ = new Subject<void>();\n\n  /**\n   * A signal representing the number of widgets with the global auto-refresh option enabled.\n   */\n  globalRefreshWidgetsCount = signal(0);\n\n  /**\n   * Tracks the navigation state.\n   *\n   * The signal returns a boolean indicating whether a navigation operation is currently in progress.\n   * It initializes with a default value of `false` and can be toggled to `true` during navigation events from `handleNavigationInProgress$`.\n   */\n  private navigationInProgress = signal(false);\n\n  private readonly router = inject(Router);\n  private readonly activatedRoute = inject(ActivatedRoute);\n\n  /**\n   * Increments the loading count by 1.\n   */\n  incrementLoading(): void {\n    this.loadingCount$.next(this.loadingCount$.value + 1);\n  }\n\n  /**\n   * Decrements the loading count by 1.\n   */\n  decrementLoading(): void {\n    this.loadingCount$.next(this.loadingCount$.value - 1);\n  }\n\n  /**\n   * Retrieves an observable that emits the value of a Global Auto Refresh query parameter\n   * whenever it changes. The query parameter being tracked is determined by\n   * `GlobalAutoRefreshName.GLOBAL_CONTEXT_AUTO_REFRESH`.\n   *\n   * @returns An observable that emits the parsed value of the `GLOBAL_CONTEXT_AUTO_REFRESH` query parameter.\n   */\n  getQueryParamChangeValue$(): Observable<boolean | null> {\n    return this.activatedRoute.queryParams.pipe(\n      map(params => params[GLOBAL_CONTEXT_AUTO_REFRESH]),\n      map(this.parseGlobalAutoRefreshParam)\n    );\n  }\n\n  /**\n   * Monitors router navigation events and updates the navigation progress state.\n   *\n   * @returns An Observable that emits router events of types NavigationStart, NavigationEnd,\n   *          NavigationCancel, and NavigationError.\n   */\n  handleNavigationInProgress$(): Observable<Event> {\n    return this.router.events.pipe(\n      filter(\n        event =>\n          event instanceof NavigationStart ||\n          event instanceof NavigationEnd ||\n          event instanceof NavigationCancel ||\n          event instanceof NavigationError\n      ),\n      tap(e => this.navigationInProgress.set(e instanceof NavigationStart))\n    );\n  }\n\n  /**\n   * Sets the global auto-refresh query parameter in the current route.\n   *\n   * @param queryParams - An object representing the query parameters to set for the global auto-refresh option.\n   *                      The existing query parameters will be merged with these.\n   */\n  async setAutoRefreshQueryParam(queryParams: GlobalAutoRefreshQueryParam): Promise<void> {\n    if (this.navigationInProgress()) {\n      return;\n    }\n\n    this.navigationInProgress.set(true);\n    await this.router.navigate([], {\n      relativeTo: this.activatedRoute,\n      queryParams,\n      queryParamsHandling: 'merge'\n    });\n    this.navigationInProgress.set(false);\n  }\n\n  /**\n   * Handles changes to the edit mode and updates the isEnabled$ variable.\n   *\n   * - If auto-refresh was manually disabled by the user (`userDisabledManually$` is `true`), auto-refresh will remain disabled regardless of the edit mode state.\n   * - If auto-refresh was not manually disabled, it will be disabled when entering edit mode and enabled when exiting edit mode.\n   *\n   * @param editMode - A boolean indicating the current state of edit mode (`true` if edit mode is active, `false` otherwise).\n   */\n  onEditModeChange(editMode: boolean): void {\n    if (this.autoRefreshSettings.userDisabledManually$.getValue()) {\n      this.autoRefreshSettings.isEnabled$.next(false);\n      return;\n    }\n    this.autoRefreshSettings.isEnabled$.next(!editMode);\n  }\n\n  /**\n   * Returns an Observable that triggers the countdown reset action when loading completes.\n   *\n   * This method creates an Observable that:\n   * - Skips a specified number of initial emissions from `isLoadingWidgets$` based on the `skipInitialBehaviorSubjectEmission$` method.\n   * - Filters out emissions where the loading state is true.\n   * - On emission where the loading state is false, it triggers a countdown reset action.\n   *\n   */\n  resetCountdownOnLoadingComplete$(): MonoTypeOperatorFunction<any> {\n    return switchMap(() =>\n      this.isLoadingWidgets$.pipe(\n        tap(isLoading => isLoading && this.countdownActions.stop$.next()),\n        filter(loading => !loading),\n        tap(() => this.resetCountdown())\n      )\n    );\n  }\n\n  /**\n   * Resets the service's settings and parameters to their default values.\n   */\n  resetServiceToDefaults(): void {\n    setTimeout(() => !this.navigationInProgress() && this.clearQueryParam());\n\n    this.autoRefreshSettings.refreshInterval$.next(DEFAULT_INTERVAL_VALUE);\n    this.autoRefreshSettings.userDisabledManually$.next(false);\n\n    setTimeout(() => {\n      this.autoRefreshSettings.isEnabled$.next(DEFAULT_INTERVAL_STATE);\n      this.resetLoadingToZero();\n      this.navigationInProgress.set(false);\n    });\n  }\n\n  /**\n   * Resets the countdown timer by emitting a reset action after a short delay.\n   */\n  resetCountdown(): void {\n    queueMicrotask(() => this.countdownActions.reset$.next());\n  }\n\n  /**\n   * Initializes the auto-refresh countdown logic based on the widget loading state and edit mode.\n   *\n   * This method returns an observable that monitors the widget loading state and triggers specific actions\n   * related to the countdown process. It performs the following steps:\n   *\n   * 1. Skips the initial loading state emitted by `isLoadingWidgets$`.\n   * 2. Stops the countdown if the widgets are currently loading.\n   * 3. Filters out cases where widgets are loading or the application is in edit mode.\n   * 4. Resets the countdown when widgets are not loading and the application is not in edit mode.\n   *\n   * @param editMode$ - A `BehaviorSubject` representing whether the application is currently in edit mode.\n   *\n   * @returns An `Observable<boolean>` that emits the loading state of the widgets after the initialization steps.\n   */\n  initializeAutoRefreshCountdownLoading$(editMode$: BehaviorSubject<boolean>): Observable<boolean> {\n    return this.isLoadingWidgets$.pipe(\n      skip(1),\n      tap(isLoading => isLoading && this.countdownActions.stop$.next()),\n      filter(isWidgetsLoading => !isWidgetsLoading && !editMode$.getValue()),\n      tap(() => this.resetCountdown())\n    );\n  }\n\n  /**\n   * Parses a string representation of global auto-refresh parameter into a boolean or null.\n   *\n   * Converts the provided `globalAutoRefresh` string into a boolean value or null based on its content:\n   * - Returns `true` if `globalAutoRefresh` is 'true'.\n   * - Returns `false` if `globalAutoRefresh` is 'false'.\n   * - Returns `null` if `globalAutoRefresh` is neither 'true' nor 'false'.\n   *\n   * @param globalAutoRefresh - The string representation of the global auto-refresh parameter.\n   *\n   * @returns A boolean value corresponding to the parsed global auto-refresh state, or null if the input is not 'true' or 'false'.\n   */\n  private parseGlobalAutoRefreshParam(globalAutoRefresh: string): boolean | null {\n    return globalAutoRefresh === 'false' ? false : globalAutoRefresh === 'true' ? true : null;\n  }\n\n  /**\n   * Resets the loading count to zero.\n   */\n  private resetLoadingToZero(): void {\n    this.loadingCount$.next(0);\n  }\n\n  /**\n   * Clears the global auto-refresh query parameter by navigating to the current route with the parameter set to null.\n   *\n   */\n  private clearQueryParam(): void {\n    const queryParams: GlobalAutoRefreshQueryParam = {\n      globalContextAutoRefresh: null\n    };\n\n    this.router.navigate([], {\n      relativeTo: this.activatedRoute,\n      queryParams,\n      queryParamsHandling: 'merge'\n    });\n  }\n}\n"]}