@coolon/angular-ui-powerups 16.1.0-aplpha.151 → 16.1.0-aplpha.153

package/esm2022/lib/components/tables/renderer/table-action-column/table-action-column.component.mjs

@@ -0,0 +1,147 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import { MatMenuTrigger } from '@angular/material/menu';
+import { DisposableComponent } from '../../../disposable-component';
+import { Track } from '../../../track';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../../commands/group/tool-bar/tool-bar.component";
+import * as i3 from "../../../commands/command/command.component";
+import * as i4 from "../../../commands/group/popup-menu/more-menu.component";
+import * as i5 from "../../../commands/separator.component";
+import * as i6 from "../../../commands/flex.component";
+import * as i7 from "../../../file/file-download/file-download.component";
+// TODO: This performs poorly, lots of factory calls initial rendering and on mouse movements
+class CommandData {
+    factory;
+    face;
+    constructor(factory, face) {
+        this.factory = factory;
+        this.face = face;
+    }
+}
+class DownloadData {
+    createInfo;
+    constructor(createInfo) {
+        this.createInfo = createInfo;
+    }
+    createDownloadInfo(value) {
+        return this.createInfo(value);
+    }
+}
+/**
+ *
+ */
+export class TableActionColumnComponent extends DisposableComponent {
+    value;
+    menu;
+    actions = [];
+    moreActions = [];
+    trackByIndex = Track.byIndex;
+    constructor() {
+        super();
+        this.onInit(() => console.log("table action column init"));
+    }
+    addCommand(commandFactory, properties) {
+        this.actions.push(new CommandData(commandFactory, properties));
+    }
+    addSeparator() {
+        this.actions.push(null);
+    }
+    addDownload(factory) {
+        this.actions.push(new DownloadData(factory));
+    }
+    addMoreMenu(builder) {
+        const self = this;
+        builder({
+            addCommand(factory, face) {
+                self.moreActions.push(new CommandData(factory, face));
+            },
+            addSeparator() {
+                self.moreActions.push(null);
+            },
+            addDownload(factory) {
+                self.moreActions.push(new DownloadData(factory));
+            }
+        });
+    }
+    // createMoreMenuCommand(item: CommandData<T>, value: T): Command<void> {
+    //   const { when } = Dsl.disposeWith(this);
+    //   const command = item.factory.create(value, { disposedWith: this });
+    //   when(command.busy$).becomesFalsey(() => {
+    //     this.closeMoreMenu();
+    //   });
+    //   return command;
+    // }
+    closeMoreMenu() {
+        this.menu.closeMenu();
+    }
+    isCommand(item) {
+        return item instanceof CommandData;
+    }
+    isDownload(item) {
+        return item instanceof DownloadData;
+    }
+    isSeparator(item) {
+        return !item;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: TableActionColumnComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.9", type: TableActionColumnComponent, selector: "aup-table-action-column", inputs: { value: "value" }, viewQueries: [{ propertyName: "menu", first: true, predicate: MatMenuTrigger, descendants: true }], usesInheritance: true, ngImport: i0, template: `
+    <aup-tool-bar>
+      <ng-container *ngFor="let action of actions;trackBy: trackByIndex">
+        <aup-command *ngIf="isCommand(action)"
+                     #comp
+                     [command]="action.factory.create(value, {disposedWith: comp})"
+                     [face]="action.face" />
+        <aup-file-download *ngIf="isDownload(action)" [download]="action.createDownloadInfo(value)" />
+        <aup-separator *ngIf="isSeparator(action)" />
+      </ng-container>
+    </aup-tool-bar>
+    <ng-container *ngIf="moreActions.length > 0">
+      <aup-flex class="flex" />
+      <aup-more-menu>
+        <ng-container *ngFor="let action of moreActions; trackBy: trackByIndex">
+          <aup-command *ngIf="isCommand(action)"
+                       #comp
+                       [command]="action.factory.create(value, {disposedWith: comp})"
+                       [face]="action.face" />
+          <aup-file-download *ngIf="isDownload(action)" [download]="action.createDownloadInfo(value)" />
+          <aup-separator *ngIf="isSeparator(action)" />
+        </ng-container>
+      </aup-more-menu>
+    </ng-container>
+  `, isInline: true, styles: [":host{display:inline-flex;flex-direction:row;align-items:center}:host:last-child{padding-right:0}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.ToolBarComponent, selector: "aup-tool-bar" }, { kind: "component", type: i3.CommandComponent, selector: "aup-command", inputs: ["command", "face$", "face", "busyFace$", "busyFace", "alignFace"] }, { kind: "component", type: i4.MoreMenuComponent, selector: "aup-more-menu", inputs: ["tooltip"] }, { kind: "component", type: i5.SeparatorComponent, selector: "aup-separator" }, { kind: "component", type: i6.FlexComponent, selector: "aup-flex" }, { kind: "component", type: i7.FileDownloadComponent, selector: "aup-file-download", inputs: ["download$", "download", "alignFace"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: TableActionColumnComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'aup-table-action-column', template: `
+    <aup-tool-bar>
+      <ng-container *ngFor="let action of actions;trackBy: trackByIndex">
+        <aup-command *ngIf="isCommand(action)"
+                     #comp
+                     [command]="action.factory.create(value, {disposedWith: comp})"
+                     [face]="action.face" />
+        <aup-file-download *ngIf="isDownload(action)" [download]="action.createDownloadInfo(value)" />
+        <aup-separator *ngIf="isSeparator(action)" />
+      </ng-container>
+    </aup-tool-bar>
+    <ng-container *ngIf="moreActions.length > 0">
+      <aup-flex class="flex" />
+      <aup-more-menu>
+        <ng-container *ngFor="let action of moreActions; trackBy: trackByIndex">
+          <aup-command *ngIf="isCommand(action)"
+                       #comp
+                       [command]="action.factory.create(value, {disposedWith: comp})"
+                       [face]="action.face" />
+          <aup-file-download *ngIf="isDownload(action)" [download]="action.createDownloadInfo(value)" />
+          <aup-separator *ngIf="isSeparator(action)" />
+        </ng-container>
+      </aup-more-menu>
+    </ng-container>
+  `, styles: [":host{display:inline-flex;flex-direction:row;align-items:center}:host:last-child{padding-right:0}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { value: [{
+                type: Input
+            }], menu: [{
+                type: ViewChild,
+                args: [MatMenuTrigger]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-action-column.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/angular-ui-powerups/src/lib/components/tables/renderer/table-action-column/table-action-column.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, ViewChild } from '@angular/core';\nimport { MatMenuTrigger } from '@angular/material/menu';\n\nimport { Command, Dsl, Trace } from '@coolon/pectin';\nimport { CommandFace } from '../../../commands/command-face';\nimport { DisposableComponent } from '../../../disposable-component';\nimport { FileDownloadComponent } from '../../../file/file-download/file-download.component';\nimport { Track } from '../../../track';\nimport { CellRenderer } from '../cell-renderer';\nimport { MenuBuilder } from './menu-builder';\n\n\n// TODO: This performs poorly, lots of factory calls initial rendering and on mouse movements\n\nclass CommandData<T extends object> {\n  constructor(readonly factory: Command.Factory<T, void>, readonly face: CommandFace) {\n  }\n}\n\nclass DownloadData<T extends object> {\n  constructor(private createInfo: (value: T) => FileDownloadComponent.DownloadInfo) {\n  }\n\n  createDownloadInfo(value: T): FileDownloadComponent.DownloadInfo {\n    return this.createInfo(value);\n  }\n}\n\ntype MenuItem<T extends object> = CommandData<T> | DownloadData<T> | null;\n\n\n/**\n *\n */\n@Component({\n  selector: 'aup-table-action-column',\n  template: `\n    <aup-tool-bar>\n      <ng-container *ngFor=\"let action of actions;trackBy: trackByIndex\">\n        <aup-command *ngIf=\"isCommand(action)\"\n                     #comp\n                     [command]=\"action.factory.create(value, {disposedWith: comp})\"\n                     [face]=\"action.face\" />\n        <aup-file-download *ngIf=\"isDownload(action)\" [download]=\"action.createDownloadInfo(value)\" />\n        <aup-separator *ngIf=\"isSeparator(action)\" />\n      </ng-container>\n    </aup-tool-bar>\n    <ng-container *ngIf=\"moreActions.length > 0\">\n      <aup-flex class=\"flex\" />\n      <aup-more-menu>\n        <ng-container *ngFor=\"let action of moreActions; trackBy: trackByIndex\">\n          <aup-command *ngIf=\"isCommand(action)\"\n                       #comp\n                       [command]=\"action.factory.create(value, {disposedWith: comp})\"\n                       [face]=\"action.face\" />\n          <aup-file-download *ngIf=\"isDownload(action)\" [download]=\"action.createDownloadInfo(value)\" />\n          <aup-separator *ngIf=\"isSeparator(action)\" />\n        </ng-container>\n      </aup-more-menu>\n    </ng-container>\n  `,\n  styles: [`:host {\n    display: inline-flex;\n    flex-direction: row;\n    align-items: center;\n\n    &:last-child {\n      padding-right: 0;\n    }\n  }`]\n})\nexport class TableActionColumnComponent<T extends object> extends DisposableComponent implements CellRenderer<T>, MenuBuilder<T> {\n\n  @Input()\n  value: T;\n\n  @ViewChild(MatMenuTrigger)\n  menu: MatMenuTrigger;\n\n  readonly actions: MenuItem<T>[] = [];\n  readonly moreActions: MenuItem<T>[] = [];\n\n  readonly trackByIndex = Track.byIndex\n\n  constructor() {\n    super();\n    this.onInit(() => console.log(\"table action column init\"));\n  }\n\n  addCommand(commandFactory: Command.Factory<T, void>, properties: CommandFace) {\n    this.actions.push(new CommandData(commandFactory, properties));\n  }\n\n  addSeparator() {\n    this.actions.push(null);\n  }\n\n  addDownload(factory: (row: T) => FileDownloadComponent.DownloadInfo) {\n    this.actions.push(new DownloadData(factory));\n  }\n\n  addMoreMenu(builder: (menu: MenuBuilder<T>) => void) {\n    const self = this;\n    builder({\n      addCommand(factory: Command.Factory<T>, face: CommandFace) {\n        self.moreActions.push(new CommandData(factory, face));\n      },\n      addSeparator() {\n        self.moreActions.push(null);\n      },\n      addDownload(factory: (row: T) => FileDownloadComponent.DownloadInfo) {\n        self.moreActions.push(new DownloadData(factory));\n      }\n    });\n  }\n\n  // createMoreMenuCommand(item: CommandData<T>, value: T): Command<void> {\n  //   const { when } = Dsl.disposeWith(this);\n  //   const command = item.factory.create(value, { disposedWith: this });\n  //   when(command.busy$).becomesFalsey(() => {\n  //     this.closeMoreMenu();\n  //   });\n  //   return command;\n  // }\n\n  private closeMoreMenu() {\n    this.menu.closeMenu();\n  }\n\n  isCommand(item: MenuItem<T>): item is CommandData<T> {\n    return item instanceof CommandData;\n  }\n\n  isDownload(item: MenuItem<T>): item is DownloadData<T> {\n    return item instanceof DownloadData;\n  }\n\n  isSeparator(item: MenuItem<T>) {\n    return !item;\n  }\n}\n"]}

