@delon/abc 15.2.1 → 16.0.0

package/esm2022/reuse-tab/reuse-tab-context.service.mjs

@@ -0,0 +1,56 @@
+import { ConnectionPositionPair } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Injectable } from '@angular/core';
+import { Subject, Subscription } from 'rxjs';
+import { ReuseTabContextMenuComponent } from './reuse-tab-context-menu.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+class ReuseTabContextService {
+    constructor(overlay) {
+        this.overlay = overlay;
+        this.ref = null;
+        this.show = new Subject();
+        this.close = new Subject();
+    }
+    remove() {
+        if (!this.ref)
+            return;
+        this.ref.detach();
+        this.ref.dispose();
+        this.ref = null;
+    }
+    open(context) {
+        this.remove();
+        const { event, item, customContextMenu } = context;
+        const { x, y } = event;
+        const positions = [
+            new ConnectionPositionPair({ originX: 'start', originY: 'bottom' }, { overlayX: 'start', overlayY: 'top' }),
+            new ConnectionPositionPair({ originX: 'start', originY: 'top' }, { overlayX: 'start', overlayY: 'bottom' })
+        ];
+        const positionStrategy = this.overlay.position().flexibleConnectedTo({ x, y }).withPositions(positions);
+        this.ref = this.overlay.create({
+            positionStrategy,
+            panelClass: 'reuse-tab__cm',
+            scrollStrategy: this.overlay.scrollStrategies.close()
+        });
+        const comp = this.ref.attach(new ComponentPortal(ReuseTabContextMenuComponent));
+        const instance = comp.instance;
+        instance.i18n = this.i18n;
+        instance.item = { ...item };
+        instance.customContextMenu = customContextMenu;
+        instance.event = event;
+        const sub$ = new Subscription();
+        sub$.add(instance.close.subscribe((res) => {
+            this.close.next(res);
+            this.remove();
+        }));
+        comp.onDestroy(() => sub$.unsubscribe());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: ReuseTabContextService, deps: [{ token: i1.Overlay }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: ReuseTabContextService }); }
+}
+export { ReuseTabContextService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: ReuseTabContextService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/reuse-tab/reuse-tab.component.mjs

@@ -0,0 +1,368 @@
+import { __decorate } from "tslib";
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, EventEmitter, Inject, Input, Optional, Output, ViewChild, ViewEncapsulation } from '@angular/core';
+import { Subject, debounceTime, filter, takeUntil, of } from 'rxjs';
+import { ALAIN_I18N_TOKEN } from '@delon/theme';
+import { InputBoolean, InputNumber } from '@delon/util/decorator';
+import { ReuseTabContextService } from './reuse-tab-context.service';
+import { ReuseTabMatchMode } from './reuse-tab.interfaces';
+import { REUSE_TAB_STORAGE_KEY, REUSE_TAB_STORAGE_STATE } from './reuse-tab.state';
+import * as i0 from "@angular/core";
+import * as i1 from "./reuse-tab.service";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/cdk/platform";
+import * as i4 from "@angular/cdk/bidi";
+import * as i5 from "@angular/common";
+import * as i6 from "ng-zorro-antd/tabs";
+import * as i7 from "ng-zorro-antd/icon";
+import * as i8 from "./reuse-tab-context.component";
+import * as i9 from "./reuse-tab-context.directive";
+class ReuseTabComponent {
+    set keepingScrollContainer(value) {
+        this._keepingScrollContainer = typeof value === 'string' ? this.doc.querySelector(value) : value;
+    }
+    // #endregion
+    constructor(srv, cdr, router, route, i18nSrv, doc, platform, directionality, stateKey, stateSrv) {
+        this.srv = srv;
+        this.cdr = cdr;
+        this.router = router;
+        this.route = route;
+        this.i18nSrv = i18nSrv;
+        this.doc = doc;
+        this.platform = platform;
+        this.directionality = directionality;
+        this.stateKey = stateKey;
+        this.stateSrv = stateSrv;
+        this.destroy$ = new Subject();
+        this.list = [];
+        this.pos = 0;
+        this.dir = 'ltr';
+        // #region fields
+        this.mode = ReuseTabMatchMode.Menu;
+        this.debug = false;
+        this.allowClose = true;
+        this.keepingScroll = false;
+        this.storageState = false;
+        this.customContextMenu = [];
+        this.tabBarStyle = null;
+        this.tabType = 'line';
+        this.routeParamMatchMode = 'strict';
+        this.disabled = false;
+        this.change = new EventEmitter();
+        this.close = new EventEmitter();
+    }
+    genTit(title) {
+        return title.i18n && this.i18nSrv ? this.i18nSrv.fanyi(title.i18n) : title.text;
+    }
+    get curUrl() {
+        return this.srv.getUrl(this.route.snapshot);
+    }
+    genCurItem() {
+        const url = this.curUrl;
+        const snapshotTrue = this.srv.getTruthRoute(this.route.snapshot);
+        return {
+            url,
+            title: this.genTit(this.srv.getTitle(url, snapshotTrue)),
+            closable: this.allowClose && this.srv.count > 0 && this.srv.getClosable(url, snapshotTrue),
+            active: false,
+            last: false,
+            index: 0
+        };
+    }
+    genList(notify) {
+        const ls = this.srv.items.map((item, index) => ({
+            url: item.url,
+            title: this.genTit(item.title),
+            closable: this.allowClose && item.closable && this.srv.count > 0,
+            position: item.position,
+            index,
+            active: false,
+            last: false
+        }));
+        // debugger;
+        const url = this.curUrl;
+        let addCurrent = ls.findIndex(w => w.url === url) === -1;
+        if (notify && notify.active === 'close' && notify.url === url) {
+            addCurrent = false;
+            let toPos = 0;
+            const curItem = this.list.find(w => w.url === url);
+            if (curItem.index === ls.length) {
+                // When closed is last
+                toPos = ls.length - 1;
+            }
+            else if (curItem.index < ls.length) {
+                // Should be actived next tab when closed is middle
+                toPos = Math.max(0, curItem.index);
+            }
+            this.router.navigateByUrl(ls[toPos].url);
+        }
+        if (addCurrent) {
+            ls.splice(this.pos + 1, 0, this.genCurItem());
+        }
+        ls.forEach((item, index) => (item.index = index));
+        if (ls.length === 1) {
+            ls[0].closable = false;
+        }
+        this.list = ls;
+        this.cdr.detectChanges();
+        this.updatePos();
+    }
+    updateTitle(res) {
+        const item = this.list.find(w => w.url === res.url);
+        if (!item)
+            return;
+        item.title = this.genTit(res.title);
+        this.cdr.detectChanges();
+    }
+    refresh(item) {
+        this.srv.runHook('_onReuseInit', this.pos === item.index ? this.srv.componentRef : item.index, 'refresh');
+    }
+    saveState() {
+        if (!this.srv.inited || !this.storageState)
+            return;
+        this.stateSrv.update(this.stateKey, this.list);
+    }
+    // #region UI
+    contextMenuChange(res) {
+        let fn = null;
+        switch (res.type) {
+            case 'refresh':
+                this.refresh(res.item);
+                break;
+            case 'close':
+                this._close(null, res.item.index, res.includeNonCloseable);
+                break;
+            case 'closeRight':
+                fn = () => {
+                    this.srv.closeRight(res.item.url, res.includeNonCloseable);
+                    this.close.emit(null);
+                };
+                break;
+            case 'closeOther':
+                fn = () => {
+                    this.srv.clear(res.includeNonCloseable);
+                    this.close.emit(null);
+                };
+                break;
+        }
+        if (!fn) {
+            return;
+        }
+        if (!res.item.active && res.item.index <= this.list.find(w => w.active).index) {
+            this._to(res.item.index, fn);
+        }
+        else {
+            fn();
+        }
+    }
+    _to(index, cb) {
+        index = Math.max(0, Math.min(index, this.list.length - 1));
+        const item = this.list[index];
+        this.router.navigateByUrl(item.url).then(res => {
+            if (!res)
+                return;
+            this.item = item;
+            this.change.emit(item);
+            if (cb) {
+                cb();
+            }
+        });
+    }
+    _close(e, idx, includeNonCloseable) {
+        if (e != null) {
+            e.preventDefault();
+            e.stopPropagation();
+        }
+        const item = this.list[idx];
+        (this.canClose ? this.canClose({ item, includeNonCloseable }) : of(true)).pipe(filter(v => v)).subscribe(() => {
+            this.srv.close(item.url, includeNonCloseable);
+            this.close.emit(item);
+            this.cdr.detectChanges();
+        });
+        return false;
+    }
+    /**
+     * 设置激活路由的实例，在 `src/app/layout/basic/basic.component.ts` 修改：
+     *
+     * @example
+     * <reuse-tab #reuseTab></reuse-tab>
+     * <router-outlet (activate)="reuseTab.activate($event)" (attach)="reuseTab.activate($event)"></router-outlet>
+     */
+    activate(instance) {
+        this.srv.componentRef = { instance };
+    }
+    updatePos() {
+        const url = this.srv.getUrl(this.route.snapshot);
+        const ls = this.list.filter(w => w.url === url || !this.srv.isExclude(w.url));
+        if (ls.length === 0) {
+            return;
+        }
+        const last = ls[ls.length - 1];
+        const item = ls.find(w => w.url === url);
+        last.last = true;
+        const pos = item == null ? last.index : item.index;
+        ls.forEach((i, idx) => (i.active = pos === idx));
+        this.pos = pos;
+        // TODO: 目前无法知道为什么 `pos` 无法通过 `nzSelectedIndex` 生效，因此强制使用组件实例的方式来修改，这种方式是安全的
+        // https://github.com/ng-alain/ng-alain/issues/1736
+        this.tabset.nzSelectedIndex = pos;
+        this.list = ls;
+        this.cdr.detectChanges();
+        this.saveState();
+    }
+    // #endregion
+    ngOnInit() {
+        this.dir = this.directionality.value;
+        this.directionality.change?.pipe(takeUntil(this.destroy$)).subscribe((direction) => {
+            this.dir = direction;
+            this.cdr.detectChanges();
+        });
+        if (!this.platform.isBrowser) {
+            return;
+        }
+        this.srv.change.pipe(takeUntil(this.destroy$)).subscribe(res => {
+            switch (res?.active) {
+                case 'title':
+                    this.updateTitle(res);
+                    return;
+                case 'override':
+                    if (res?.list?.length === this.list.length) {
+                        this.updatePos();
+                        return;
+                    }
+                    break;
+            }
+            this.genList(res);
+        });
+        this.i18nSrv.change
+            .pipe(filter(() => this.srv.inited), takeUntil(this.destroy$), debounceTime(100))
+            .subscribe(() => this.genList({ active: 'title' }));
+        this.srv.init();
+    }
+    ngOnChanges(changes) {
+        if (!this.platform.isBrowser) {
+            return;
+        }
+        if (changes.max)
+            this.srv.max = this.max;
+        if (changes.excludes)
+            this.srv.excludes = this.excludes;
+        if (changes.mode)
+            this.srv.mode = this.mode;
+        if (changes.routeParamMatchMode)
+            this.srv.routeParamMatchMode = this.routeParamMatchMode;
+        if (changes.keepingScroll) {
+            this.srv.keepingScroll = this.keepingScroll;
+            this.srv.keepingScrollContainer = this._keepingScrollContainer;
+        }
+        if (changes.storageState)
+            this.srv.storageState = this.storageState;
+        this.srv.debug = this.debug;
+        this.cdr.detectChanges();
+    }
+    ngOnDestroy() {
+        const { destroy$ } = this;
+        destroy$.next();
+        destroy$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: ReuseTabComponent, deps: [{ token: i1.ReuseTabService }, { token: i0.ChangeDetectorRef }, { token: i2.Router }, { token: i2.ActivatedRoute }, { token: ALAIN_I18N_TOKEN, optional: true }, { token: DOCUMENT }, { token: i3.Platform }, { token: i4.Directionality, optional: true }, { token: REUSE_TAB_STORAGE_KEY, optional: true }, { token: REUSE_TAB_STORAGE_STATE, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.4", type: ReuseTabComponent, selector: "reuse-tab, [reuse-tab]", inputs: { mode: "mode", i18n: "i18n", debug: "debug", max: "max", tabMaxWidth: "tabMaxWidth", excludes: "excludes", allowClose: "allowClose", keepingScroll: "keepingScroll", storageState: "storageState", keepingScrollContainer: "keepingScrollContainer", customContextMenu: "customContextMenu", tabBarExtraContent: "tabBarExtraContent", tabBarGutter: "tabBarGutter", tabBarStyle: "tabBarStyle", tabType: "tabType", routeParamMatchMode: "routeParamMatchMode", disabled: "disabled", titleRender: "titleRender", canClose: "canClose" }, outputs: { change: "change", close: "close" }, host: { properties: { "class.reuse-tab": "true", "class.reuse-tab__line": "tabType === 'line'", "class.reuse-tab__card": "tabType === 'card'", "class.reuse-tab__disabled": "disabled", "class.reuse-tab-rtl": "dir === 'rtl'" } }, providers: [ReuseTabContextService], viewQueries: [{ propertyName: "tabset", first: true, predicate: ["tabset"], descendants: true }], exportAs: ["reuseTab"], usesOnChanges: true, ngImport: i0, template: "<nz-tabset\n  #tabset\n  [nzSelectedIndex]=\"pos\"\n  [nzAnimated]=\"false\"\n  [nzType]=\"tabType\"\n  [nzTabBarExtraContent]=\"tabBarExtraContent\"\n  [nzTabBarGutter]=\"tabBarGutter\"\n  [nzTabBarStyle]=\"tabBarStyle\"\n>\n  <nz-tab *ngFor=\"let i of list; let index = index\" [nzTitle]=\"titleTemplate\" (nzClick)=\"_to(index)\">\n    <ng-template #titleTemplate>\n      <div\n        [reuse-tab-context-menu]=\"i\"\n        [customContextMenu]=\"customContextMenu\"\n        class=\"reuse-tab__name\"\n        [attr.title]=\"i.title\"\n      >\n        <span [class.reuse-tab__name-width]=\"tabMaxWidth\" [style.max-width.px]=\"tabMaxWidth\">\n          <ng-container\n            *ngIf=\"titleRender; else defaultTitle\"\n            [ngTemplateOutlet]=\"titleRender\"\n            [ngTemplateOutletContext]=\"{ $implicit: i }\"\n          ></ng-container>\n          <ng-template #defaultTitle>{{ i.title }}</ng-template>\n        </span>\n      </div>\n      <i *ngIf=\"i.closable\" nz-icon nzType=\"close\" class=\"reuse-tab__op\" (click)=\"_close($event, index, false)\"></i>\n    </ng-template>\n  </nz-tab>\n</nz-tabset>\n<reuse-tab-context [i18n]=\"i18n\" (change)=\"contextMenuChange($event)\"></reuse-tab-context>\n", dependencies: [{ kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i6.NzTabSetComponent, selector: "nz-tabset", inputs: ["nzSelectedIndex", "nzTabPosition", "nzTabBarExtraContent", "nzCanDeactivate", "nzAddIcon", "nzTabBarStyle", "nzType", "nzSize", "nzAnimated", "nzTabBarGutter", "nzHideAdd", "nzCentered", "nzHideAll", "nzLinkRouter", "nzLinkExact"], outputs: ["nzSelectChange", "nzSelectedIndexChange", "nzTabListScroll", "nzClose", "nzAdd"], exportAs: ["nzTabset"] }, { kind: "component", type: i6.NzTabComponent, selector: "nz-tab", inputs: ["nzTitle", "nzClosable", "nzCloseIcon", "nzDisabled", "nzForceRender"], outputs: ["nzSelect", "nzDeselect", "nzClick", "nzContextmenu"], exportAs: ["nzTab"] }, { kind: "directive", type: i7.NzIconDirective, selector: "[nz-icon]", inputs: ["nzSpin", "nzRotate", "nzType", "nzTheme", "nzTwotoneColor", "nzIconfont"], exportAs: ["nzIcon"] }, { kind: "component", type: i8.ReuseTabContextComponent, selector: "reuse-tab-context", inputs: ["i18n"], outputs: ["change"] }, { kind: "directive", type: i9.ReuseTabContextDirective, selector: "[reuse-tab-context-menu]", inputs: ["reuse-tab-context-menu", "customContextMenu"], exportAs: ["reuseTabContextMenu"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+__decorate([
+    InputBoolean()
+], ReuseTabComponent.prototype, "debug", void 0);
+__decorate([
+    InputNumber()
+], ReuseTabComponent.prototype, "max", void 0);
+__decorate([
+    InputNumber()
+], ReuseTabComponent.prototype, "tabMaxWidth", void 0);
+__decorate([
+    InputBoolean()
+], ReuseTabComponent.prototype, "allowClose", void 0);
+__decorate([
+    InputBoolean()
+], ReuseTabComponent.prototype, "keepingScroll", void 0);
+__decorate([
+    InputBoolean()
+], ReuseTabComponent.prototype, "storageState", void 0);
+__decorate([
+    InputBoolean()
+], ReuseTabComponent.prototype, "disabled", void 0);
+export { ReuseTabComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: ReuseTabComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'reuse-tab, [reuse-tab]', exportAs: 'reuseTab', host: {
+                        '[class.reuse-tab]': 'true',
+                        '[class.reuse-tab__line]': `tabType === 'line'`,
+                        '[class.reuse-tab__card]': `tabType === 'card'`,
+                        '[class.reuse-tab__disabled]': `disabled`,
+                        '[class.reuse-tab-rtl]': `dir === 'rtl'`
+                    }, providers: [ReuseTabContextService], preserveWhitespaces: false, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<nz-tabset\n  #tabset\n  [nzSelectedIndex]=\"pos\"\n  [nzAnimated]=\"false\"\n  [nzType]=\"tabType\"\n  [nzTabBarExtraContent]=\"tabBarExtraContent\"\n  [nzTabBarGutter]=\"tabBarGutter\"\n  [nzTabBarStyle]=\"tabBarStyle\"\n>\n  <nz-tab *ngFor=\"let i of list; let index = index\" [nzTitle]=\"titleTemplate\" (nzClick)=\"_to(index)\">\n    <ng-template #titleTemplate>\n      <div\n        [reuse-tab-context-menu]=\"i\"\n        [customContextMenu]=\"customContextMenu\"\n        class=\"reuse-tab__name\"\n        [attr.title]=\"i.title\"\n      >\n        <span [class.reuse-tab__name-width]=\"tabMaxWidth\" [style.max-width.px]=\"tabMaxWidth\">\n          <ng-container\n            *ngIf=\"titleRender; else defaultTitle\"\n            [ngTemplateOutlet]=\"titleRender\"\n            [ngTemplateOutletContext]=\"{ $implicit: i }\"\n          ></ng-container>\n          <ng-template #defaultTitle>{{ i.title }}</ng-template>\n        </span>\n      </div>\n      <i *ngIf=\"i.closable\" nz-icon nzType=\"close\" class=\"reuse-tab__op\" (click)=\"_close($event, index, false)\"></i>\n    </ng-template>\n  </nz-tab>\n</nz-tabset>\n<reuse-tab-context [i18n]=\"i18n\" (change)=\"contextMenuChange($event)\"></reuse-tab-context>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ReuseTabService }, { type: i0.ChangeDetectorRef }, { type: i2.Router }, { type: i2.ActivatedRoute }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ALAIN_I18N_TOKEN]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i3.Platform }, { type: i4.Directionality, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [REUSE_TAB_STORAGE_KEY]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [REUSE_TAB_STORAGE_STATE]
+                }] }]; }, propDecorators: { tabset: [{
+                type: ViewChild,
+                args: ['tabset']
+            }], mode: [{
+                type: Input
+            }], i18n: [{
+                type: Input
+            }], debug: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], tabMaxWidth: [{
+                type: Input
+            }], excludes: [{
+                type: Input
+            }], allowClose: [{
+                type: Input
+            }], keepingScroll: [{
+                type: Input
+            }], storageState: [{
+                type: Input
+            }], keepingScrollContainer: [{
+                type: Input
+            }], customContextMenu: [{
+                type: Input
+            }], tabBarExtraContent: [{
+                type: Input
+            }], tabBarGutter: [{
+                type: Input
+            }], tabBarStyle: [{
+                type: Input
+            }], tabType: [{
+                type: Input
+            }], routeParamMatchMode: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], titleRender: [{
+                type: Input
+            }], canClose: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }], close: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reuse-tab.component.js","sourceRoot":"","sources":["../../../../../packages/abc/reuse-tab/reuse-tab.component.ts","../../../../../packages/abc/reuse-tab/reuse-tab.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Direction, Directionality } from '@angular/cdk/bidi';\nimport { Platform } from '@angular/cdk/platform';\nimport { DOCUMENT } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Inject,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  SimpleChange,\n  SimpleChanges,\n  TemplateRef,\n  ViewChild,\n  ViewEncapsulation\n} from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { Subject, debounceTime, filter, takeUntil, of } from 'rxjs';\n\nimport { AlainI18NService, ALAIN_I18N_TOKEN } from '@delon/theme';\nimport { BooleanInput, InputBoolean, InputNumber, NumberInput } from '@delon/util/decorator';\nimport type { NzSafeAny } from 'ng-zorro-antd/core/types';\nimport { NzTabSetComponent } from 'ng-zorro-antd/tabs';\n\nimport { ReuseTabContextService } from './reuse-tab-context.service';\nimport {\n  ReuseCanClose,\n  ReuseContextCloseEvent,\n  ReuseContextI18n,\n  ReuseCustomContextMenu,\n  ReuseItem,\n  ReuseTabCached,\n  ReuseTabMatchMode,\n  ReuseTabNotify,\n  ReuseTabRouteParamMatchMode,\n  ReuseTitle\n} from './reuse-tab.interfaces';\nimport { ReuseTabService } from './reuse-tab.service';\nimport { ReuseTabStorageState, REUSE_TAB_STORAGE_KEY, REUSE_TAB_STORAGE_STATE } from './reuse-tab.state';\n\n@Component({\n  selector: 'reuse-tab, [reuse-tab]',\n  exportAs: 'reuseTab',\n  templateUrl: './reuse-tab.component.html',\n  host: {\n    '[class.reuse-tab]': 'true',\n    '[class.reuse-tab__line]': `tabType === 'line'`,\n    '[class.reuse-tab__card]': `tabType === 'card'`,\n    '[class.reuse-tab__disabled]': `disabled`,\n    '[class.reuse-tab-rtl]': `dir === 'rtl'`\n  },\n  providers: [ReuseTabContextService],\n  preserveWhitespaces: false,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None\n})\nexport class ReuseTabComponent implements OnInit, OnChanges, OnDestroy {\n  static ngAcceptInputType_debug: BooleanInput;\n  static ngAcceptInputType_max: NumberInput;\n  static ngAcceptInputType_tabMaxWidth: NumberInput;\n  static ngAcceptInputType_allowClose: BooleanInput;\n  static ngAcceptInputType_keepingScroll: BooleanInput;\n  static ngAcceptInputType_disabled: BooleanInput;\n  static ngAcceptInputType_storageState: BooleanInput;\n\n  @ViewChild('tabset') private tabset!: NzTabSetComponent;\n  private destroy$ = new Subject<void>();\n  private _keepingScrollContainer?: Element;\n  list: ReuseItem[] = [];\n  item?: ReuseItem;\n  pos = 0;\n  dir: Direction = 'ltr';\n\n  // #region fields\n\n  @Input() mode: ReuseTabMatchMode = ReuseTabMatchMode.Menu;\n  @Input() i18n?: ReuseContextI18n;\n  @Input() @InputBoolean() debug = false;\n  @Input() @InputNumber() max?: number;\n  @Input() @InputNumber() tabMaxWidth?: number;\n  @Input() excludes?: RegExp[];\n  @Input() @InputBoolean() allowClose = true;\n  @Input() @InputBoolean() keepingScroll = false;\n  @Input() @InputBoolean() storageState = false;\n  @Input()\n  set keepingScrollContainer(value: string | Element) {\n    this._keepingScrollContainer = typeof value === 'string' ? this.doc.querySelector(value) : value;\n  }\n  @Input() customContextMenu: ReuseCustomContextMenu[] = [];\n  @Input() tabBarExtraContent?: TemplateRef<void>;\n  @Input() tabBarGutter?: number;\n  @Input() tabBarStyle: { [key: string]: string } | null = null;\n  @Input() tabType: 'line' | 'card' = 'line';\n  @Input() routeParamMatchMode: ReuseTabRouteParamMatchMode = 'strict';\n  @Input() @InputBoolean() disabled = false;\n  @Input() titleRender?: TemplateRef<{ $implicit: ReuseItem }>;\n  @Input() canClose?: ReuseCanClose;\n  @Output() readonly change = new EventEmitter<ReuseItem>();\n  @Output() readonly close = new EventEmitter<ReuseItem | null>();\n\n  // #endregion\n\n  constructor(\n    private srv: ReuseTabService,\n    private cdr: ChangeDetectorRef,\n    private router: Router,\n    private route: ActivatedRoute,\n    @Optional() @Inject(ALAIN_I18N_TOKEN) private i18nSrv: AlainI18NService,\n    @Inject(DOCUMENT) private doc: NzSafeAny,\n    private platform: Platform,\n    @Optional() private directionality: Directionality,\n    @Optional() @Inject(REUSE_TAB_STORAGE_KEY) private stateKey: string,\n    @Optional() @Inject(REUSE_TAB_STORAGE_STATE) private stateSrv: ReuseTabStorageState\n  ) {}\n\n  private genTit(title: ReuseTitle): string {\n    return title.i18n && this.i18nSrv ? this.i18nSrv.fanyi(title.i18n) : title.text!;\n  }\n\n  private get curUrl(): string {\n    return this.srv.getUrl(this.route.snapshot);\n  }\n\n  private genCurItem(): ReuseItem {\n    const url = this.curUrl;\n    const snapshotTrue = this.srv.getTruthRoute(this.route.snapshot);\n    return {\n      url,\n      title: this.genTit(this.srv.getTitle(url, snapshotTrue)),\n      closable: this.allowClose && this.srv.count > 0 && this.srv.getClosable(url, snapshotTrue),\n      active: false,\n      last: false,\n      index: 0\n    };\n  }\n\n  private genList(notify: ReuseTabNotify | null): void {\n    const ls = this.srv.items.map(\n      (item: ReuseTabCached, index: number) =>\n        ({\n          url: item.url,\n          title: this.genTit(item.title),\n          closable: this.allowClose && item.closable && this.srv.count > 0,\n          position: item.position,\n          index,\n          active: false,\n          last: false\n        } as ReuseItem)\n    );\n    // debugger;\n\n    const url = this.curUrl;\n    let addCurrent = ls.findIndex(w => w.url === url) === -1;\n    if (notify && notify.active === 'close' && notify.url === url) {\n      addCurrent = false;\n      let toPos = 0;\n      const curItem = this.list.find(w => w.url === url)!;\n      if (curItem.index === ls.length) {\n        // When closed is last\n        toPos = ls.length - 1;\n      } else if (curItem.index < ls.length) {\n        // Should be actived next tab when closed is middle\n        toPos = Math.max(0, curItem.index);\n      }\n      this.router.navigateByUrl(ls[toPos].url);\n    }\n\n    if (addCurrent) {\n      ls.splice(this.pos + 1, 0, this.genCurItem());\n    }\n\n    ls.forEach((item, index) => (item.index = index));\n    if (ls.length === 1) {\n      ls[0].closable = false;\n    }\n    this.list = ls;\n    this.cdr.detectChanges();\n    this.updatePos();\n  }\n\n  private updateTitle(res: ReuseTabNotify): void {\n    const item = this.list.find(w => w.url === res!.url);\n    if (!item) return;\n    item.title = this.genTit(res!.title!);\n    this.cdr.detectChanges();\n  }\n\n  private refresh(item: ReuseItem): void {\n    this.srv.runHook('_onReuseInit', this.pos === item.index ? this.srv.componentRef : item.index, 'refresh');\n  }\n\n  private saveState(): void {\n    if (!this.srv.inited || !this.storageState) return;\n\n    this.stateSrv.update(this.stateKey, this.list);\n  }\n\n  // #region UI\n\n  contextMenuChange(res: ReuseContextCloseEvent): void {\n    let fn: (() => void) | null = null;\n    switch (res.type) {\n      case 'refresh':\n        this.refresh(res.item);\n        break;\n      case 'close':\n        this._close(null, res.item.index, res.includeNonCloseable);\n        break;\n      case 'closeRight':\n        fn = () => {\n          this.srv.closeRight(res.item.url, res.includeNonCloseable);\n          this.close.emit(null);\n        };\n        break;\n      case 'closeOther':\n        fn = () => {\n          this.srv.clear(res.includeNonCloseable);\n          this.close.emit(null);\n        };\n        break;\n    }\n    if (!fn) {\n      return;\n    }\n    if (!res.item.active && res.item.index <= this.list.find(w => w.active)!.index) {\n      this._to(res.item.index, fn);\n    } else {\n      fn();\n    }\n  }\n\n  _to(index: number, cb?: () => void): void {\n    index = Math.max(0, Math.min(index, this.list.length - 1));\n    const item = this.list[index];\n    this.router.navigateByUrl(item.url).then(res => {\n      if (!res) return;\n      this.item = item;\n      this.change.emit(item);\n      if (cb) {\n        cb();\n      }\n    });\n  }\n\n  _close(e: Event | null, idx: number, includeNonCloseable: boolean): boolean {\n    if (e != null) {\n      e.preventDefault();\n      e.stopPropagation();\n    }\n    const item = this.list[idx];\n    (this.canClose ? this.canClose({ item, includeNonCloseable }) : of(true)).pipe(filter(v => v)).subscribe(() => {\n      this.srv.close(item.url, includeNonCloseable);\n      this.close.emit(item);\n      this.cdr.detectChanges();\n    });\n    return false;\n  }\n\n  /**\n   * 设置激活路由的实例，在 `src/app/layout/basic/basic.component.ts` 修改：\n   *\n   * @example\n   * <reuse-tab #reuseTab></reuse-tab>\n   * <router-outlet (activate)=\"reuseTab.activate($event)\" (attach)=\"reuseTab.activate($event)\"></router-outlet>\n   */\n  activate(instance: NzSafeAny): void {\n    this.srv.componentRef = { instance };\n  }\n\n  private updatePos(): void {\n    const url = this.srv.getUrl(this.route.snapshot);\n    const ls = this.list.filter(w => w.url === url || !this.srv.isExclude(w.url));\n    if (ls.length === 0) {\n      return;\n    }\n\n    const last = ls[ls.length - 1];\n    const item = ls.find(w => w.url === url);\n    last.last = true;\n    const pos = item == null ? last.index : item.index;\n    ls.forEach((i, idx) => (i.active = pos === idx));\n    this.pos = pos;\n    // TODO: 目前无法知道为什么 `pos` 无法通过 `nzSelectedIndex` 生效，因此强制使用组件实例的方式来修改，这种方式是安全的\n    // https://github.com/ng-alain/ng-alain/issues/1736\n    this.tabset.nzSelectedIndex = pos;\n    this.list = ls;\n    this.cdr.detectChanges();\n    this.saveState();\n  }\n\n  // #endregion\n\n  ngOnInit(): void {\n    this.dir = this.directionality.value;\n    this.directionality.change?.pipe(takeUntil(this.destroy$)).subscribe((direction: Direction) => {\n      this.dir = direction;\n      this.cdr.detectChanges();\n    });\n\n    if (!this.platform.isBrowser) {\n      return;\n    }\n\n    this.srv.change.pipe(takeUntil(this.destroy$)).subscribe(res => {\n      switch (res?.active) {\n        case 'title':\n          this.updateTitle(res);\n          return;\n        case 'override':\n          if (res?.list?.length === this.list.length) {\n            this.updatePos();\n            return;\n          }\n          break;\n      }\n      this.genList(res);\n    });\n\n    this.i18nSrv.change\n      .pipe(\n        filter(() => this.srv.inited),\n        takeUntil(this.destroy$),\n        debounceTime(100)\n      )\n      .subscribe(() => this.genList({ active: 'title' }));\n\n    this.srv.init();\n  }\n\n  ngOnChanges(changes: { [P in keyof this]?: SimpleChange } & SimpleChanges): void {\n    if (!this.platform.isBrowser) {\n      return;\n    }\n\n    if (changes.max) this.srv.max = this.max!;\n    if (changes.excludes) this.srv.excludes = this.excludes!;\n    if (changes.mode) this.srv.mode = this.mode;\n    if (changes.routeParamMatchMode) this.srv.routeParamMatchMode = this.routeParamMatchMode;\n    if (changes.keepingScroll) {\n      this.srv.keepingScroll = this.keepingScroll;\n      this.srv.keepingScrollContainer = this._keepingScrollContainer;\n    }\n    if (changes.storageState) this.srv.storageState = this.storageState;\n\n    this.srv.debug = this.debug;\n\n    this.cdr.detectChanges();\n  }\n\n  ngOnDestroy(): void {\n    const { destroy$ } = this;\n    destroy$.next();\n    destroy$.complete();\n  }\n}\n","<nz-tabset\n  #tabset\n  [nzSelectedIndex]=\"pos\"\n  [nzAnimated]=\"false\"\n  [nzType]=\"tabType\"\n  [nzTabBarExtraContent]=\"tabBarExtraContent\"\n  [nzTabBarGutter]=\"tabBarGutter\"\n  [nzTabBarStyle]=\"tabBarStyle\"\n>\n  <nz-tab *ngFor=\"let i of list; let index = index\" [nzTitle]=\"titleTemplate\" (nzClick)=\"_to(index)\">\n    <ng-template #titleTemplate>\n      <div\n        [reuse-tab-context-menu]=\"i\"\n        [customContextMenu]=\"customContextMenu\"\n        class=\"reuse-tab__name\"\n        [attr.title]=\"i.title\"\n      >\n        <span [class.reuse-tab__name-width]=\"tabMaxWidth\" [style.max-width.px]=\"tabMaxWidth\">\n          <ng-container\n            *ngIf=\"titleRender; else defaultTitle\"\n            [ngTemplateOutlet]=\"titleRender\"\n            [ngTemplateOutletContext]=\"{ $implicit: i }\"\n          ></ng-container>\n          <ng-template #defaultTitle>{{ i.title }}</ng-template>\n        </span>\n      </div>\n      <i *ngIf=\"i.closable\" nz-icon nzType=\"close\" class=\"reuse-tab__op\" (click)=\"_close($event, index, false)\"></i>\n    </ng-template>\n  </nz-tab>\n</nz-tabset>\n<reuse-tab-context [i18n]=\"i18n\" (change)=\"contextMenuChange($event)\"></reuse-tab-context>\n"]}

package/esm2022/reuse-tab/reuse-tab.module.mjs

@@ -0,0 +1,50 @@
+import { OverlayModule } from '@angular/cdk/overlay';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { DelonLocaleModule } from '@delon/theme';
+import { NzIconModule } from 'ng-zorro-antd/icon';
+import { NzMenuModule } from 'ng-zorro-antd/menu';
+import { NzTabsModule } from 'ng-zorro-antd/tabs';
+import { ReuseTabContextMenuComponent } from './reuse-tab-context-menu.component';
+import { ReuseTabContextComponent } from './reuse-tab-context.component';
+import { ReuseTabContextDirective } from './reuse-tab-context.directive';
+import { ReuseTabComponent } from './reuse-tab.component';
+import { ReuseTabLocalStorageState, REUSE_TAB_STORAGE_KEY, REUSE_TAB_STORAGE_STATE } from './reuse-tab.state';
+import * as i0 from "@angular/core";
+const COMPONENTS = [ReuseTabComponent];
+const NOEXPORTS = [ReuseTabContextMenuComponent, ReuseTabContextComponent, ReuseTabContextDirective];
+class ReuseTabModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: ReuseTabModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.4", ngImport: i0, type: ReuseTabModule, declarations: [ReuseTabComponent, ReuseTabContextMenuComponent, ReuseTabContextComponent, ReuseTabContextDirective], imports: [CommonModule, RouterModule, DelonLocaleModule, NzMenuModule, NzTabsModule, NzIconModule, OverlayModule], exports: [ReuseTabComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: ReuseTabModule, providers: [
+            {
+                provide: REUSE_TAB_STORAGE_KEY,
+                useValue: '_reuse-tab-state'
+            },
+            {
+                provide: REUSE_TAB_STORAGE_STATE,
+                useFactory: () => new ReuseTabLocalStorageState()
+            }
+        ], imports: [CommonModule, RouterModule, DelonLocaleModule, NzMenuModule, NzTabsModule, NzIconModule, OverlayModule] }); }
+}
+export { ReuseTabModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: ReuseTabModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, RouterModule, DelonLocaleModule, NzMenuModule, NzTabsModule, NzIconModule, OverlayModule],
+                    declarations: [...COMPONENTS, ...NOEXPORTS],
+                    providers: [
+                        {
+                            provide: REUSE_TAB_STORAGE_KEY,
+                            useValue: '_reuse-tab-state'
+                        },
+                        {
+                            provide: REUSE_TAB_STORAGE_STATE,
+                            useFactory: () => new ReuseTabLocalStorageState()
+                        }
+                    ],
+                    exports: COMPONENTS
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV1c2UtdGFiLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FiYy9yZXVzZS10YWIvcmV1c2UtdGFiLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDckQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRS9DLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUNqRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVsRCxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUNsRixPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN6RSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN6RSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUMxRCxPQUFPLEVBQUUseUJBQXlCLEVBQUUscUJBQXFCLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQzs7QUFFOUcsTUFBTSxVQUFVLEdBQUcsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0FBQ3ZDLE1BQU0sU0FBUyxHQUFHLENBQUMsNEJBQTRCLEVBQUUsd0JBQXdCLEVBQUUsd0JBQXdCLENBQUMsQ0FBQztBQUVyRyxNQWVhLGNBQWM7OEdBQWQsY0FBYzsrR0FBZCxjQUFjLGlCQWxCUCxpQkFBaUIsRUFDbEIsNEJBQTRCLEVBQUUsd0JBQXdCLEVBQUUsd0JBQXdCLGFBR3ZGLFlBQVksRUFBRSxZQUFZLEVBQUUsaUJBQWlCLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxZQUFZLEVBQUUsYUFBYSxhQUo5RixpQkFBaUI7K0dBa0J4QixjQUFjLGFBWmQ7WUFDVDtnQkFDRSxPQUFPLEVBQUUscUJBQXFCO2dCQUM5QixRQUFRLEVBQUUsa0JBQWtCO2FBQzdCO1lBQ0Q7Z0JBQ0UsT0FBTyxFQUFFLHVCQUF1QjtnQkFDaEMsVUFBVSxFQUFFLEdBQUcsRUFBRSxDQUFDLElBQUkseUJBQXlCLEVBQUU7YUFDbEQ7U0FDRixZQVhTLFlBQVksRUFBRSxZQUFZLEVBQUUsaUJBQWlCLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxZQUFZLEVBQUUsYUFBYTs7U0FjckcsY0FBYzsyRkFBZCxjQUFjO2tCQWYxQixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxZQUFZLEVBQUUsaUJBQWlCLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxZQUFZLEVBQUUsYUFBYSxDQUFDO29CQUNqSCxZQUFZLEVBQUUsQ0FBQyxHQUFHLFVBQVUsRUFBRSxHQUFHLFNBQVMsQ0FBQztvQkFDM0MsU0FBUyxFQUFFO3dCQUNUOzRCQUNFLE9BQU8sRUFBRSxxQkFBcUI7NEJBQzlCLFFBQVEsRUFBRSxrQkFBa0I7eUJBQzdCO3dCQUNEOzRCQUNFLE9BQU8sRUFBRSx1QkFBdUI7NEJBQ2hDLFVBQVUsRUFBRSxHQUFHLEVBQUUsQ0FBQyxJQUFJLHlCQUF5QixFQUFFO3lCQUNsRDtxQkFDRjtvQkFDRCxPQUFPLEVBQUUsVUFBVTtpQkFDcEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPdmVybGF5TW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL292ZXJsYXknO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBSb3V0ZXJNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuXG5pbXBvcnQgeyBEZWxvbkxvY2FsZU1vZHVsZSB9IGZyb20gJ0BkZWxvbi90aGVtZSc7XG5pbXBvcnQgeyBOekljb25Nb2R1bGUgfSBmcm9tICduZy16b3Jyby1hbnRkL2ljb24nO1xuaW1wb3J0IHsgTnpNZW51TW9kdWxlIH0gZnJvbSAnbmctem9ycm8tYW50ZC9tZW51JztcbmltcG9ydCB7IE56VGFic01vZHVsZSB9IGZyb20gJ25nLXpvcnJvLWFudGQvdGFicyc7XG5cbmltcG9ydCB7IFJldXNlVGFiQ29udGV4dE1lbnVDb21wb25lbnQgfSBmcm9tICcuL3JldXNlLXRhYi1jb250ZXh0LW1lbnUuY29tcG9uZW50JztcbmltcG9ydCB7IFJldXNlVGFiQ29udGV4dENvbXBvbmVudCB9IGZyb20gJy4vcmV1c2UtdGFiLWNvbnRleHQuY29tcG9uZW50JztcbmltcG9ydCB7IFJldXNlVGFiQ29udGV4dERpcmVjdGl2ZSB9IGZyb20gJy4vcmV1c2UtdGFiLWNvbnRleHQuZGlyZWN0aXZlJztcbmltcG9ydCB7IFJldXNlVGFiQ29tcG9uZW50IH0gZnJvbSAnLi9yZXVzZS10YWIuY29tcG9uZW50JztcbmltcG9ydCB7IFJldXNlVGFiTG9jYWxTdG9yYWdlU3RhdGUsIFJFVVNFX1RBQl9TVE9SQUdFX0tFWSwgUkVVU0VfVEFCX1NUT1JBR0VfU1RBVEUgfSBmcm9tICcuL3JldXNlLXRhYi5zdGF0ZSc7XG5cbmNvbnN0IENPTVBPTkVOVFMgPSBbUmV1c2VUYWJDb21wb25lbnRdO1xuY29uc3QgTk9FWFBPUlRTID0gW1JldXNlVGFiQ29udGV4dE1lbnVDb21wb25lbnQsIFJldXNlVGFiQ29udGV4dENvbXBvbmVudCwgUmV1c2VUYWJDb250ZXh0RGlyZWN0aXZlXTtcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgUm91dGVyTW9kdWxlLCBEZWxvbkxvY2FsZU1vZHVsZSwgTnpNZW51TW9kdWxlLCBOelRhYnNNb2R1bGUsIE56SWNvbk1vZHVsZSwgT3ZlcmxheU1vZHVsZV0sXG4gIGRlY2xhcmF0aW9uczogWy4uLkNPTVBPTkVOVFMsIC4uLk5PRVhQT1JUU10sXG4gIHByb3ZpZGVyczogW1xuICAgIHtcbiAgICAgIHByb3ZpZGU6IFJFVVNFX1RBQl9TVE9SQUdFX0tFWSxcbiAgICAgIHVzZVZhbHVlOiAnX3JldXNlLXRhYi1zdGF0ZSdcbiAgICB9LFxuICAgIHtcbiAgICAgIHByb3ZpZGU6IFJFVVNFX1RBQl9TVE9SQUdFX1NUQVRFLFxuICAgICAgdXNlRmFjdG9yeTogKCkgPT4gbmV3IFJldXNlVGFiTG9jYWxTdG9yYWdlU3RhdGUoKVxuICAgIH1cbiAgXSxcbiAgZXhwb3J0czogQ09NUE9ORU5UU1xufSlcbmV4cG9ydCBjbGFzcyBSZXVzZVRhYk1vZHVsZSB7fVxuIl19