@c8y/ngx-components 1021.11.1 → 1021.21.0

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

@@ -0,0 +1,127 @@
+import { Component, inject, Input } from '@angular/core';
+import { FormBuilder } from '@angular/forms';
+import { filter, takeUntil, tap } from 'rxjs/operators';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { GLOBAL_CONTEXT_AUTO_REFRESH } from './widget-auto-refresh-context.model';
+import { WidgetGlobalAutoRefreshService } from './widget-global-auto-refresh.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../common/icon.directive";
+import * as i2 from "@angular/common";
+import * as i3 from "../../action-bar/action-bar-item.component";
+import * as i4 from "ngx-bootstrap/tooltip";
+import * as i5 from "@angular/forms";
+import * as i6 from "./auto-refresh-control.component";
+import * as i7 from "./auto-refresh-select-control.component";
+import * as i8 from "@ngx-translate/core";
+export class WidgetAutoRefreshContextComponent {
+    constructor() {
+        this.globalRefreshWidgetLoading = true;
+        this.ACTION_BAR_GROUP_ID = 'globalrefreshcontext';
+        this.ACTION_BAR_PRIORITY = 5;
+        this.destroy$ = new Subject();
+        this.fb = inject(FormBuilder);
+        this.widgetGlobalAutoRefresh = inject(WidgetGlobalAutoRefreshService);
+    }
+    ngOnInit() {
+        this.widgetGlobalAutoRefresh.globalRefreshWidgetsCount.update(count => count + 1);
+        this.form = this.createForm();
+        this.subscribeOnAutoRefreshSecondsChange();
+        this.subscribeOnAutoRefreshChange();
+        this.subscribeOnRouterEvents();
+    }
+    ngAfterViewInit() {
+        this.initializeWidgetSubscriptions();
+        this.subscribeOnQueryParamChange();
+        this.widgetGlobalAutoRefresh.autoRefreshSettings.isEnabled$
+            .pipe(tap(() => this.setAutoRefreshQueryParam()))
+            .pipe(takeUntil(this.destroy$))
+            .subscribe();
+        this.widgetGlobalAutoRefresh
+            .initializeAutoRefreshCountdownLoading$(this.editMode$)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe();
+        this.listenOnDashboardSaveOperation();
+    }
+    ngOnDestroy() {
+        this.onContextDestroy();
+    }
+    onRefresh() {
+        this.widgetGlobalAutoRefresh.countdownActions.countdownEnded$.next();
+    }
+    createForm() {
+        return this.fb.group({
+            autoRefresh: this.widgetGlobalAutoRefresh.autoRefreshSettings.isEnabled$.getValue(),
+            autoRefreshSeconds: this.widgetGlobalAutoRefresh.autoRefreshSettings.refreshInterval$.getValue()
+        });
+    }
+    subscribeOnAutoRefreshSecondsChange() {
+        const autoRefreshSecondsChanges$ = this.form.controls.autoRefreshSeconds.valueChanges;
+        autoRefreshSecondsChanges$
+            .pipe(tap(value => this.widgetGlobalAutoRefresh.autoRefreshSettings.refreshInterval$.next(value)), this.widgetGlobalAutoRefresh.resetCountdownOnLoadingComplete$(), takeUntil(this.destroy$))
+            .subscribe();
+    }
+    subscribeOnAutoRefreshChange() {
+        const autoRefreshChanges$ = this.form.controls.autoRefresh.valueChanges;
+        autoRefreshChanges$
+            .pipe(tap(value => this.widgetGlobalAutoRefresh.autoRefreshSettings.isEnabled$.next(value)), filter(Boolean), this.widgetGlobalAutoRefresh.resetCountdownOnLoadingComplete$(), takeUntil(this.destroy$))
+            .subscribe();
+    }
+    initializeWidgetSubscriptions() {
+        this.editMode$
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(editMode => this.widgetGlobalAutoRefresh.onEditModeChange(editMode));
+    }
+    setAutoRefreshQueryParam() {
+        queueMicrotask(() => {
+            if (this.widgetGlobalAutoRefresh.globalRefreshWidgetsCount() === 0) {
+                return;
+            }
+            const queryParam = {
+                [GLOBAL_CONTEXT_AUTO_REFRESH]: this.widgetGlobalAutoRefresh.autoRefreshSettings.isEnabled$.getValue()
+            };
+            this.widgetGlobalAutoRefresh.setAutoRefreshQueryParam(queryParam);
+        });
+    }
+    subscribeOnQueryParamChange() {
+        this.widgetGlobalAutoRefresh
+            .getQueryParamChangeValue$()
+            .pipe(tap(paramValue => paramValue === null && this.setAutoRefreshQueryParam()), filter(paramValue => paramValue !== null &&
+            this.widgetGlobalAutoRefresh.autoRefreshSettings.isEnabled$.getValue() !== paramValue), tap(paramValue => {
+            this.widgetGlobalAutoRefresh.autoRefreshSettings.isEnabled$.next(paramValue);
+            this.setAutoRefreshQueryParam();
+            if (paramValue) {
+                this.widgetGlobalAutoRefresh.resetCountdown();
+            }
+        }), takeUntil(this.destroy$))
+            .subscribe();
+    }
+    subscribeOnRouterEvents() {
+        this.widgetGlobalAutoRefresh
+            .handleNavigationInProgress$()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe();
+    }
+    onContextDestroy() {
+        const widgetsCount = this.widgetGlobalAutoRefresh.globalRefreshWidgetsCount;
+        widgetsCount.update(count => count - 1);
+        if (widgetsCount() === 0) {
+            this.destroy$.next();
+            this.destroy$.complete();
+            this.widgetGlobalAutoRefresh.resetServiceToDefaults();
+        }
+    }
+    listenOnDashboardSaveOperation() {
+        this.widgetGlobalAutoRefresh.onDashboardSave$
+            .pipe(this.widgetGlobalAutoRefresh.resetCountdownOnLoadingComplete$(), takeUntil(this.destroy$))
+            .subscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: WidgetAutoRefreshContextComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: WidgetAutoRefreshContextComponent, selector: "c8y-widget-auto-refresh-context", inputs: { editMode$: "editMode$" }, ngImport: i0, template: "<c8y-action-bar-item\n  [groupId]=\"ACTION_BAR_GROUP_ID\"\n  [priority]=\"ACTION_BAR_PRIORITY\"\n  [placement]=\"'left'\"\n>\n  <form\n    class=\"d-flex\"\n    [formGroup]=\"form\"\n  >\n    <c8y-auto-refresh-control\n      [hidden]=\"editMode$ | async\"\n      (loading)=\"globalRefreshWidgetLoading = $event\"\n      formControlName=\"autoRefresh\"\n    ></c8y-auto-refresh-control>\n\n    <c8y-auto-refresh-select-control\n      [hidden]=\"editMode$ | async\"\n      formControlName=\"autoRefreshSeconds\"\n    ></c8y-auto-refresh-select-control>\n  </form>\n  <div class=\"input-group-btn\">\n    <button\n      class=\"btn btn-default\"\n      style=\"border-left: 0\"\n      [attr.aria-label]=\"'Refresh' | translate\"\n      [tooltip]=\"'Refresh' | translate\"\n      placement=\"bottom\"\n      type=\"button\"\n      *ngIf=\"!(editMode$ | async)\"\n      [adaptivePosition]=\"false\"\n      [delay]=\"500\"\n      [disabled]=\"globalRefreshWidgetLoading\"\n      (click)=\"onRefresh()\"\n    >\n      <i\n        c8yIcon=\"refresh\"\n        [ngClass]=\"{ 'icon-spin': globalRefreshWidgetLoading }\"\n      ></i>\n    </button>\n  </div>\n</c8y-action-bar-item>\n", dependencies: [{ kind: "directive", type: i1.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.ActionBarItemComponent, selector: "c8y-action-bar-item", inputs: ["placement", "priority", "itemClass", "injector", "groupId", "inGroupPriority"] }, { kind: "directive", type: i4.TooltipDirective, selector: "[tooltip], [tooltipHtml]", inputs: ["adaptivePosition", "tooltip", "placement", "triggers", "container", "containerClass", "boundariesElement", "isOpen", "isDisabled", "delay", "tooltipHtml", "tooltipPlacement", "tooltipIsOpen", "tooltipEnable", "tooltipAppendToBody", "tooltipAnimation", "tooltipClass", "tooltipContext", "tooltipPopupDelay", "tooltipFadeDuration", "tooltipTrigger"], outputs: ["tooltipChange", "onShown", "onHidden", "tooltipStateChanged"], exportAs: ["bs-tooltip"] }, { kind: "directive", type: i5.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i5.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i5.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i5.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i6.AutoRefreshControlComponent, selector: "c8y-auto-refresh-control", outputs: ["loading"] }, { kind: "component", type: i7.AutoRefreshSelectControlComponent, selector: "c8y-auto-refresh-select-control" }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i8.TranslatePipe, name: "translate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: WidgetAutoRefreshContextComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c8y-widget-auto-refresh-context', template: "<c8y-action-bar-item\n  [groupId]=\"ACTION_BAR_GROUP_ID\"\n  [priority]=\"ACTION_BAR_PRIORITY\"\n  [placement]=\"'left'\"\n>\n  <form\n    class=\"d-flex\"\n    [formGroup]=\"form\"\n  >\n    <c8y-auto-refresh-control\n      [hidden]=\"editMode$ | async\"\n      (loading)=\"globalRefreshWidgetLoading = $event\"\n      formControlName=\"autoRefresh\"\n    ></c8y-auto-refresh-control>\n\n    <c8y-auto-refresh-select-control\n      [hidden]=\"editMode$ | async\"\n      formControlName=\"autoRefreshSeconds\"\n    ></c8y-auto-refresh-select-control>\n  </form>\n  <div class=\"input-group-btn\">\n    <button\n      class=\"btn btn-default\"\n      style=\"border-left: 0\"\n      [attr.aria-label]=\"'Refresh' | translate\"\n      [tooltip]=\"'Refresh' | translate\"\n      placement=\"bottom\"\n      type=\"button\"\n      *ngIf=\"!(editMode$ | async)\"\n      [adaptivePosition]=\"false\"\n      [delay]=\"500\"\n      [disabled]=\"globalRefreshWidgetLoading\"\n      (click)=\"onRefresh()\"\n    >\n      <i\n        c8yIcon=\"refresh\"\n        [ngClass]=\"{ 'icon-spin': globalRefreshWidgetLoading }\"\n      ></i>\n    </button>\n  </div>\n</c8y-action-bar-item>\n" }]
+        }], propDecorators: { editMode$: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-auto-refresh-context.component.js","sourceRoot":"","sources":["../../../../../core/dashboard/widget-auto-refresh-context/widget-auto-refresh-context.component.ts","../../../../../core/dashboard/widget-auto-refresh-context/widget-auto-refresh-context.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, inject, Input, OnDestroy, OnInit } from '@angular/core';\nimport { FormBuilder } from '@angular/forms';\nimport { filter, takeUntil, tap } from 'rxjs/operators';\nimport { BehaviorSubject, Subject } from 'rxjs';\nimport {\n  GLOBAL_CONTEXT_AUTO_REFRESH,\n  GlobalAutoRefreshQueryParam\n} from './widget-auto-refresh-context.model';\nimport { WidgetGlobalAutoRefreshService } from './widget-global-auto-refresh.service';\n\n@Component({\n  selector: 'c8y-widget-auto-refresh-context',\n  templateUrl: './widget-auto-refresh-context.component.html'\n})\nexport class WidgetAutoRefreshContextComponent implements OnInit, OnDestroy, AfterViewInit {\n  form: ReturnType<WidgetAutoRefreshContextComponent['createForm']>;\n\n  @Input()\n  editMode$: BehaviorSubject<boolean>;\n\n  globalRefreshWidgetLoading = true;\n  readonly ACTION_BAR_GROUP_ID = 'globalrefreshcontext';\n  readonly ACTION_BAR_PRIORITY = 5;\n\n  private destroy$: Subject<void> = new Subject();\n\n  private readonly fb = inject(FormBuilder);\n  private readonly widgetGlobalAutoRefresh = inject(WidgetGlobalAutoRefreshService);\n\n  ngOnInit() {\n    this.widgetGlobalAutoRefresh.globalRefreshWidgetsCount.update(count => count + 1);\n\n    this.form = this.createForm();\n\n    this.subscribeOnAutoRefreshSecondsChange();\n    this.subscribeOnAutoRefreshChange();\n    this.subscribeOnRouterEvents();\n  }\n\n  ngAfterViewInit() {\n    this.initializeWidgetSubscriptions();\n    this.subscribeOnQueryParamChange();\n\n    this.widgetGlobalAutoRefresh.autoRefreshSettings.isEnabled$\n      .pipe(tap(() => this.setAutoRefreshQueryParam()))\n      .pipe(takeUntil(this.destroy$))\n      .subscribe();\n\n    this.widgetGlobalAutoRefresh\n      .initializeAutoRefreshCountdownLoading$(this.editMode$)\n      .pipe(takeUntil(this.destroy$))\n      .subscribe();\n\n    this.listenOnDashboardSaveOperation();\n  }\n\n  ngOnDestroy() {\n    this.onContextDestroy();\n  }\n\n  onRefresh() {\n    this.widgetGlobalAutoRefresh.countdownActions.countdownEnded$.next();\n  }\n\n  private createForm() {\n    return this.fb.group({\n      autoRefresh: this.widgetGlobalAutoRefresh.autoRefreshSettings.isEnabled$.getValue(),\n      autoRefreshSeconds:\n        this.widgetGlobalAutoRefresh.autoRefreshSettings.refreshInterval$.getValue()\n    });\n  }\n\n  private subscribeOnAutoRefreshSecondsChange() {\n    const autoRefreshSecondsChanges$ = this.form.controls.autoRefreshSeconds.valueChanges;\n\n    autoRefreshSecondsChanges$\n      .pipe(\n        tap(value => this.widgetGlobalAutoRefresh.autoRefreshSettings.refreshInterval$.next(value)),\n        this.widgetGlobalAutoRefresh.resetCountdownOnLoadingComplete$(),\n        takeUntil(this.destroy$)\n      )\n      .subscribe();\n  }\n\n  private subscribeOnAutoRefreshChange() {\n    const autoRefreshChanges$ = this.form.controls.autoRefresh.valueChanges;\n\n    autoRefreshChanges$\n      .pipe(\n        tap(value => this.widgetGlobalAutoRefresh.autoRefreshSettings.isEnabled$.next(value)),\n        filter(Boolean),\n        this.widgetGlobalAutoRefresh.resetCountdownOnLoadingComplete$(),\n        takeUntil(this.destroy$)\n      )\n      .subscribe();\n  }\n\n  private initializeWidgetSubscriptions() {\n    this.editMode$\n      .pipe(takeUntil(this.destroy$))\n      .subscribe(editMode => this.widgetGlobalAutoRefresh.onEditModeChange(editMode));\n  }\n\n  private setAutoRefreshQueryParam() {\n    queueMicrotask(() => {\n      if (this.widgetGlobalAutoRefresh.globalRefreshWidgetsCount() === 0) {\n        return;\n      }\n      const queryParam: GlobalAutoRefreshQueryParam = {\n        [GLOBAL_CONTEXT_AUTO_REFRESH]:\n          this.widgetGlobalAutoRefresh.autoRefreshSettings.isEnabled$.getValue()\n      };\n      this.widgetGlobalAutoRefresh.setAutoRefreshQueryParam(queryParam);\n    });\n  }\n\n  private subscribeOnQueryParamChange() {\n    this.widgetGlobalAutoRefresh\n      .getQueryParamChangeValue$()\n      .pipe(\n        tap(paramValue => paramValue === null && this.setAutoRefreshQueryParam()),\n        filter(\n          paramValue =>\n            paramValue !== null &&\n            this.widgetGlobalAutoRefresh.autoRefreshSettings.isEnabled$.getValue() !== paramValue\n        ),\n        tap(paramValue => {\n          this.widgetGlobalAutoRefresh.autoRefreshSettings.isEnabled$.next(paramValue);\n          this.setAutoRefreshQueryParam();\n          if (paramValue) {\n            this.widgetGlobalAutoRefresh.resetCountdown();\n          }\n        }),\n        takeUntil(this.destroy$)\n      )\n      .subscribe();\n  }\n\n  private subscribeOnRouterEvents() {\n    this.widgetGlobalAutoRefresh\n      .handleNavigationInProgress$()\n      .pipe(takeUntil(this.destroy$))\n      .subscribe();\n  }\n\n  private onContextDestroy() {\n    const widgetsCount = this.widgetGlobalAutoRefresh.globalRefreshWidgetsCount;\n    widgetsCount.update(count => count - 1);\n\n    if (widgetsCount() === 0) {\n      this.destroy$.next();\n      this.destroy$.complete();\n\n      this.widgetGlobalAutoRefresh.resetServiceToDefaults();\n    }\n  }\n\n  private listenOnDashboardSaveOperation() {\n    this.widgetGlobalAutoRefresh.onDashboardSave$\n      .pipe(\n        this.widgetGlobalAutoRefresh.resetCountdownOnLoadingComplete$(),\n        takeUntil(this.destroy$)\n      )\n      .subscribe();\n  }\n}\n","<c8y-action-bar-item\n  [groupId]=\"ACTION_BAR_GROUP_ID\"\n  [priority]=\"ACTION_BAR_PRIORITY\"\n  [placement]=\"'left'\"\n>\n  <form\n    class=\"d-flex\"\n    [formGroup]=\"form\"\n  >\n    <c8y-auto-refresh-control\n      [hidden]=\"editMode$ | async\"\n      (loading)=\"globalRefreshWidgetLoading = $event\"\n      formControlName=\"autoRefresh\"\n    ></c8y-auto-refresh-control>\n\n    <c8y-auto-refresh-select-control\n      [hidden]=\"editMode$ | async\"\n      formControlName=\"autoRefreshSeconds\"\n    ></c8y-auto-refresh-select-control>\n  </form>\n  <div class=\"input-group-btn\">\n    <button\n      class=\"btn btn-default\"\n      style=\"border-left: 0\"\n      [attr.aria-label]=\"'Refresh' | translate\"\n      [tooltip]=\"'Refresh' | translate\"\n      placement=\"bottom\"\n      type=\"button\"\n      *ngIf=\"!(editMode$ | async)\"\n      [adaptivePosition]=\"false\"\n      [delay]=\"500\"\n      [disabled]=\"globalRefreshWidgetLoading\"\n      (click)=\"onRefresh()\"\n    >\n      <i\n        c8yIcon=\"refresh\"\n        [ngClass]=\"{ 'icon-spin': globalRefreshWidgetLoading }\"\n      ></i>\n    </button>\n  </div>\n</c8y-action-bar-item>\n"]}

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