package/esm2022/lib/components/tables/renderer/table-custom-more-menu/table-custom-more-menu-popup.component.mjs

@@ -0,0 +1,45 @@
+import { Component } from "@angular/core";
+import { DelegatingCommand, DelegatingValueModel } from "@coolon/pectin";
+import { POPUP_CONTAINER } from "../../../commands/group/popup-container";
+import { LoadableComponent } from "../../../loadable-component";
+import * as i0 from "@angular/core";
+export class TableCustomMoreMenuPopupComponent extends LoadableComponent {
+    _value$ = this.registerDisposable(new DelegatingValueModel());
+    _visible$ = this.registerDisposable(new DelegatingValueModel()).withDefault(true);
+    _closeCommand = this.registerDisposable(new DelegatingCommand());
+    constructor() {
+        super();
+        this.onInit(() => console.log('init'));
+    }
+    initialise(row$, closeCommand) {
+        this._value$.setDelegate(row$);
+        this._closeCommand.setDelegate(closeCommand);
+    }
+    visibleWhile(condition) {
+        this._visible$.setDelegate(condition);
+        return this;
+    }
+    get visible$() {
+        return this._visible$.readonly$;
+    }
+    get closeCommand() {
+        return this._closeCommand;
+    }
+    get value$() {
+        return this._value$.readonly$;
+    }
+    register(comp) {
+        // ignored
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: TableCustomMoreMenuPopupComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.9", type: TableCustomMoreMenuPopupComponent, selector: "aup-table-more-menu-popup", providers: [
+            { provide: POPUP_CONTAINER, useValue: TableCustomMoreMenuPopupComponent },
+        ], usesInheritance: true, ngImport: i0, template: '', isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: TableCustomMoreMenuPopupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'aup-table-more-menu-popup', template: '', providers: [
+                        { provide: POPUP_CONTAINER, useValue: TableCustomMoreMenuPopupComponent },
+                    ] }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/tables/renderer/table-custom-more-menu/table-custom-more-menu.component.mjs

