@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/async-data/page-state/component.mjs

@@ -0,0 +1,129 @@
+/**
+ * @packageDocumentation
+ * @module async-data
+ */
+import { handlePixel } from '@alauda/ui';
+import { AsyncPipe, NgIf, NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChild, EventEmitter, Input, Output, TemplateRef, } from '@angular/core';
+import { combineLatest, merge, filter, map, mapTo } from 'rxjs';
+import { publishRef } from '../../core/public-api';
+import { LoadingMaskComponent } from '../../widget/loading-mask/loading-mask.component';
+import { ErrorStateComponent } from '../error-page/component';
+import * as i0 from "@angular/core";
+function PageStateComponent_ng_container_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementContainer(1, 2);
+    i0.ɵɵpipe(2, "async");
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngTemplateOutlet", ctx_r0.template)("ngTemplateOutletContext", i0.ɵɵpipeBind1(2, 2, ctx_r0.context$));
+} }
+function PageStateComponent_div_2_ng_container_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelement(1, "acl-loading-mask", 4);
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("loading", true);
+} }
+function PageStateComponent_div_2_ng_container_3_Template(rf, ctx) { if (rf & 1) {
+    const _r5 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "acl-error-state", 5);
+    i0.ɵɵlistener("reload", function PageStateComponent_div_2_ng_container_3_Template_acl_error_state_reload_1_listener() { i0.ɵɵrestoreView(_r5); const ctx_r4 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r4.adapter.reload()); })("redirect", function PageStateComponent_div_2_ng_container_3_Template_acl_error_state_redirect_1_listener() { i0.ɵɵrestoreView(_r5); const ctx_r6 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r6.redirect.emit()); });
+    i0.ɵɵpipe(2, "async");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r3 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("errorCode", i0.ɵɵpipeBind1(2, 4, ctx_r3.errorCode$))("autoRedirect", ctx_r3.autoRedirect)("showBackButton", ctx_r3.showBackButton)("backLink", ctx_r3.backLink);
+} }
+function PageStateComponent_div_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 3);
+    i0.ɵɵtemplate(1, PageStateComponent_div_2_ng_container_1_Template, 2, 1, "ng-container", 0);
+    i0.ɵɵpipe(2, "async");
+    i0.ɵɵtemplate(3, PageStateComponent_div_2_ng_container_3_Template, 3, 6, "ng-container", 0);
+    i0.ɵɵpipe(4, "async");
+    i0.ɵɵpipe(5, "async");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵstyleProp("margin-top", ctx_r1.marginTop);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(2, 4, ctx_r1.adapter.loading$));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngIf", !i0.ɵɵpipeBind1(4, 6, ctx_r1.adapter.loading$) && !!i0.ɵɵpipeBind1(5, 8, ctx_r1.errorCode$));
+} }
+export class PageStateComponent {
+    constructor() {
+        this.autoRedirect = true;
+        this.showBackButton = true;
+        this.redirect = new EventEmitter();
+    }
+    set top(top) {
+        this.marginTop = handlePixel(top ?? 120);
+    }
+    ngOnInit() {
+        this.context$ = this.adapter.rawData$.pipe(map(data => ({ $implicit: data, ...data })), publishRef());
+        this.errorCode$ = merge(combineLatest([this.adapter.rawData$, this.adapter.loading$]).pipe(filter(([data, loading]) => !data && !loading), mapTo(404)), this.adapter.error$.pipe(filter(error => !!error), map(error => {
+            if (error.code && typeof error.code === 'number') {
+                return error.code;
+            }
+            if (error.status && typeof error.status === 'number') {
+                return error.status;
+            }
+            return 1;
+        }))).pipe(publishRef());
+    }
+    static { this.ɵfac = function PageStateComponent_Factory(t) { return new (t || PageStateComponent)(); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PageStateComponent, selectors: [["acl-page-state"]], contentQueries: function PageStateComponent_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+            i0.ɵɵcontentQuery(dirIndex, TemplateRef, 7);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.template = _t.first);
+        } }, inputs: { adapter: "adapter", autoRedirect: "autoRedirect", showBackButton: "showBackButton", backLink: "backLink", top: "top" }, outputs: { redirect: "redirect" }, standalone: true, features: [i0.ɵɵStandaloneFeature], decls: 4, vars: 6, consts: [[4, "ngIf"], ["class", "acl-data-state", 3, "marginTop", 4, "ngIf"], [3, "ngTemplateOutlet", "ngTemplateOutletContext"], [1, "acl-data-state"], ["type", "module", 3, "loading"], [3, "errorCode", "autoRedirect", "showBackButton", "backLink", "reload", "redirect"]], template: function PageStateComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, PageStateComponent_ng_container_0_Template, 3, 4, "ng-container", 0);
+            i0.ɵɵpipe(1, "async");
+            i0.ɵɵtemplate(2, PageStateComponent_div_2_Template, 6, 10, "div", 1);
+            i0.ɵɵpipe(3, "async");
+        } if (rf & 2) {
+            let tmp_0_0;
+            let tmp_1_0;
+            i0.ɵɵproperty("ngIf", (tmp_0_0 = i0.ɵɵpipeBind1(1, 2, ctx.context$)) == null ? null : tmp_0_0.$implicit);
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", !((tmp_1_0 = i0.ɵɵpipeBind1(3, 4, ctx.context$)) == null ? null : tmp_1_0.$implicit));
+        } }, dependencies: [NgTemplateOutlet,
+            NgIf,
+            LoadingMaskComponent,
+            AsyncPipe,
+            ErrorStateComponent], encapsulation: 2, changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PageStateComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-page-state', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                    NgTemplateOutlet,
+                    NgIf,
+                    LoadingMaskComponent,
+                    AsyncPipe,
+                    ErrorStateComponent,
+                ], template: "<ng-container *ngIf=\"(context$ | async)?.$implicit\">\n  <ng-container\n    [ngTemplateOutlet]=\"template\"\n    [ngTemplateOutletContext]=\"context$ | async\"\n  ></ng-container>\n</ng-container>\n\n<div\n  *ngIf=\"!(context$ | async)?.$implicit\"\n  class=\"acl-data-state\"\n  [style.marginTop]=\"marginTop\"\n>\n  <ng-container *ngIf=\"adapter.loading$ | async\">\n    <acl-loading-mask\n      [loading]=\"true\"\n      type=\"module\"\n    ></acl-loading-mask>\n  </ng-container>\n  <ng-container *ngIf=\"!(adapter.loading$ | async) && !!(errorCode$ | async)\">\n    <acl-error-state\n      [errorCode]=\"errorCode$ | async\"\n      [autoRedirect]=\"autoRedirect\"\n      [showBackButton]=\"showBackButton\"\n      [backLink]=\"backLink\"\n      (reload)=\"adapter.reload()\"\n      (redirect)=\"redirect.emit()\"\n    ></acl-error-state>\n  </ng-container>\n</div>\n" }]
+    }], null, { adapter: [{
+            type: Input
+        }], autoRedirect: [{
+            type: Input
+        }], showBackButton: [{
+            type: Input
+        }], backLink: [{
+            type: Input
+        }], top: [{
+            type: Input
+        }], redirect: [{
+            type: Output
+        }], template: [{
+            type: ContentChild,
+            args: [TemplateRef, { static: true }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/async-data/public-api.mjs

@@ -0,0 +1,12 @@
+/**
+ * [[include:async-data/README.md]]
+ * @module async-data
+ * @preferred
+ */
+/** imports */
+export * from './async-data.module';
+export * from './async-data-loader';
+export * from './page-state/component';
+export * from './types';
+export { ErrorStateComponent } from './error-page/component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9hc3luYy1kYXRhL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILGNBQWM7QUFDZCxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLFNBQVMsQ0FBQztBQUN4QixPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogW1tpbmNsdWRlOmFzeW5jLWRhdGEvUkVBRE1FLm1kXV1cbiAqIEBtb2R1bGUgYXN5bmMtZGF0YVxuICogQHByZWZlcnJlZFxuICovXG5cbi8qKiBpbXBvcnRzICovXG5leHBvcnQgKiBmcm9tICcuL2FzeW5jLWRhdGEubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vYXN5bmMtZGF0YS1sb2FkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9wYWdlLXN0YXRlL2NvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbmV4cG9ydCB7IEVycm9yU3RhdGVDb21wb25lbnQgfSBmcm9tICcuL2Vycm9yLXBhZ2UvY29tcG9uZW50JztcbiJdfQ==

package/esm2022/async-data/types.mjs

@@ -0,0 +1,6 @@
+/**
+ * @packageDocumentation
+ * @module async-data
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvYXN5bmMtZGF0YS90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0ciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICogQG1vZHVsZSBhc3luYy1kYXRhXG4gKi9cblxuaW1wb3J0IHsgSHR0cEVycm9yUmVzcG9uc2UgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7IFN0YXR1cyB9IGZyb20gJy4uL2NvcmUvcHVibGljLWFwaSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YVN0YXRlQWRhcHRlcjxEPiB7XG4gIHJhd0RhdGEkOiBPYnNlcnZhYmxlPEQ+O1xuICBkYXRhJDogT2JzZXJ2YWJsZTxEPjtcbiAgbG9hZGluZyQ6IE9ic2VydmFibGU8Ym9vbGVhbj47XG4gIGVycm9yJDogT2JzZXJ2YWJsZTxEYXRhRXJyb3I+O1xuICByZWxvYWQ6ICgpID0+IHZvaWQ7XG59XG5cbmV4cG9ydCB0eXBlIEZldGNoZXI8RCwgUD4gPSAocGFyYW1zOiBQKSA9PiBPYnNlcnZhYmxlPEQ+O1xuXG5leHBvcnQgaW50ZXJmYWNlIExvYWRlckNvbmZpZzxELCBQPiB7XG4gIGZldGNoZXI6IEZldGNoZXI8RCwgUD47XG4gIHBhcmFtcyQ/OiBPYnNlcnZhYmxlPFA+O1xuICBwYXJhbXM/OiBQO1xuICBkYXRhRmlsdGVyPzogKGRhdGE6IEQsIGluZGV4OiBudW1iZXIpID0+IGJvb2xlYW47XG4gIHNpbGVudD86IGJvb2xlYW47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTG9hZGVyQ29uZmlnV2l0aEludGVydmFsPEQsIFA+IGV4dGVuZHMgTG9hZGVyQ29uZmlnPEQsIFA+IHtcbiAgaW50ZXJ2YWw6IG51bWJlcjtcbiAgaW50ZXJ2YWxGaWx0ZXI/OiAoaW5kZXg6IG51bWJlcikgPT4gYm9vbGVhbjtcbiAgY29tcGFyZTogc3RyaW5nW10gfCAoKGE6IEQsIGI6IEQpID0+IGJvb2xlYW4pO1xufVxuXG5leHBvcnQgdHlwZSBEYXRhRXJyb3IgPSBQYXJ0aWFsPEh0dHBFcnJvclJlc3BvbnNlICYgU3RhdHVzPjtcblxuZXhwb3J0IHR5cGUgRGF0YU1hcHBlcjxEPiA9IChkYXRhOiBEKSA9PiBEO1xuIl19

package/esm2022/authorization/app-init-url.mjs

@@ -0,0 +1,33 @@
+/**
+ * @packageDocumentation
+ * @module authorization
+ */
+let initUrl;
+export function recordInitUrl() {
+    if (location?.href) {
+        initUrl = location.href;
+        history.replaceState({}, '', removeCode(location.href));
+    }
+}
+export function getInitUrl() {
+    if (!initUrl) {
+        throw new Error('The initial URL was not recorded. Please ensure that you invoke "recordInitUrl" before bootstrapping Angular.');
+    }
+    return initUrl;
+}
+function removeCode(href) {
+    const url = new URL(href);
+    const queryParams = url.search
+        ? url.search
+            .slice(1)
+            .split('&')
+            .filter(pair => {
+            const [key] = pair.split('=');
+            return key !== 'code' && key !== 'state';
+        })
+            .join('&')
+        : '';
+    const query = queryParams ? '?' + queryParams : '';
+    return `${url.origin}${url.pathname}${query}${url.hash}`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLWluaXQtdXJsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2F1dGhvcml6YXRpb24vYXBwLWluaXQtdXJsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUVILElBQUksT0FBZSxDQUFDO0FBRXBCLE1BQU0sVUFBVSxhQUFhO0lBQzNCLElBQUksUUFBUSxFQUFFLElBQUksRUFBRTtRQUNsQixPQUFPLEdBQUcsUUFBUSxDQUFDLElBQUksQ0FBQztRQUN4QixPQUFPLENBQUMsWUFBWSxDQUFDLEVBQUUsRUFBRSxFQUFFLEVBQUUsVUFBVSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0tBQ3pEO0FBQ0gsQ0FBQztBQUVELE1BQU0sVUFBVSxVQUFVO0lBQ3hCLElBQUksQ0FBQyxPQUFPLEVBQUU7UUFDWixNQUFNLElBQUksS0FBSyxDQUNiLCtHQUErRyxDQUNoSCxDQUFDO0tBQ0g7SUFDRCxPQUFPLE9BQU8sQ0FBQztBQUNqQixDQUFDO0FBRUQsU0FBUyxVQUFVLENBQUMsSUFBWTtJQUM5QixNQUFNLEdBQUcsR0FBRyxJQUFJLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUUxQixNQUFNLFdBQVcsR0FBRyxHQUFHLENBQUMsTUFBTTtRQUM1QixDQUFDLENBQUMsR0FBRyxDQUFDLE1BQU07YUFDUCxLQUFLLENBQUMsQ0FBQyxDQUFDO2FBQ1IsS0FBSyxDQUFDLEdBQUcsQ0FBQzthQUNWLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBRTtZQUNiLE1BQU0sQ0FBQyxHQUFHLENBQUMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQzlCLE9BQU8sR0FBRyxLQUFLLE1BQU0sSUFBSSxHQUFHLEtBQUssT0FBTyxDQUFDO1FBQzNDLENBQUMsQ0FBQzthQUNELElBQUksQ0FBQyxHQUFHLENBQUM7UUFDZCxDQUFDLENBQUMsRUFBRSxDQUFDO0lBRVAsTUFBTSxLQUFLLEdBQUcsV0FBVyxDQUFDLENBQUMsQ0FBQyxHQUFHLEdBQUcsV0FBVyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7SUFFbkQsT0FBTyxHQUFHLEdBQUcsQ0FBQyxNQUFNLEdBQUcsR0FBRyxDQUFDLFFBQVEsR0FBRyxLQUFLLEdBQUcsR0FBRyxDQUFDLElBQUksRUFBRSxDQUFDO0FBQzNELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICogQG1vZHVsZSBhdXRob3JpemF0aW9uXG4gKi9cblxubGV0IGluaXRVcmw6IHN0cmluZztcblxuZXhwb3J0IGZ1bmN0aW9uIHJlY29yZEluaXRVcmwoKSB7XG4gIGlmIChsb2NhdGlvbj8uaHJlZikge1xuICAgIGluaXRVcmwgPSBsb2NhdGlvbi5ocmVmO1xuICAgIGhpc3RvcnkucmVwbGFjZVN0YXRlKHt9LCAnJywgcmVtb3ZlQ29kZShsb2NhdGlvbi5ocmVmKSk7XG4gIH1cbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldEluaXRVcmwoKSB7XG4gIGlmICghaW5pdFVybCkge1xuICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgICdUaGUgaW5pdGlhbCBVUkwgd2FzIG5vdCByZWNvcmRlZC4gUGxlYXNlIGVuc3VyZSB0aGF0IHlvdSBpbnZva2UgXCJyZWNvcmRJbml0VXJsXCIgYmVmb3JlIGJvb3RzdHJhcHBpbmcgQW5ndWxhci4nLFxuICAgICk7XG4gIH1cbiAgcmV0dXJuIGluaXRVcmw7XG59XG5cbmZ1bmN0aW9uIHJlbW92ZUNvZGUoaHJlZjogc3RyaW5nKSB7XG4gIGNvbnN0IHVybCA9IG5ldyBVUkwoaHJlZik7XG5cbiAgY29uc3QgcXVlcnlQYXJhbXMgPSB1cmwuc2VhcmNoXG4gICAgPyB1cmwuc2VhcmNoXG4gICAgICAgIC5zbGljZSgxKVxuICAgICAgICAuc3BsaXQoJyYnKVxuICAgICAgICAuZmlsdGVyKHBhaXIgPT4ge1xuICAgICAgICAgIGNvbnN0IFtrZXldID0gcGFpci5zcGxpdCgnPScpO1xuICAgICAgICAgIHJldHVybiBrZXkgIT09ICdjb2RlJyAmJiBrZXkgIT09ICdzdGF0ZSc7XG4gICAgICAgIH0pXG4gICAgICAgIC5qb2luKCcmJylcbiAgICA6ICcnO1xuXG4gIGNvbnN0IHF1ZXJ5ID0gcXVlcnlQYXJhbXMgPyAnPycgKyBxdWVyeVBhcmFtcyA6ICcnO1xuXG4gIHJldHVybiBgJHt1cmwub3JpZ2lufSR7dXJsLnBhdGhuYW1lfSR7cXVlcnl9JHt1cmwuaGFzaH1gO1xufVxuIl19

package/esm2022/authorization/guard.service.mjs

@@ -0,0 +1,42 @@
+/**
+ * @packageDocumentation
+ * @module authorization
+ */
+import { Inject, Injectable, InjectionToken } from '@angular/core';
+import { of, catchError, map } from 'rxjs';
+import { SilentlyNavigateService } from '../core/services/public-api';
+import { AuthorizationStateService } from './state.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./state.service";
+import * as i2 from "../core/services/public-api";
+export const DEFAULT_ABNORMAL_EMPTY_URL = 'system-abnormal';
+export function abnormalEmptyUrlFactory() {
+    return DEFAULT_ABNORMAL_EMPTY_URL;
+}
+export const ABNORMAL_EMPTY_URL_TOKEN = new InjectionToken('abnormal_empty_url', { providedIn: 'root', factory: abnormalEmptyUrlFactory });
+export class AuthorizationGuardService {
+    constructor(emptyUrl, auth, silentlyNavigate) {
+        this.emptyUrl = emptyUrl;
+        this.auth = auth;
+        this.silentlyNavigate = silentlyNavigate;
+    }
+    canActivate(_route, state) {
+        return this.auth.getToken().pipe(map(token => !!token), catchError(() => {
+            this.silentlyNavigate.navigate(state.url, this.emptyUrl);
+            return of(false);
+        }));
+    }
+    canActivateChild(route, state) {
+        return this.canActivate(route, state);
+    }
+    static { this.ɵfac = function AuthorizationGuardService_Factory(t) { return new (t || AuthorizationGuardService)(i0.ɵɵinject(ABNORMAL_EMPTY_URL_TOKEN), i0.ɵɵinject(i1.AuthorizationStateService), i0.ɵɵinject(i2.SilentlyNavigateService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AuthorizationGuardService, factory: AuthorizationGuardService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AuthorizationGuardService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [ABNORMAL_EMPTY_URL_TOKEN]
+            }] }, { type: i1.AuthorizationStateService }, { type: i2.SilentlyNavigateService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/authorization/interceptor.service.mjs

@@ -0,0 +1,149 @@
+/**
+ * @packageDocumentation
+ * @module authorization
+ */
+import { DialogService } from '@alauda/ui';
+import { Inject, Injectable, Injector } from '@angular/core';
+import { NEVER, combineLatest, throwError, catchError, concatMap, take, map, of, switchMap, } from 'rxjs';
+import { ApiGatewayService } from '../api/public-api';
+import { ANONYMOUS_APIS, catchPromise } from '../core/public-api';
+import { TranslateService } from '../public-api';
+import { SESSION_MANAGE_KEY, SessionManageService, } from './session-manage.service';
+import { AuthorizationStateService } from './state.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../api/public-api";
+import * as i2 from "@alauda/ui";
+import * as i3 from "./session-manage.service";
+// Interceptor must provide with correct order, not provide in root here
+// https://angular.cn/guide/http#interceptor-order
+export class AuthorizationInterceptorService {
+    constructor(anonymousApis, apiGateway, injector, dialog, sessionManage) {
+        this.anonymousApis = anonymousApis;
+        this.apiGateway = apiGateway;
+        this.injector = injector;
+        this.dialog = dialog;
+        this.sessionManage = sessionManage;
+    }
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    intercept(req, next) {
+        if (this.isConsoleRelative(req.url)) {
+            return next.handle(req);
+        }
+        const auth = this.getAuth();
+        return combineLatest([
+            this.apiGateway.getApiAddress(),
+            auth.getToken(),
+        ]).pipe(take(1), concatMap(([apiAddress, idToken]) => {
+            if (!this.needAuthorization(apiAddress, req)) {
+                return next.handle(req);
+            }
+            if (!idToken) {
+                return NEVER;
+            }
+            const authReq = this.cloneReq(req, idToken);
+            return next.handle(authReq).pipe(catchError((error) => {
+                if (this.isSessionInvalid(error)) {
+                    this.handleSessionInvalid();
+                    return NEVER;
+                }
+                // 当用户被禁用自动登出
+                if (this.isInvalidUser(error)) {
+                    auth.logout(true);
+                    return NEVER;
+                }
+                if (!this.isUnauthorized(error)) {
+                    return throwError(() => error);
+                }
+                if (this.isWatchReq(apiAddress, authReq)) {
+                    return NEVER;
+                }
+                return auth.checkToken(idToken).pipe(map(() => false), catchError(() => of(true)), switchMap(expired => expired ? this.retryAuth(next, req) : throwError(() => error)));
+            }));
+        }));
+    }
+    // console relative means url protocol+hostname+port same with console, for this case, just check url start with ```http(s)://``` or ```//```
+    isConsoleRelative(url) {
+        const lowerCaseUrl = (url || '').toLowerCase();
+        return (!lowerCaseUrl.startsWith('http://') &&
+            !lowerCaseUrl.startsWith('https://') &&
+            !lowerCaseUrl.startsWith('//'));
+    }
+    retryAuth(next, req) {
+        const auth = this.getAuth();
+        return auth.refreshToken().pipe(concatMap(token => next.handle(this.cloneReq(req, token)).pipe(catchError((error) => {
+            if (this.isUnauthorized(error)) {
+                auth.logout(true);
+            }
+            return throwError(() => error);
+        }))));
+    }
+    cloneReq(req, idToken) {
+        return req.clone({
+            setHeaders: {
+                Authorization: `Bearer ${idToken}`,
+            },
+        });
+    }
+    getAuth() {
+        if (!this.auth) {
+            this.auth = this.injector.get(AuthorizationStateService);
+        }
+        return this.auth;
+    }
+    needAuthorization(apiAddress, req) {
+        if (!req.url.startsWith(apiAddress) || req.headers.get('Authorization')) {
+            return false;
+        }
+        return !this.anonymousApis.some(api => api instanceof RegExp ? api.test(req.url) : req.url.includes(api));
+    }
+    is401({ error }) {
+        return this.isStatus(error) && error.code === 401;
+    }
+    isSessionInvalid(errorRes) {
+        const { error } = errorRes;
+        return this.is401(errorRes) && error.reason === 'SessionInvalid';
+    }
+    handleSessionInvalid() {
+        this.sessionManage.complete();
+        if (Date.now() - parseInt(sessionStorage.getItem(SESSION_MANAGE_KEY)) <
+            5000) {
+            sessionStorage.removeItem(SESSION_MANAGE_KEY);
+            this.auth.logout(true);
+            return;
+        }
+        // fix circle dependency error
+        const translate = this.injector.get(TranslateService);
+        catchPromise(this.dialog.confirm({
+            title: translate.get('session_invalid_hint'),
+            confirmText: translate.get('i_know'),
+            cancelButton: false,
+        })).subscribe(() => {
+            this.auth.logout(true);
+        });
+    }
+    isUnauthorized(errorRes) {
+        return this.is401(errorRes) && errorRes.error.reason === 'Unauthorized';
+    }
+    isInvalidUser(errorRes) {
+        return this.is401(errorRes) && errorRes.error.reason === 'InvalidUser';
+    }
+    isStatus(error) {
+        return error && typeof error !== 'string' && 'code' in error;
+    }
+    isWatchReq(apiAddress, { url, params }) {
+        const isStandardApi = url.startsWith(apiAddress + '/api/') ||
+            url.startsWith(apiAddress + '/apis/') ||
+            url.startsWith(apiAddress + '/kubernetes/');
+        const isWatchOn = params.get('watch')?.toLowerCase() === 'true';
+        return isStandardApi && isWatchOn;
+    }
+    static { this.ɵfac = function AuthorizationInterceptorService_Factory(t) { return new (t || AuthorizationInterceptorService)(i0.ɵɵinject(ANONYMOUS_APIS), i0.ɵɵinject(i1.ApiGatewayService), i0.ɵɵinject(i0.Injector), i0.ɵɵinject(i2.DialogService), i0.ɵɵinject(i3.SessionManageService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AuthorizationInterceptorService, factory: AuthorizationInterceptorService.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AuthorizationInterceptorService, [{
+        type: Injectable
+    }], function () { return [{ type: Array, decorators: [{
+                type: Inject,
+                args: [ANONYMOUS_APIS]
+            }] }, { type: i1.ApiGatewayService }, { type: i0.Injector }, { type: i2.DialogService }, { type: i3.SessionManageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.service.js","sourceRoot":"","sources":["../../../../../libs/common/src/authorization/interceptor.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module authorization\n */\n\nimport { DialogService } from '@alauda/ui';\nimport {\n  HttpErrorResponse,\n  HttpHandler,\n  HttpInterceptor,\n  HttpRequest,\n} from '@angular/common/http';\nimport { Inject, Injectable, Injector } from '@angular/core';\nimport {\n  NEVER,\n  combineLatest,\n  throwError,\n  catchError,\n  concatMap,\n  take,\n  map,\n  of,\n  switchMap,\n} from 'rxjs';\n\nimport { ApiGatewayService } from '../api/public-api';\nimport { ANONYMOUS_APIS, catchPromise } from '../core/public-api';\nimport { Status, TranslateService } from '../public-api';\n\nimport {\n  SESSION_MANAGE_KEY,\n  SessionManageService,\n} from './session-manage.service';\nimport { AuthorizationStateService } from './state.service';\n\n// Interceptor must provide with correct order, not provide in root here\n// https://angular.cn/guide/http#interceptor-order\n@Injectable()\nexport class AuthorizationInterceptorService implements HttpInterceptor {\n  private auth: AuthorizationStateService;\n\n  constructor(\n    @Inject(ANONYMOUS_APIS)\n    private readonly anonymousApis: Array<string | RegExp>,\n    private readonly apiGateway: ApiGatewayService,\n    private readonly injector: Injector,\n    private readonly dialog: DialogService,\n    private readonly sessionManage: SessionManageService,\n  ) {}\n\n  // eslint-disable-next-line sonarjs/cognitive-complexity\n  intercept(req: HttpRequest<unknown>, next: HttpHandler) {\n    if (this.isConsoleRelative(req.url)) {\n      return next.handle(req);\n    }\n\n    const auth = this.getAuth();\n\n    return combineLatest([\n      this.apiGateway.getApiAddress(),\n      auth.getToken(),\n    ]).pipe(\n      take(1),\n      concatMap(([apiAddress, idToken]) => {\n        if (!this.needAuthorization(apiAddress, req)) {\n          return next.handle(req);\n        }\n\n        if (!idToken) {\n          return NEVER;\n        }\n\n        const authReq = this.cloneReq(req, idToken);\n        return next.handle(authReq).pipe(\n          catchError((error: HttpErrorResponse) => {\n            if (this.isSessionInvalid(error)) {\n              this.handleSessionInvalid();\n              return NEVER;\n            }\n\n            // 当用户被禁用自动登出\n            if (this.isInvalidUser(error)) {\n              auth.logout(true);\n              return NEVER;\n            }\n\n            if (!this.isUnauthorized(error)) {\n              return throwError(() => error);\n            }\n\n            if (this.isWatchReq(apiAddress, authReq)) {\n              return NEVER;\n            }\n\n            return auth.checkToken(idToken).pipe(\n              map(() => false),\n              catchError(() => of(true)),\n              switchMap(expired =>\n                expired ? this.retryAuth(next, req) : throwError(() => error),\n              ),\n            );\n          }),\n        );\n      }),\n    );\n  }\n\n  // console relative means url protocol+hostname+port same with console, for this case, just check url start with ```http(s)://``` or ```//```\n  isConsoleRelative(url: string) {\n    const lowerCaseUrl = (url || '').toLowerCase();\n\n    return (\n      !lowerCaseUrl.startsWith('http://') &&\n      !lowerCaseUrl.startsWith('https://') &&\n      !lowerCaseUrl.startsWith('//')\n    );\n  }\n\n  private retryAuth(next: HttpHandler, req: HttpRequest<unknown>) {\n    const auth = this.getAuth();\n    return auth.refreshToken().pipe(\n      concatMap(token =>\n        next.handle(this.cloneReq(req, token)).pipe(\n          catchError((error: HttpErrorResponse) => {\n            if (this.isUnauthorized(error)) {\n              auth.logout(true);\n            }\n\n            return throwError(() => error);\n          }),\n        ),\n      ),\n    );\n  }\n\n  private cloneReq(req: HttpRequest<unknown>, idToken: string) {\n    return req.clone({\n      setHeaders: {\n        Authorization: `Bearer ${idToken}`,\n      },\n    });\n  }\n\n  private getAuth() {\n    if (!this.auth) {\n      this.auth = this.injector.get(AuthorizationStateService);\n    }\n    return this.auth;\n  }\n\n  private needAuthorization(\n    apiAddress: string,\n    req: HttpRequest<unknown>,\n  ): boolean {\n    if (!req.url.startsWith(apiAddress) || req.headers.get('Authorization')) {\n      return false;\n    }\n\n    return !this.anonymousApis.some(api =>\n      api instanceof RegExp ? api.test(req.url) : req.url.includes(api),\n    );\n  }\n\n  private is401({ error }: HttpErrorResponse) {\n    return this.isStatus(error) && error.code === 401;\n  }\n\n  private isSessionInvalid(errorRes: HttpErrorResponse) {\n    const { error } = errorRes;\n    return this.is401(errorRes) && error.reason === 'SessionInvalid';\n  }\n\n  private handleSessionInvalid() {\n    this.sessionManage.complete();\n    if (\n      Date.now() - parseInt(sessionStorage.getItem(SESSION_MANAGE_KEY)) <\n      5000\n    ) {\n      sessionStorage.removeItem(SESSION_MANAGE_KEY);\n      this.auth.logout(true);\n      return;\n    }\n    // fix circle dependency error\n    const translate = this.injector.get(TranslateService);\n    catchPromise(\n      this.dialog.confirm({\n        title: translate.get('session_invalid_hint'),\n        confirmText: translate.get('i_know'),\n        cancelButton: false,\n      }),\n    ).subscribe(() => {\n      this.auth.logout(true);\n    });\n  }\n\n  private isUnauthorized(errorRes: HttpErrorResponse) {\n    return this.is401(errorRes) && errorRes.error.reason === 'Unauthorized';\n  }\n\n  private isInvalidUser(errorRes: HttpErrorResponse) {\n    return this.is401(errorRes) && errorRes.error.reason === 'InvalidUser';\n  }\n\n  private isStatus(error: string | Status): error is Status {\n    return error && typeof error !== 'string' && 'code' in error;\n  }\n\n  private isWatchReq(\n    apiAddress: string,\n    { url, params }: HttpRequest<unknown>,\n  ) {\n    const isStandardApi =\n      url.startsWith(apiAddress + '/api/') ||\n      url.startsWith(apiAddress + '/apis/') ||\n      url.startsWith(apiAddress + '/kubernetes/');\n    const isWatchOn = params.get('watch')?.toLowerCase() === 'true';\n    return isStandardApi && isWatchOn;\n  }\n}\n"]}

package/esm2022/authorization/public-api.mjs

@@ -0,0 +1,12 @@
+/**
+ * [[include:authorization/README.md]]
+ * @module authorization
+ * @preferred
+ */
+/** imports */
+export * from './guard.service';
+export * from './interceptor.service';
+export * from './app-init-url';
+export * from './session-manage.service';
+export * from './state.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9hdXRob3JpemF0aW9uL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILGNBQWM7QUFDZCxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFtbaW5jbHVkZTphdXRob3JpemF0aW9uL1JFQURNRS5tZF1dXG4gKiBAbW9kdWxlIGF1dGhvcml6YXRpb25cbiAqIEBwcmVmZXJyZWRcbiAqL1xuXG4vKiogaW1wb3J0cyAqL1xuZXhwb3J0ICogZnJvbSAnLi9ndWFyZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJjZXB0b3Iuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2FwcC1pbml0LXVybCc7XG5leHBvcnQgKiBmcm9tICcuL3Nlc3Npb24tbWFuYWdlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGF0ZS5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/authorization/session-manage.service.mjs

@@ -0,0 +1,60 @@
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { asyncScheduler, bufferTime, filter, fromEvent, map, merge, subscribeOn, switchMap, withLatestFrom, } from 'rxjs';
+import { PageVisibilityService } from '../api/page-visibility.service';
+import { API_GATEWAY, K8sApiService, TOKEN_DISABLE_SESSION_MANAGE, publishRef, skipError, } from '../public-api';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../api/page-visibility.service";
+import * as i3 from "../public-api";
+const EVENT_TRIGGERS = ['click', 'keypress'];
+const HEARTBEAT_POLLING = 15000;
+export const SESSION_MANAGE_KEY = 'session-manage-construct-time';
+export class SessionManageService {
+    constructor(http, pageVisibility, k8sApi, disabled) {
+        this.http = http;
+        this.pageVisibility = pageVisibility;
+        this.k8sApi = k8sApi;
+        this.visibility$ = this.pageVisibility.getPageVisibility();
+        this.policy$ = this.k8sApi
+            .getGlobalResource({
+            definition: {
+                type: 'userpolicies',
+                apiGroup: 'security.alauda.io',
+                apiVersion: 'v1alpha1',
+            },
+            name: 'user-security-policy',
+        })
+            .pipe(map(p => p.rules
+            .find(r => r.name === 'AccessControlPolicy')
+            ?.items?.find(i => i.key === 'SESSION_SWITCH')?.enable), subscribeOn(asyncScheduler), publishRef());
+        this.userAction$ = merge(...EVENT_TRIGGERS.map(ev => fromEvent(document, ev)))
+            .pipe(bufferTime(HEARTBEAT_POLLING), withLatestFrom(this.visibility$, this.policy$))
+            .pipe(filter(([_, v, p]) => v && p), switchMap(([i]) => this.http
+            .get(`${API_GATEWAY}/auth/v1/heartbeat`, {
+            params: { action: !!i.length },
+        })
+            .pipe(
+        // 错误由 HttpInterceptor 处理，仅由 HttpInterceptor 主动结束此流，自身一直进行心跳
+        skipError())));
+        if (!disabled) {
+            sessionStorage.setItem(SESSION_MANAGE_KEY, String(Date.now()));
+            this.subscription = this.userAction$.subscribe();
+        }
+    }
+    complete() {
+        this.subscription?.unsubscribe();
+    }
+    static { this.ɵfac = function SessionManageService_Factory(t) { return new (t || SessionManageService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.PageVisibilityService), i0.ɵɵinject(i3.K8sApiService), i0.ɵɵinject(TOKEN_DISABLE_SESSION_MANAGE)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SessionManageService, factory: SessionManageService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SessionManageService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.PageVisibilityService }, { type: i3.K8sApiService }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [TOKEN_DISABLE_SESSION_MANAGE]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi1tYW5hZ2Uuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9hdXRob3JpemF0aW9uL3Nlc3Npb24tbWFuYWdlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ25ELE9BQU8sRUFFTCxjQUFjLEVBQ2QsVUFBVSxFQUNWLE1BQU0sRUFDTixTQUFTLEVBQ1QsR0FBRyxFQUNILEtBQUssRUFDTCxXQUFXLEVBQ1gsU0FBUyxFQUNULGNBQWMsR0FDZixNQUFNLE1BQU0sQ0FBQztBQUVkLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3ZFLE9BQU8sRUFDTCxXQUFXLEVBQ1gsYUFBYSxFQUViLDRCQUE0QixFQUM1QixVQUFVLEVBQ1YsU0FBUyxHQUNWLE1BQU0sZUFBZSxDQUFDOzs7OztBQUV2QixNQUFNLGNBQWMsR0FBRyxDQUFDLE9BQU8sRUFBRSxVQUFVLENBQUMsQ0FBQztBQUM3QyxNQUFNLGlCQUFpQixHQUFHLEtBQU0sQ0FBQztBQUNqQyxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRywrQkFBK0IsQ0FBQztBQUtsRSxNQUFNLE9BQU8sb0JBQW9CO0lBNEMvQixZQUNtQixJQUFnQixFQUNoQixjQUFxQyxFQUNyQyxNQUFxQixFQUNBLFFBQWlCO1FBSHRDLFNBQUksR0FBSixJQUFJLENBQVk7UUFDaEIsbUJBQWMsR0FBZCxjQUFjLENBQXVCO1FBQ3JDLFdBQU0sR0FBTixNQUFNLENBQWU7UUE3Q3ZCLGdCQUFXLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO1FBQ3RELFlBQU8sR0FBRyxJQUFJLENBQUMsTUFBTTthQUNuQyxpQkFBaUIsQ0FBeUI7WUFDekMsVUFBVSxFQUFFO2dCQUNWLElBQUksRUFBRSxjQUFjO2dCQUNwQixRQUFRLEVBQUUsb0JBQW9CO2dCQUM5QixVQUFVLEVBQUUsVUFBVTthQUN2QjtZQUNELElBQUksRUFBRSxzQkFBc0I7U0FDN0IsQ0FBQzthQUNELElBQUksQ0FDSCxHQUFHLENBQ0QsQ0FBQyxDQUFDLEVBQUUsQ0FDRixDQUFDLENBQUMsS0FBSzthQUNKLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUsscUJBQXFCLENBQUM7WUFDNUMsRUFBRSxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsS0FBSyxnQkFBZ0IsQ0FBQyxFQUFFLE1BQU0sQ0FDM0QsRUFDRCxXQUFXLENBQUMsY0FBYyxDQUFDLEVBQzNCLFVBQVUsRUFBRSxDQUNiLENBQUM7UUFFYSxnQkFBVyxHQUFHLEtBQUssQ0FDbEMsR0FBRyxjQUFjLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsU0FBUyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUNyRDthQUNFLElBQUksQ0FDSCxVQUFVLENBQUMsaUJBQWlCLENBQUMsRUFDN0IsY0FBYyxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUMvQzthQUNBLElBQUksQ0FDSCxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsRUFDN0IsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQ2hCLElBQUksQ0FBQyxJQUFJO2FBQ04sR0FBRyxDQUFDLEdBQUcsV0FBVyxvQkFBb0IsRUFBRTtZQUN2QyxNQUFNLEVBQUUsRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLEVBQUU7U0FDL0IsQ0FBQzthQUNELElBQUk7UUFDSCw0REFBNEQ7UUFDNUQsU0FBUyxFQUFFLENBQ1osQ0FDSixDQUNGLENBQUM7UUFRRixJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ2IsY0FBYyxDQUFDLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQztZQUMvRCxJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsU0FBUyxFQUFFLENBQUM7U0FDbEQ7SUFDSCxDQUFDO0lBRUQsUUFBUTtRQUNOLElBQUksQ0FBQyxZQUFZLEVBQUUsV0FBVyxFQUFFLENBQUM7SUFDbkMsQ0FBQztxRkExRFUsb0JBQW9CLGdIQWdEckIsNEJBQTRCO3VFQWhEM0Isb0JBQW9CLFdBQXBCLG9CQUFvQixtQkFGbkIsTUFBTTs7dUZBRVAsb0JBQW9CO2NBSGhDLFVBQVU7ZUFBQztnQkFDVixVQUFVLEVBQUUsTUFBTTthQUNuQjs7c0JBaURJLE1BQU07dUJBQUMsNEJBQTRCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cENsaWVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtcbiAgU3Vic2NyaXB0aW9uLFxuICBhc3luY1NjaGVkdWxlcixcbiAgYnVmZmVyVGltZSxcbiAgZmlsdGVyLFxuICBmcm9tRXZlbnQsXG4gIG1hcCxcbiAgbWVyZ2UsXG4gIHN1YnNjcmliZU9uLFxuICBzd2l0Y2hNYXAsXG4gIHdpdGhMYXRlc3RGcm9tLFxufSBmcm9tICdyeGpzJztcblxuaW1wb3J0IHsgUGFnZVZpc2liaWxpdHlTZXJ2aWNlIH0gZnJvbSAnLi4vYXBpL3BhZ2UtdmlzaWJpbGl0eS5zZXJ2aWNlJztcbmltcG9ydCB7XG4gIEFQSV9HQVRFV0FZLFxuICBLOHNBcGlTZXJ2aWNlLFxuICBTZWN1cml0eVBvbGljeVJlc291cmNlLFxuICBUT0tFTl9ESVNBQkxFX1NFU1NJT05fTUFOQUdFLFxuICBwdWJsaXNoUmVmLFxuICBza2lwRXJyb3IsXG59IGZyb20gJy4uL3B1YmxpYy1hcGknO1xuXG5jb25zdCBFVkVOVF9UUklHR0VSUyA9IFsnY2xpY2snLCAna2V5cHJlc3MnXTtcbmNvbnN0IEhFQVJUQkVBVF9QT0xMSU5HID0gMTVfMDAwO1xuZXhwb3J0IGNvbnN0IFNFU1NJT05fTUFOQUdFX0tFWSA9ICdzZXNzaW9uLW1hbmFnZS1jb25zdHJ1Y3QtdGltZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBTZXNzaW9uTWFuYWdlU2VydmljZSB7XG4gIHByaXZhdGUgcmVhZG9ubHkgc3Vic2NyaXB0aW9uOiBTdWJzY3JpcHRpb247XG4gIHByaXZhdGUgcmVhZG9ubHkgdmlzaWJpbGl0eSQgPSB0aGlzLnBhZ2VWaXNpYmlsaXR5LmdldFBhZ2VWaXNpYmlsaXR5KCk7XG4gIHByaXZhdGUgcmVhZG9ubHkgcG9saWN5JCA9IHRoaXMuazhzQXBpXG4gICAgLmdldEdsb2JhbFJlc291cmNlPFNlY3VyaXR5UG9saWN5UmVzb3VyY2U+KHtcbiAgICAgIGRlZmluaXRpb246IHtcbiAgICAgICAgdHlwZTogJ3VzZXJwb2xpY2llcycsXG4gICAgICAgIGFwaUdyb3VwOiAnc2VjdXJpdHkuYWxhdWRhLmlvJyxcbiAgICAgICAgYXBpVmVyc2lvbjogJ3YxYWxwaGExJyxcbiAgICAgIH0sXG4gICAgICBuYW1lOiAndXNlci1zZWN1cml0eS1wb2xpY3knLFxuICAgIH0pXG4gICAgLnBpcGUoXG4gICAgICBtYXAoXG4gICAgICAgIHAgPT5cbiAgICAgICAgICBwLnJ1bGVzXG4gICAgICAgICAgICAuZmluZChyID0+IHIubmFtZSA9PT0gJ0FjY2Vzc0NvbnRyb2xQb2xpY3knKVxuICAgICAgICAgICAgPy5pdGVtcz8uZmluZChpID0+IGkua2V5ID09PSAnU0VTU0lPTl9TV0lUQ0gnKT8uZW5hYmxlLFxuICAgICAgKSxcbiAgICAgIHN1YnNjcmliZU9uKGFzeW5jU2NoZWR1bGVyKSxcbiAgICAgIHB1Ymxpc2hSZWYoKSxcbiAgICApO1xuXG4gIHByaXZhdGUgcmVhZG9ubHkgdXNlckFjdGlvbiQgPSBtZXJnZShcbiAgICAuLi5FVkVOVF9UUklHR0VSUy5tYXAoZXYgPT4gZnJvbUV2ZW50KGRvY3VtZW50LCBldikpLFxuICApXG4gICAgLnBpcGUoXG4gICAgICBidWZmZXJUaW1lKEhFQVJUQkVBVF9QT0xMSU5HKSxcbiAgICAgIHdpdGhMYXRlc3RGcm9tKHRoaXMudmlzaWJpbGl0eSQsIHRoaXMucG9saWN5JCksXG4gICAgKVxuICAgIC5waXBlKFxuICAgICAgZmlsdGVyKChbXywgdiwgcF0pID0+IHYgJiYgcCksXG4gICAgICBzd2l0Y2hNYXAoKFtpXSkgPT5cbiAgICAgICAgdGhpcy5odHRwXG4gICAgICAgICAgLmdldChgJHtBUElfR0FURVdBWX0vYXV0aC92MS9oZWFydGJlYXRgLCB7XG4gICAgICAgICAgICBwYXJhbXM6IHsgYWN0aW9uOiAhIWkubGVuZ3RoIH0sXG4gICAgICAgICAgfSlcbiAgICAgICAgICAucGlwZShcbiAgICAgICAgICAgIC8vIOmUmeivr+eUsSBIdHRwSW50ZXJjZXB0b3Ig5aSE55CG77yM5LuF55SxIEh0dHBJbnRlcmNlcHRvciDkuLvliqjnu5PmnZ/mraTmtYHvvIzoh6rouqvkuIDnm7Tov5vooYzlv4Pot7NcbiAgICAgICAgICAgIHNraXBFcnJvcigpLFxuICAgICAgICAgICksXG4gICAgICApLFxuICAgICk7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSByZWFkb25seSBodHRwOiBIdHRwQ2xpZW50LFxuICAgIHByaXZhdGUgcmVhZG9ubHkgcGFnZVZpc2liaWxpdHk6IFBhZ2VWaXNpYmlsaXR5U2VydmljZSxcbiAgICBwcml2YXRlIHJlYWRvbmx5IGs4c0FwaTogSzhzQXBpU2VydmljZSxcbiAgICBASW5qZWN0KFRPS0VOX0RJU0FCTEVfU0VTU0lPTl9NQU5BR0UpIGRpc2FibGVkOiBib29sZWFuLFxuICApIHtcbiAgICBpZiAoIWRpc2FibGVkKSB7XG4gICAgICBzZXNzaW9uU3RvcmFnZS5zZXRJdGVtKFNFU1NJT05fTUFOQUdFX0tFWSwgU3RyaW5nKERhdGUubm93KCkpKTtcbiAgICAgIHRoaXMuc3Vic2NyaXB0aW9uID0gdGhpcy51c2VyQWN0aW9uJC5zdWJzY3JpYmUoKTtcbiAgICB9XG4gIH1cblxuICBjb21wbGV0ZSgpIHtcbiAgICB0aGlzLnN1YnNjcmlwdGlvbj8udW5zdWJzY3JpYmUoKTtcbiAgfVxufVxuIl19