@@ -0,0 +1,5 @@
+export const DEFAULT_INTERVAL_VALUE = 30_000;
+export const DEFAULT_INTERVAL_VALUES = [5_000, 10_000, 15_000, 30_000, 60_000];
+export const DEFAULT_INTERVAL_STATE = true;
+export const GLOBAL_CONTEXT_AUTO_REFRESH = 'globalContextAutoRefresh';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2lkZ2V0LWF1dG8tcmVmcmVzaC1jb250ZXh0Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vY29yZS9kYXNoYm9hcmQvd2lkZ2V0LWF1dG8tcmVmcmVzaC1jb250ZXh0L3dpZGdldC1hdXRvLXJlZnJlc2gtY29udGV4dC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxNQUFNLENBQUM7QUFDN0MsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsQ0FBQyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFDL0UsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsSUFBSSxDQUFDO0FBRTNDLE1BQU0sQ0FBQyxNQUFNLDJCQUEyQixHQUFHLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IERFRkFVTFRfSU5URVJWQUxfVkFMVUUgPSAzMF8wMDA7XG5leHBvcnQgY29uc3QgREVGQVVMVF9JTlRFUlZBTF9WQUxVRVMgPSBbNV8wMDAsIDEwXzAwMCwgMTVfMDAwLCAzMF8wMDAsIDYwXzAwMF07XG5leHBvcnQgY29uc3QgREVGQVVMVF9JTlRFUlZBTF9TVEFURSA9IHRydWU7XG5cbmV4cG9ydCBjb25zdCBHTE9CQUxfQ09OVEVYVF9BVVRPX1JFRlJFU0ggPSAnZ2xvYmFsQ29udGV4dEF1dG9SZWZyZXNoJztcbmV4cG9ydCB0eXBlIEdsb2JhbEF1dG9SZWZyZXNoUXVlcnlQYXJhbSA9IHtcbiAgW0dMT0JBTF9DT05URVhUX0FVVE9fUkVGUkVTSF06IGJvb2xlYW47XG59O1xuXG5leHBvcnQgaW50ZXJmYWNlIEdsb2JhbEF1dG9SZWZyZXNoV2lkZ2V0Q29uZmlnIHtcbiAgLyoqXG4gICAqIEluZGljYXRlcyBpZiBpbnN0YW5jZSBvZiB3aWRnZXQgaXMgYm91bmQgdG8gZ2xvYmFsIGF1dG8gcmVmcmVzaCBjb250ZXh0LiBJdCBjYW4gYmUgb25seSB1c2VkIHdpdGggd2lkZ2V0cyB3aGljaFxuICAgKiBkeW5hbWljIGNvbXBvbmVudCBkZWZpbml0aW9uIGNvbnRhaW5zIGRpc3BsYXlTZXR0aW5ncyBhbGxvd2luZyB0byB1c2UgaXQgd2l0aCBnbG9iYWwgYXV0byByZWZyZXNoIGNvbnRleHQuXG4gICAqL1xuICB3aWRnZXRJbnN0YW5jZUdsb2JhbEF1dG9SZWZyZXNoQ29udGV4dD86IGJvb2xlYW47XG59XG4iXX0=

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"]}