@@ -0,0 +1,71 @@
+import { __decorate, __metadata } from "tslib";
+import { ComponentPortal } from "@angular/cdk/portal";
+import { Component, HostListener, ViewChild } from "@angular/core";
+import { MatMenuTrigger } from "@angular/material/menu";
+import { Command, DelegatingValueModel, Dsl, MutableValueModel, StoreInValueModel, Trace } from '@coolon/pectin';
+import { DisposableComponent } from "../../../disposable-component";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/button";
+import * as i3 from "@angular/cdk/portal";
+import * as i4 from "@angular/material/menu";
+import * as i5 from "../../../icon/icon.component";
+export class TableCustomMoreMenuComponent extends DisposableComponent {
+    value$ = new MutableValueModel();
+    #value_accessor_storage;
+    get value() { return this.#value_accessor_storage; }
+    set value(value) { this.#value_accessor_storage = value; }
+    matMenuTrigger;
+    popupType$ = new MutableValueModel();
+    popupComponentPortal$;
+    _visible$ = this.registerDisposable(new DelegatingValueModel());
+    initialiseCallback;
+    constructor() {
+        super();
+        const { chain } = Dsl.disposeWith(this);
+        this.popupComponentPortal$ = chain(this.popupType$).map(type => new ComponentPortal(type));
+    }
+    configurePopupComponentType(popupComponentType, configureCallback) {
+        this.popupType$.value = popupComponentType;
+        this.initialiseCallback = configureCallback;
+    }
+    // Stops tree selection when clicking the menu button
+    preventDefault($event) {
+        $event.preventDefault();
+        $event.stopPropagation();
+    }
+    initialise($event) {
+        const component = $event.instance;
+        component.initialise(this.value$, Command.create(() => this.matMenuTrigger.closeMenu()));
+        this._visible$.setDelegate(component.visible$);
+        if (this.initialiseCallback) {
+            this.initialiseCallback(component);
+        }
+    }
+    get visible$() {
+        return this._visible$.readonly$;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: TableCustomMoreMenuComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.9", type: TableCustomMoreMenuComponent, selector: "aup-table-custom-more-menu", host: { listeners: { "click": "preventDefault($event)" } }, viewQueries: [{ propertyName: "matMenuTrigger", first: true, predicate: MatMenuTrigger, descendants: true }], usesInheritance: true, ngImport: i0, template: "<mat-menu #menu=\"matMenu\" xPosition=\"before\">\n  <ng-template matMenuContent [cdkPortalOutlet]=\"popupComponentPortal$.value\" (attached)=\"initialise($event)\"></ng-template>\n</mat-menu>\n\n<button mat-icon-button [matMenuTriggerFor]=\"menu\" data-cy=\"more-menu-trigger\" *ngIf=\"visible$.value\">\n  <aup-icon icon=\"mat:more_vert\"></aup-icon>\n</button>\n", styles: [":host{display:inline;text-align:end}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.MatIconButton, selector: "button[mat-icon-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "directive", type: i3.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: i4.MatMenu, selector: "mat-menu", exportAs: ["matMenu"] }, { kind: "directive", type: i4.MatMenuContent, selector: "ng-template[matMenuContent]" }, { kind: "directive", type: i4.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", exportAs: ["matMenuTrigger"] }, { kind: "component", type: i5.IconComponent, selector: "aup-icon", inputs: ["icon"] }] });
+}
+__decorate([
+    StoreInValueModel(),
+    __metadata("design:type", Object)
+], TableCustomMoreMenuComponent.prototype, "value", null);
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], TableCustomMoreMenuComponent.prototype, "initialise", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: TableCustomMoreMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "aup-table-custom-more-menu", template: "<mat-menu #menu=\"matMenu\" xPosition=\"before\">\n  <ng-template matMenuContent [cdkPortalOutlet]=\"popupComponentPortal$.value\" (attached)=\"initialise($event)\"></ng-template>\n</mat-menu>\n\n<button mat-icon-button [matMenuTriggerFor]=\"menu\" data-cy=\"more-menu-trigger\" *ngIf=\"visible$.value\">\n  <aup-icon icon=\"mat:more_vert\"></aup-icon>\n</button>\n", styles: [":host{display:inline;text-align:end}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { value: [], matMenuTrigger: [{
+                type: ViewChild,
+                args: [MatMenuTrigger]
+            }], preventDefault: [{
+                type: HostListener,
+                args: ["click", ["$event"]]
+            }], initialise: [] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtY3VzdG9tLW1vcmUtbWVudS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdWktcG93ZXJ1cHMvc3JjL2xpYi9jb21wb25lbnRzL3RhYmxlcy9yZW5kZXJlci90YWJsZS1jdXN0b20tbW9yZS1tZW51L3RhYmxlLWN1c3RvbS1tb3JlLW1lbnUuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLXVpLXBvd2VydXBzL3NyYy9saWIvY29tcG9uZW50cy90YWJsZXMvcmVuZGVyZXIvdGFibGUtY3VzdG9tLW1vcmUtbWVudS90YWJsZS1jdXN0b20tbW9yZS1tZW51LmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQTZCLGVBQWUsRUFBQyxNQUFNLHFCQUFxQixDQUFDO0FBQ2hGLE9BQU8sRUFBQyxTQUFTLEVBQWdCLFlBQVksRUFBRSxTQUFTLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDL0UsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLHdCQUF3QixDQUFDO0FBQ3RELE9BQU8sRUFDTCxPQUFPLEVBQ1Asb0JBQW9CLEVBQ3BCLEdBQUcsRUFDSCxpQkFBaUIsRUFDakIsaUJBQWlCLEVBQUUsS0FBSyxFQUV6QixNQUFNLGdCQUFnQixDQUFDO0FBRXhCLE9BQU8sRUFBQyxtQkFBbUIsRUFBQyxNQUFNLCtCQUErQixDQUFDOzs7Ozs7O0FBVWxFLE1BQU0sT0FBTyw0QkFBZ0MsU0FBUSxtQkFBbUI7SUFHOUQsTUFBTSxHQUFHLElBQUksaUJBQWlCLEVBQUssQ0FBQztJQUduQyx3QkFBUztJQUFULElBQUEsS0FBSywyQ0FBSTtJQUFULElBQUEsS0FBSyxpREFBSTtJQUdsQixjQUFjLENBQWlCO0lBRWQsVUFBVSxHQUFHLElBQUksaUJBQWlCLEVBQXVELENBQUM7SUFFM0cscUJBQXFCLENBQXlFO0lBRTdFLFNBQVMsR0FBRyxJQUFJLENBQUMsa0JBQWtCLENBQUMsSUFBSSxvQkFBb0IsRUFBVyxDQUFDLENBQUM7SUFDbEYsa0JBQWtCLENBQTZEO0lBRXZGO1FBQ0UsS0FBSyxFQUFFLENBQUM7UUFDUixNQUFNLEVBQUUsS0FBSyxFQUFFLEdBQUcsR0FBRyxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN4QyxJQUFJLENBQUMscUJBQXFCLEdBQUcsS0FBSyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLGVBQWUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQzdGLENBQUM7SUFFRCwyQkFBMkIsQ0FBQyxrQkFBdUUsRUFBRSxpQkFBNEU7UUFDL0ssSUFBSSxDQUFDLFVBQVUsQ0FBQyxLQUFLLEdBQUcsa0JBQWtCLENBQUM7UUFDM0MsSUFBSSxDQUFDLGtCQUFrQixHQUFHLGlCQUFpQixDQUFDO0lBQzlDLENBQUM7SUFFRCxxREFBcUQ7SUFFckQsY0FBYyxDQUFDLE1BQWtCO1FBQy9CLE1BQU0sQ0FBQyxjQUFjLEVBQUUsQ0FBQztRQUN4QixNQUFNLENBQUMsZUFBZSxFQUFFLENBQUM7SUFDM0IsQ0FBQztJQUdELFVBQVUsQ0FBQyxNQUFrQztRQUMzQyxNQUFNLFNBQVMsR0FBSSxNQUE2RCxDQUFDLFFBQVEsQ0FBQztRQUMxRixTQUFTLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUN6RixJQUFJLENBQUMsU0FBUyxDQUFDLFdBQVcsQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDL0MsSUFBSSxJQUFJLENBQUMsa0JBQWtCLEVBQUU7WUFDM0IsSUFBSSxDQUFDLGtCQUFrQixDQUFDLFNBQVMsQ0FBQyxDQUFDO1NBQ3BDO0lBQ0gsQ0FBQztJQUVELElBQUksUUFBUTtRQUNWLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUM7SUFDbEMsQ0FBQzt1R0FoRFUsNEJBQTRCOzJGQUE1Qiw0QkFBNEIsOEtBUTVCLGNBQWMsdUVDOUIzQiwrV0FPQTs7QURxQlc7SUFEUixpQkFBaUIsRUFBRTs7eURBQ0Y7QUErQmxCO0lBREMsS0FBSyxFQUFFOzs7OzhEQVFQOzJGQTVDVSw0QkFBNEI7a0JBTHhDLFNBQVM7K0JBQ0UsNEJBQTRCOzBFQVU3QixLQUFLLE1BR2QsY0FBYztzQkFEYixTQUFTO3VCQUFDLGNBQWM7Z0JBdUJ6QixjQUFjO3NCQURiLFlBQVk7dUJBQUMsT0FBTyxFQUFFLENBQUMsUUFBUSxDQUFDO2dCQU9qQyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDZGtQb3J0YWxPdXRsZXRBdHRhY2hlZFJlZiwgQ29tcG9uZW50UG9ydGFsfSBmcm9tIFwiQGFuZ3VsYXIvY2RrL3BvcnRhbFwiO1xuaW1wb3J0IHtDb21wb25lbnQsIENvbXBvbmVudFJlZiwgSG9zdExpc3RlbmVyLCBWaWV3Q2hpbGR9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQge01hdE1lbnVUcmlnZ2VyfSBmcm9tIFwiQGFuZ3VsYXIvbWF0ZXJpYWwvbWVudVwiO1xuaW1wb3J0IHtcbiAgQ29tbWFuZCxcbiAgRGVsZWdhdGluZ1ZhbHVlTW9kZWwsXG4gIERzbCxcbiAgTXV0YWJsZVZhbHVlTW9kZWwsXG4gIFN0b3JlSW5WYWx1ZU1vZGVsLCBUcmFjZSxcbiAgVmFsdWVNb2RlbENoYWluXG59IGZyb20gJ0Bjb29sb24vcGVjdGluJztcbmltcG9ydCB7Q29uc3RydWN0YWJsZX0gZnJvbSBcIkBjb29sb24vdHlwZXNjcmlwdC11dGlsaXRpZXNcIjtcbmltcG9ydCB7RGlzcG9zYWJsZUNvbXBvbmVudH0gZnJvbSBcIi4uLy4uLy4uL2Rpc3Bvc2FibGUtY29tcG9uZW50XCI7XG5pbXBvcnQge0xvYWRhYmxlQ29tcG9uZW50fSBmcm9tIFwiLi4vLi4vLi4vbG9hZGFibGUtY29tcG9uZW50XCI7XG5pbXBvcnQge0NlbGxSZW5kZXJlcn0gZnJvbSBcIi4uL2NlbGwtcmVuZGVyZXJcIjtcbmltcG9ydCB7VGFibGVDdXN0b21Nb3JlTWVudVBvcHVwQ29tcG9uZW50fSBmcm9tIFwiLi90YWJsZS1jdXN0b20tbW9yZS1tZW51LXBvcHVwLmNvbXBvbmVudFwiO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6IFwiYXVwLXRhYmxlLWN1c3RvbS1tb3JlLW1lbnVcIixcbiAgdGVtcGxhdGVVcmw6IFwiLi90YWJsZS1jdXN0b20tbW9yZS1tZW51LmNvbXBvbmVudC5odG1sXCIsXG4gIHN0eWxlVXJsczogW1wiLi90YWJsZS1jdXN0b20tbW9yZS1tZW51LmNvbXBvbmVudC5zY3NzXCJdXG59KVxuZXhwb3J0IGNsYXNzIFRhYmxlQ3VzdG9tTW9yZU1lbnVDb21wb25lbnQ8VD4gZXh0ZW5kcyBEaXNwb3NhYmxlQ29tcG9uZW50IGltcGxlbWVudHMgQ2VsbFJlbmRlcmVyPFQ+IHtcblxuXG4gIHByaXZhdGUgdmFsdWUkID0gbmV3IE11dGFibGVWYWx1ZU1vZGVsPFQ+KCk7XG5cbiAgQFN0b3JlSW5WYWx1ZU1vZGVsKClcbiAgYWNjZXNzb3IgdmFsdWU6IFQ7XG5cbiAgQFZpZXdDaGlsZChNYXRNZW51VHJpZ2dlcilcbiAgbWF0TWVudVRyaWdnZXI6IE1hdE1lbnVUcmlnZ2VyO1xuXG4gIHByaXZhdGUgcmVhZG9ubHkgcG9wdXBUeXBlJCA9IG5ldyBNdXRhYmxlVmFsdWVNb2RlbDxDb25zdHJ1Y3RhYmxlPFRhYmxlQ3VzdG9tTW9yZU1lbnVQb3B1cENvbXBvbmVudDxUPj4+KCk7XG5cbiAgcG9wdXBDb21wb25lbnRQb3J0YWwkOiBWYWx1ZU1vZGVsQ2hhaW48Q29tcG9uZW50UG9ydGFsPFRhYmxlQ3VzdG9tTW9yZU1lbnVQb3B1cENvbXBvbmVudDxUPj4+O1xuXG4gIHByaXZhdGUgcmVhZG9ubHkgX3Zpc2libGUkID0gdGhpcy5yZWdpc3RlckRpc3Bvc2FibGUobmV3IERlbGVnYXRpbmdWYWx1ZU1vZGVsPGJvb2xlYW4+KCkpO1xuICBwcml2YXRlIGluaXRpYWxpc2VDYWxsYmFjaz86IChjb21wb25lbnQ6IFRhYmxlQ3VzdG9tTW9yZU1lbnVQb3B1cENvbXBvbmVudDxUPikgPT4gdm9pZDtcblxuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcigpO1xuICAgIGNvbnN0IHsgY2hhaW4gfSA9IERzbC5kaXNwb3NlV2l0aCh0aGlzKTtcbiAgICB0aGlzLnBvcHVwQ29tcG9uZW50UG9ydGFsJCA9IGNoYWluKHRoaXMucG9wdXBUeXBlJCkubWFwKHR5cGUgPT4gbmV3IENvbXBvbmVudFBvcnRhbCh0eXBlKSk7XG4gIH1cblxuICBjb25maWd1cmVQb3B1cENvbXBvbmVudFR5cGUocG9wdXBDb21wb25lbnRUeXBlOiBDb25zdHJ1Y3RhYmxlPFRhYmxlQ3VzdG9tTW9yZU1lbnVQb3B1cENvbXBvbmVudDxUPj4sIGNvbmZpZ3VyZUNhbGxiYWNrPzogKGNvbXBvbmVudDpUYWJsZUN1c3RvbU1vcmVNZW51UG9wdXBDb21wb25lbnQ8VD4pID0+IHZvaWQpIHtcbiAgICB0aGlzLnBvcHVwVHlwZSQudmFsdWUgPSBwb3B1cENvbXBvbmVudFR5cGU7XG4gICAgdGhpcy5pbml0aWFsaXNlQ2FsbGJhY2sgPSBjb25maWd1cmVDYWxsYmFjaztcbiAgfVxuXG4gIC8vIFN0b3BzIHRyZWUgc2VsZWN0aW9uIHdoZW4gY2xpY2tpbmcgdGhlIG1lbnUgYnV0dG9uXG4gIEBIb3N0TGlzdGVuZXIoXCJjbGlja1wiLCBbXCIkZXZlbnRcIl0pXG4gIHByZXZlbnREZWZhdWx0KCRldmVudDogTW91c2VFdmVudCkge1xuICAgICRldmVudC5wcmV2ZW50RGVmYXVsdCgpO1xuICAgICRldmVudC5zdG9wUHJvcGFnYXRpb24oKTtcbiAgfVxuXG4gIEBUcmFjZSgpXG4gIGluaXRpYWxpc2UoJGV2ZW50OiBDZGtQb3J0YWxPdXRsZXRBdHRhY2hlZFJlZikge1xuICAgIGNvbnN0IGNvbXBvbmVudCA9ICgkZXZlbnQgYXMgQ29tcG9uZW50UmVmPFRhYmxlQ3VzdG9tTW9yZU1lbnVQb3B1cENvbXBvbmVudDxUPj4pLmluc3RhbmNlO1xuICAgIGNvbXBvbmVudC5pbml0aWFsaXNlKHRoaXMudmFsdWUkLCBDb21tYW5kLmNyZWF0ZSgoKSA9PiB0aGlzLm1hdE1lbnVUcmlnZ2VyLmNsb3NlTWVudSgpKSk7XG4gICAgdGhpcy5fdmlzaWJsZSQuc2V0RGVsZWdhdGUoY29tcG9uZW50LnZpc2libGUkKTtcbiAgICBpZiAodGhpcy5pbml0aWFsaXNlQ2FsbGJhY2spIHtcbiAgICAgIHRoaXMuaW5pdGlhbGlzZUNhbGxiYWNrKGNvbXBvbmVudCk7XG4gICAgfVxuICB9XG5cbiAgZ2V0IHZpc2libGUkKCkge1xuICAgIHJldHVybiB0aGlzLl92aXNpYmxlJC5yZWFkb25seSQ7XG4gIH1cblxufVxuIiwiPG1hdC1tZW51ICNtZW51PVwibWF0TWVudVwiIHhQb3NpdGlvbj1cImJlZm9yZVwiPlxuICA8bmctdGVtcGxhdGUgbWF0TWVudUNvbnRlbnQgW2Nka1BvcnRhbE91dGxldF09XCJwb3B1cENvbXBvbmVudFBvcnRhbCQudmFsdWVcIiAoYXR0YWNoZWQpPVwiaW5pdGlhbGlzZSgkZXZlbnQpXCI+PC9uZy10ZW1wbGF0ZT5cbjwvbWF0LW1lbnU+XG5cbjxidXR0b24gbWF0LWljb24tYnV0dG9uIFttYXRNZW51VHJpZ2dlckZvcl09XCJtZW51XCIgZGF0YS1jeT1cIm1vcmUtbWVudS10cmlnZ2VyXCIgKm5nSWY9XCJ2aXNpYmxlJC52YWx1ZVwiPlxuICA8YXVwLWljb24gaWNvbj1cIm1hdDptb3JlX3ZlcnRcIj48L2F1cC1pY29uPlxuPC9idXR0b24+XG4iXX0=