package/esm2022/core/dashboard/widget-change-event.model.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2lkZ2V0LWNoYW5nZS1ldmVudC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2NvcmUvZGFzaGJvYXJkL3dpZGdldC1jaGFuZ2UtZXZlbnQubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEludGVydmFsIH0gZnJvbSAnLi93aWdldC10aW1lLWNvbnRleHQvd2lkZ2V0LXRpbWUtY29udGV4dC5tb2RlbCc7XG5pbXBvcnQgeyBhZ2dyZWdhdGlvblR5cGUgfSBmcm9tICdAYzh5L2NsaWVudCc7XG5cbi8qKlxuICogVHlwZSBmb3IgZGVzY3JpYmluZyB3aWRnZXQgY2hhbmdlIGV2ZW50cy4gSXQncyBwb3NzaWJsZVxuICogdG8gZXh0ZW5kIHRoaXMgYnkgYWRkaW5nIGFkZGl0aW9uYWwgZXZlbnRzIHRvIGRpc2NyaW1pbmF0ZWQgdW5pb24gdHlwZS5cbiAqL1xuZXhwb3J0IHR5cGUgV2lkZ2V0Q2hhbmdlRXZlbnQgPSBUaW1lQ29udGV4dEV2ZW50O1xuXG5leHBvcnQgaW50ZXJmYWNlIFRpbWVDb250ZXh0RXZlbnQge1xuICB0eXBlOiAnVElNRV9DT05URVhUJztcbiAgZGF0YTogV2lkZ2V0VGltZUNvbnRleHQ7XG59XG5cbmV4cG9ydCB0eXBlIFdpZGdldENoYW5nZUV2ZW50VHlwZSA9IFdpZGdldENoYW5nZUV2ZW50Wyd0eXBlJ107XG5cbmV4cG9ydCB0eXBlIFJldmVydENoYW5nZVR5cGUgPSAndW5kbycgfCAncmVkbyc7XG5cbmV4cG9ydCB0eXBlIERhdGVUaW1lQ29udGV4dCA9IFtEYXRlLCBEYXRlXTtcblxuZXhwb3J0IHR5cGUgV2lkZ2V0VGltZUNvbnRleHQgPVxuICB8ICh7IGRhdGVUaW1lQ29udGV4dDogRGF0ZVRpbWVDb250ZXh0OyByZWFsdGltZTogYm9vbGVhbjsgYWdncmVnYXRpb246IGFnZ3JlZ2F0aW9uVHlwZSB9ICYge1xuICAgICAgaW50ZXJ2YWw/OiBuZXZlcjtcbiAgICB9KVxuICB8ICh7IGRhdGVUaW1lQ29udGV4dD86IG5ldmVyIH0gJiB7XG4gICAgICBpbnRlcnZhbDogSW50ZXJ2YWxbJ2lkJ107XG4gICAgICByZWFsdGltZTogYm9vbGVhbjtcbiAgICAgIGFnZ3JlZ2F0aW9uOiBhZ2dyZWdhdGlvblR5cGU7XG4gICAgfSk7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2lkZ2V0LWNoYW5nZS1ldmVudC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2NvcmUvZGFzaGJvYXJkL3dpZGdldC1jaGFuZ2UtZXZlbnQubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGFnZ3JlZ2F0aW9uVHlwZSB9IGZyb20gJ0BjOHkvY2xpZW50JztcbmltcG9ydCB7IEludGVydmFsIH0gZnJvbSAnQGM4eS9uZ3gtY29tcG9uZW50cy9pbnRlcnZhbC1waWNrZXInO1xuXG4vKipcbiAqIFR5cGUgZm9yIGRlc2NyaWJpbmcgd2lkZ2V0IGNoYW5nZSBldmVudHMuIEl0J3MgcG9zc2libGVcbiAqIHRvIGV4dGVuZCB0aGlzIGJ5IGFkZGluZyBhZGRpdGlvbmFsIGV2ZW50cyB0byBkaXNjcmltaW5hdGVkIHVuaW9uIHR5cGUuXG4gKi9cbmV4cG9ydCB0eXBlIFdpZGdldENoYW5nZUV2ZW50ID0gVGltZUNvbnRleHRFdmVudDtcblxuZXhwb3J0IGludGVyZmFjZSBUaW1lQ29udGV4dEV2ZW50IHtcbiAgdHlwZTogJ1RJTUVfQ09OVEVYVCc7XG4gIGRhdGE6IFdpZGdldFRpbWVDb250ZXh0O1xufVxuXG5leHBvcnQgdHlwZSBXaWRnZXRDaGFuZ2VFdmVudFR5cGUgPSBXaWRnZXRDaGFuZ2VFdmVudFsndHlwZSddO1xuXG5leHBvcnQgdHlwZSBSZXZlcnRDaGFuZ2VUeXBlID0gJ3VuZG8nIHwgJ3JlZG8nO1xuXG5leHBvcnQgdHlwZSBEYXRlVGltZUNvbnRleHQgPSBbRGF0ZSwgRGF0ZV07XG5cbmV4cG9ydCB0eXBlIFdpZGdldFRpbWVDb250ZXh0ID1cbiAgfCAoeyBkYXRlVGltZUNvbnRleHQ6IERhdGVUaW1lQ29udGV4dDsgcmVhbHRpbWU6IGJvb2xlYW47IGFnZ3JlZ2F0aW9uOiBhZ2dyZWdhdGlvblR5cGUgfSAmIHtcbiAgICAgIGludGVydmFsPzogbmV2ZXI7XG4gICAgfSlcbiAgfCAoeyBkYXRlVGltZUNvbnRleHQ/OiBuZXZlciB9ICYge1xuICAgICAgaW50ZXJ2YWw6IEludGVydmFsWydpZCddO1xuICAgICAgcmVhbHRpbWU6IGJvb2xlYW47XG4gICAgICBhZ2dyZWdhdGlvbjogYWdncmVnYXRpb25UeXBlO1xuICAgIH0pO1xuIl19