@huntsman-cancer-institute/dictionary-editor 16.0.1 → 17.0.1

package/esm2022/grid-editors/select.editor.mjs

@@ -1,138 +1,138 @@
-import { Component } from "@angular/core";
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common";
-import * as i2 from "@angular/forms";
-//import {MatDialog, MatDialogConfig, MatDialogRef} from "@angular/material/dialog";
-//import {SpinnerDialogComponent} from "../popup/spinner-dialog.component";
-export class SelectEditor {
-    get options() {
-        if (this.using_selectOptionsPerRowFilterFunction) {
-            return this._filteredOptions;
-        }
-        else {
-            return this._options;
-        }
-    }
-    set options(value) {
-        this._options = value;
-    }
-    //    private spinnerDialogRefs: MatDialogRef<SpinnerDialogComponent>[] = [];
-    constructor() {
-        this.using_selectOptionsPerRowFilterFunction = false;
-        this._spinnerDialogIsOpen = false;
-    }
-    agInit(params) {
-        this.params = params;
-        this.options = [];
-        this.optionsValueField = "";
-        this.optionsDisplayField = "";
-        if (this.params && this.params.column && this.params.column.colDef) {
-            this.gridValueField = this.params.column.colDef.field;
-            this.options = this.params.column.colDef.selectOptions;
-            this.optionsValueField = this.params.column.colDef.selectOptionsValueField;
-            this.optionsDisplayField = this.params.column.colDef.selectOptionsDisplayField;
-            if (this.params.column.colDef.selectOptionsPerRowFilterFunction) {
-                let backup = this.selectOptionsPerRowFilterFunction;
-                try {
-                    this.selectOptionsPerRowFilterFunction = this.params.column.colDef.selectOptionsPerRowFilterFunction;
-                    this.using_selectOptionsPerRowFilterFunction = !!this.selectOptionsPerRowFilterFunction;
-                }
-                catch (e) {
-                    console.error("selectOptionsPerRowFilterFunction option has wrong signature for column : " + this.params.column.colDef.headerName + "\n"
-                        + "  Requires signature (context:any, rowData: any, option: any) => boolean");
-                    this.selectOptionsPerRowFilterFunction = backup;
-                    this.using_selectOptionsPerRowFilterFunction = !!backup;
-                }
-            }
-            this.context = this.params.column.colDef.context;
-            this.fillGroupAttribute = this.params.column.colDef.fillGroupAttribute;
-            this.fillAll = this.params.column.colDef.fillAll && ("" + this.params.column.colDef.fillAll).toLowerCase() !== "false";
-            this.showFillButton = this.params.column.colDef.showFillButton && ("" + this.params.column.colDef.showFillButton).toLowerCase() !== "false";
-            if (this._options
-                && this.params.node
-                && this.params.node.data
-                && this.using_selectOptionsPerRowFilterFunction) {
-                this._filteredOptions = this._options.filter((option) => {
-                    return this.selectOptionsPerRowFilterFunction(this.context, this.params.node.data, option);
-                });
-            }
-        }
-        if (this.params) {
-            this.value = this.params.value ? "" + this.params.value : "";
-        }
-        if (this.showFillButton && !this.fillAll && (!this.fillGroupAttribute || this.fillGroupAttribute === "")) {
-            throw new Error("Invalid state, cannot use fill button without specifying the fillGroupAttribute or fillAll.");
-        }
-    }
-    ngOnDestroy() {
-        if (this.params && this.params.node && this.params.node[(this.gridValueField + "_originalValue")]) {
-            this.value = this.params.node[(this.gridValueField + "_originalValue")];
-        }
-    }
-    onChange(event) {
-        if (event && event.currentTarget) {
-            if (this.params && this.params.node && !this.params.node[(this.gridValueField + "_originalValue")]) {
-                this.params.node[(this.gridValueField + "_originalValue")] = this.value;
-            }
-            // This looks unnecessary, since this.value is linked to the value of the select component, but
-            // because this also ends editing, it also queues the destruction of this component and the call to getValue.
-            // The problem was that this.value isn't updated with the new value before this event fires,
-            // so we need to update it manually here.
-            this.value = event.currentTarget.value;
-            this.params.node.setDataValue(this.gridValueField, this.value);
-        }
-        if (this.params) {
-            //  If the fill button, which is part of the editor, is activated, don't stop editing
-            // immediately after making a selection.
-            if (!this.showFillButton) {
-                this.params.stopEditing();
-            }
-        }
-    }
-    getValue() {
-        return this.value ? this.value : "";
-    }
-    isPopup() {
-        return false;
-    }
-    onFillButtonClicked() {
-        if (!this.fillAll && (!this.fillGroupAttribute || this.fillGroupAttribute === "")) {
-            throw new Error('No column attribute "fillGroupAttribute" or "fillAll" specified. This is required to use the Fill functionality.');
-        }
-        if (this.params && this.params.column && this.params.column.gridApi && this.params.node && (this.fillAll || (this.fillGroupAttribute && this.fillGroupAttribute !== ""))) {
-            let thisRowNode = this.params.node;
-            //this.startSpinnerDialog();
-            this.params.column.gridApi.forEachNodeAfterFilter((rowNode) => {
-                if (rowNode && rowNode.data && thisRowNode && thisRowNode.data && (this.fillAll || rowNode.data[this.fillGroupAttribute] === thisRowNode.data[this.fillGroupAttribute])) {
-                    let spoofedEvent = {
-                        api: this.params.column.gridApi,
-                        colDef: this.params.column.colDef,
-                        column: this.params.column,
-                        columnApi: this.params.column.columnApi,
-                        context: undefined,
-                        data: rowNode.data,
-                        event: null,
-                        newValue: this.value,
-                        node: rowNode,
-                        oldValue: rowNode.data[this.gridValueField],
-                        rowIndex: rowNode.rowIndex,
-                        rowPinned: undefined,
-                        type: "cellValueChanged",
-                        value: this.value
-                    };
-                    rowNode.data[this.gridValueField] = this.value;
-                    rowNode.setDataValue(this.gridValueField, this.value);
-                    this.params.column.gridApi.dispatchEvent(spoofedEvent);
-                }
-            });
-            this.params.column.gridApi.refreshCells();
-            setTimeout(() => {
-                //this.stopSpinnerDialogs();
-            });
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SelectEditor, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: SelectEditor, selector: "ng-component", ngImport: i0, template: `
+import { Component } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+//import {MatDialog, MatDialogConfig, MatDialogRef} from "@angular/material/dialog";
+//import {SpinnerDialogComponent} from "../popup/spinner-dialog.component";
+export class SelectEditor {
+    get options() {
+        if (this.using_selectOptionsPerRowFilterFunction) {
+            return this._filteredOptions;
+        }
+        else {
+            return this._options;
+        }
+    }
+    set options(value) {
+        this._options = value;
+    }
+    //    private spinnerDialogRefs: MatDialogRef<SpinnerDialogComponent>[] = [];
+    constructor() {
+        this.using_selectOptionsPerRowFilterFunction = false;
+        this._spinnerDialogIsOpen = false;
+    }
+    agInit(params) {
+        this.params = params;
+        this.options = [];
+        this.optionsValueField = "";
+        this.optionsDisplayField = "";
+        if (this.params && this.params.column && this.params.column.colDef) {
+            this.gridValueField = this.params.column.colDef.field;
+            this.options = this.params.column.colDef.selectOptions;
+            this.optionsValueField = this.params.column.colDef.selectOptionsValueField;
+            this.optionsDisplayField = this.params.column.colDef.selectOptionsDisplayField;
+            if (this.params.column.colDef.selectOptionsPerRowFilterFunction) {
+                let backup = this.selectOptionsPerRowFilterFunction;
+                try {
+                    this.selectOptionsPerRowFilterFunction = this.params.column.colDef.selectOptionsPerRowFilterFunction;
+                    this.using_selectOptionsPerRowFilterFunction = !!this.selectOptionsPerRowFilterFunction;
+                }
+                catch (e) {
+                    console.error("selectOptionsPerRowFilterFunction option has wrong signature for column : " + this.params.column.colDef.headerName + "\n"
+                        + "  Requires signature (context:any, rowData: any, option: any) => boolean");
+                    this.selectOptionsPerRowFilterFunction = backup;
+                    this.using_selectOptionsPerRowFilterFunction = !!backup;
+                }
+            }
+            this.context = this.params.column.colDef.context;
+            this.fillGroupAttribute = this.params.column.colDef.fillGroupAttribute;
+            this.fillAll = this.params.column.colDef.fillAll && ("" + this.params.column.colDef.fillAll).toLowerCase() !== "false";
+            this.showFillButton = this.params.column.colDef.showFillButton && ("" + this.params.column.colDef.showFillButton).toLowerCase() !== "false";
+            if (this._options
+                && this.params.node
+                && this.params.node.data
+                && this.using_selectOptionsPerRowFilterFunction) {
+                this._filteredOptions = this._options.filter((option) => {
+                    return this.selectOptionsPerRowFilterFunction(this.context, this.params.node.data, option);
+                });
+            }
+        }
+        if (this.params) {
+            this.value = this.params.value ? "" + this.params.value : "";
+        }
+        if (this.showFillButton && !this.fillAll && (!this.fillGroupAttribute || this.fillGroupAttribute === "")) {
+            throw new Error("Invalid state, cannot use fill button without specifying the fillGroupAttribute or fillAll.");
+        }
+    }
+    ngOnDestroy() {
+        if (this.params && this.params.node && this.params.node[(this.gridValueField + "_originalValue")]) {
+            this.value = this.params.node[(this.gridValueField + "_originalValue")];
+        }
+    }
+    onChange(event) {
+        if (event && event.currentTarget) {
+            if (this.params && this.params.node && !this.params.node[(this.gridValueField + "_originalValue")]) {
+                this.params.node[(this.gridValueField + "_originalValue")] = this.value;
+            }
+            // This looks unnecessary, since this.value is linked to the value of the select component, but
+            // because this also ends editing, it also queues the destruction of this component and the call to getValue.
+            // The problem was that this.value isn't updated with the new value before this event fires,
+            // so we need to update it manually here.
+            this.value = event.currentTarget.value;
+            this.params.node.setDataValue(this.gridValueField, this.value);
+        }
+        if (this.params) {
+            //  If the fill button, which is part of the editor, is activated, don't stop editing
+            // immediately after making a selection.
+            if (!this.showFillButton) {
+                this.params.stopEditing();
+            }
+        }
+    }
+    getValue() {
+        return this.value ? this.value : "";
+    }
+    isPopup() {
+        return false;
+    }
+    onFillButtonClicked() {
+        if (!this.fillAll && (!this.fillGroupAttribute || this.fillGroupAttribute === "")) {
+            throw new Error('No column attribute "fillGroupAttribute" or "fillAll" specified. This is required to use the Fill functionality.');
+        }
+        if (this.params && this.params.column && this.params.column.gridApi && this.params.node && (this.fillAll || (this.fillGroupAttribute && this.fillGroupAttribute !== ""))) {
+            let thisRowNode = this.params.node;
+            //this.startSpinnerDialog();
+            this.params.column.gridApi.forEachNodeAfterFilter((rowNode) => {
+                if (rowNode && rowNode.data && thisRowNode && thisRowNode.data && (this.fillAll || rowNode.data[this.fillGroupAttribute] === thisRowNode.data[this.fillGroupAttribute])) {
+                    let spoofedEvent = {
+                        api: this.params.column.gridApi,
+                        colDef: this.params.column.colDef,
+                        column: this.params.column,
+                        columnApi: this.params.column.columnApi,
+                        context: undefined,
+                        data: rowNode.data,
+                        event: null,
+                        newValue: this.value,
+                        node: rowNode,
+                        oldValue: rowNode.data[this.gridValueField],
+                        rowIndex: rowNode.rowIndex,
+                        rowPinned: undefined,
+                        type: "cellValueChanged",
+                        value: this.value
+                    };
+                    rowNode.data[this.gridValueField] = this.value;
+                    rowNode.setDataValue(this.gridValueField, this.value);
+                    this.params.column.gridApi.dispatchEvent(spoofedEvent);
+                }
+            });
+            this.params.column.gridApi.refreshCells();
+            setTimeout(() => {
+                //this.stopSpinnerDialogs();
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: SelectEditor, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.2", type: SelectEditor, selector: "ng-component", ngImport: i0, template: `
         <div class="full-width full-height flex-column-container">
           <div class="full-height flex-stretch flex-row">
             <select class="full-width full-height" [(value)]="value" (change)="onChange($event)">
@@ -150,10 +150,10 @@ export class SelectEditor {
             <button class="full-height" (click)="onFillButtonClicked()">Fill</button>
           </div>
         </div>
-      `, isInline: true, styles: [".full-width{width:100%}.full-height{height:100%}.flex-column-container{display:flex;flex-direction:row}.flex-row{display:flex}.flex-stretch{display:flex;flex:1}\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: "directive", type: i2.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i2.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SelectEditor, decorators: [{
-            type: Component,
+      `, isInline: true, styles: [".full-width{width:100%}.full-height{height:100%}.flex-column-container{display:flex;flex-direction:row}.flex-row{display:flex}.flex-stretch{display:flex;flex:1}\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: "directive", type: i2.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i2.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: SelectEditor, decorators: [{
+            type: Component,
             args: [{ template: `
         <div class="full-width full-height flex-column-container">
           <div class="full-height flex-stretch flex-row">
@@ -172,6 +172,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             <button class="full-height" (click)="onFillButtonClicked()">Fill</button>
           </div>
         </div>
-      `, styles: [".full-width{width:100%}.full-height{height:100%}.flex-column-container{display:flex;flex-direction:row}.flex-row{display:flex}.flex-stretch{display:flex;flex:1}\n"] }]
-        }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.editor.js","sourceRoot":"","sources":["../../../../projects/dictionary-editor/src/grid-editors/select.editor.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, OnDestroy} from \"@angular/core\";\r\nimport {ICellEditorAngularComp} from \"ag-grid-angular\";\r\n//import {MatDialog, MatDialogConfig, MatDialogRef} from \"@angular/material/dialog\";\r\n//import {SpinnerDialogComponent} from \"../popup/spinner-dialog.component\";\r\n\r\n@Component(\r\n  {\r\n    template:\r\n      `\r\n        <div class=\"full-width full-height flex-column-container\">\r\n          <div class=\"full-height flex-stretch flex-row\">\r\n            <select class=\"full-width full-height\" [(value)]=\"value\" (change)=\"onChange($event)\">\r\n              <option hidden>\r\n                Select An Option\r\n              </option>\r\n              <option\r\n                *ngFor=\"let option of options\"\r\n                value=\"{{option.hasOwnProperty(optionsValueField) ? option[optionsValueField] : (option.value) ? option.value : option }}\">\r\n                {{option.hasOwnProperty(optionsDisplayField) ? option[optionsDisplayField] : (option.display) ? option.display : option }}\r\n              </option>\r\n            </select>\r\n          </div>\r\n          <div *ngIf=\"showFillButton\" class=\"full-height flex-row button-container\">\r\n            <button class=\"full-height\" (click)=\"onFillButtonClicked()\">Fill</button>\r\n          </div>\r\n        </div>\r\n      `\r\n    ,\r\n    styles: [\r\n      `\r\n        .full-width {\r\n          width: 100%;\r\n        }\r\n\r\n        .full-height {\r\n          height: 100%;\r\n        }\r\n\r\n        .flex-column-container {\r\n          display: flex;\r\n          flex-direction: row;\r\n        }\r\n\r\n        .flex-row {\r\n          display: flex;\r\n        }\r\n\r\n        .flex-stretch {\r\n          display: flex;\r\n          flex: 1;\r\n        }\r\n      `\r\n    ]\r\n  }\r\n)\r\nexport class SelectEditor implements ICellEditorAngularComp, OnDestroy {\r\n    public params: any;\r\n    public value: any;\r\n    private _options: any[];\r\n    public get options(): any[] {\r\n        if (this.using_selectOptionsPerRowFilterFunction) {\r\n            return this._filteredOptions;\r\n        } else {\r\n            return this._options;\r\n        }\r\n    }\r\n    public set options(value: any[]) {\r\n        this._options = value;\r\n    }\r\n\r\n    public optionsValueField: string;\r\n    public optionsDisplayField: string;\r\n\r\n    // variables used for the optional per-row-filtering\r\n    public context: any;\r\n    protected using_selectOptionsPerRowFilterFunction: boolean = false;\r\n    protected selectOptionsPerRowFilterFunction: (context: any, rowData: any, option: any) => boolean;\r\n    private _filteredOptions: any[];\r\n\r\n\r\n\r\n    public gridValueField: string;\r\n\r\n    public showFillButton: boolean;\t\t// This represents whether the editor should show the \"Fill\" button,\r\n                                        // which is used to copy the value of this cell to other cells in this column in the grid\r\n    public fillGroupAttribute: string;\t\t// This attribute is used to specify which \"Group\" a particular\r\n                                            // row belongs to, which is used when the fill button is active.\r\n                                            // When clicked, the fill button will copy the data in that cell\r\n                                            // to the corresponding cells in rows of the same group.\r\n    public fillAll: boolean;                // If fillAll is set, all data will automatically be grouped together\r\n\r\n    private _spinnerDialogIsOpen: boolean = false;\r\n//    private spinnerDialogRefs: MatDialogRef<SpinnerDialogComponent>[] = [];\r\n\r\n    constructor(/*protected dialog: MatDialog*/) { }\r\n\r\n    agInit(params: any): void {\r\n        this.params = params;\r\n        this.options = [];\r\n        this.optionsValueField = \"\";\r\n        this.optionsDisplayField = \"\";\r\n\r\n        if (this.params && this.params.column && this.params.column.colDef) {\r\n            this.gridValueField = this.params.column.colDef.field;\r\n\r\n            this.options = this.params.column.colDef.selectOptions;\r\n            this.optionsValueField = this.params.column.colDef.selectOptionsValueField;\r\n            this.optionsDisplayField = this.params.column.colDef.selectOptionsDisplayField;\r\n\r\n            if (this.params.column.colDef.selectOptionsPerRowFilterFunction) {\r\n                let backup = this.selectOptionsPerRowFilterFunction;\r\n                try {\r\n                    this.selectOptionsPerRowFilterFunction = this.params.column.colDef.selectOptionsPerRowFilterFunction;\r\n                    this.using_selectOptionsPerRowFilterFunction = !!this.selectOptionsPerRowFilterFunction;\r\n                } catch (e) {\r\n                    console.error(\"selectOptionsPerRowFilterFunction option has wrong signature for column : \" + this.params.column.colDef.headerName + \"\\n\"\r\n                        + \"  Requires signature (context:any, rowData: any, option: any) => boolean\"\r\n                    );\r\n                    this.selectOptionsPerRowFilterFunction = backup;\r\n                    this.using_selectOptionsPerRowFilterFunction = !!backup;\r\n                }\r\n            }\r\n\r\n            this.context = this.params.column.colDef.context;\r\n\r\n            this.fillGroupAttribute = this.params.column.colDef.fillGroupAttribute;\r\n            this.fillAll = this.params.column.colDef.fillAll && (\"\" + this.params.column.colDef.fillAll).toLowerCase() !== \"false\";\r\n\r\n            this.showFillButton = this.params.column.colDef.showFillButton && (\"\" + this.params.column.colDef.showFillButton).toLowerCase() !== \"false\";\r\n\r\n            if (this._options\r\n                && this.params.node\r\n                && this.params.node.data\r\n                && this.using_selectOptionsPerRowFilterFunction) {\r\n\r\n                this._filteredOptions = this._options.filter((option: any) => {\r\n                    return this.selectOptionsPerRowFilterFunction(this.context, this.params.node.data, option);\r\n                });\r\n            }\r\n        }\r\n\r\n        if (this.params) {\r\n            this.value = this.params.value ? \"\" + this.params.value : \"\";\r\n        }\r\n\r\n        if (this.showFillButton && !this.fillAll && (!this.fillGroupAttribute || this.fillGroupAttribute === \"\")) {\r\n            throw new Error(\"Invalid state, cannot use fill button without specifying the fillGroupAttribute or fillAll.\");\r\n        }\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        if (this.params && this.params.node && this.params.node[(this.gridValueField + \"_originalValue\")]) {\r\n            this.value = this.params.node[(this.gridValueField + \"_originalValue\")];\r\n        }\r\n    }\r\n\r\n    onChange(event: any): void {\r\n        if (event && event.currentTarget) {\r\n\r\n            if (this.params && this.params.node && !this.params.node[(this.gridValueField + \"_originalValue\")]) {\r\n                this.params.node[(this.gridValueField + \"_originalValue\")] = this.value;\r\n            }\r\n\r\n            // This looks unnecessary, since this.value is linked to the value of the select component, but\r\n            // because this also ends editing, it also queues the destruction of this component and the call to getValue.\r\n            // The problem was that this.value isn't updated with the new value before this event fires,\r\n            // so we need to update it manually here.\r\n            this.value = event.currentTarget.value;\r\n            this.params.node.setDataValue(this.gridValueField, this.value);\r\n        }\r\n        if (this.params) {\r\n\r\n            //  If the fill button, which is part of the editor, is activated, don't stop editing\r\n            // immediately after making a selection.\r\n            if (!this.showFillButton) {\r\n                this.params.stopEditing();\r\n            }\r\n        }\r\n    }\r\n\r\n    getValue(): any {\r\n        return this.value ? this.value : \"\";\r\n    }\r\n\r\n    isPopup(): boolean {\r\n        return false;\r\n    }\r\n\r\n    onFillButtonClicked(): void {\r\n        if (!this.fillAll && (!this.fillGroupAttribute || this.fillGroupAttribute === \"\")) {\r\n            throw new Error('No column attribute \"fillGroupAttribute\" or \"fillAll\" specified. This is required to use the Fill functionality.');\r\n        }\r\n\r\n        if (this.params && this.params.column && this.params.column.gridApi && this.params.node && (this.fillAll || (this.fillGroupAttribute && this.fillGroupAttribute !== \"\"))) {\r\n            let thisRowNode = this.params.node;\r\n\r\n            //this.startSpinnerDialog();\r\n            this.params.column.gridApi.forEachNodeAfterFilter((rowNode) => {\r\n                if (rowNode && rowNode.data && thisRowNode && thisRowNode.data && (this.fillAll || rowNode.data[this.fillGroupAttribute] === thisRowNode.data[this.fillGroupAttribute])) {\r\n                    let spoofedEvent: any = {\r\n                        api: this.params.column.gridApi,\r\n                        colDef: this.params.column.colDef,\r\n                        column: this.params.column,\r\n                        columnApi: this.params.column.columnApi,\r\n                        context: undefined,\r\n                        data: rowNode.data,\r\n                        event: null,\r\n                        newValue: this.value,\r\n                        node: rowNode,\r\n                        oldValue: rowNode.data[this.gridValueField],\r\n                        rowIndex: rowNode.rowIndex,\r\n                        rowPinned: undefined,\r\n                        type: \"cellValueChanged\",\r\n                        value: this.value\r\n                    };\r\n\r\n                    rowNode.data[this.gridValueField] = this.value;\r\n                    rowNode.setDataValue(this.gridValueField, this.value);\r\n                    this.params.column.gridApi.dispatchEvent(spoofedEvent);\r\n                }\r\n            });\r\n\r\n            this.params.column.gridApi.refreshCells();\r\n            setTimeout(() => {\r\n                //this.stopSpinnerDialogs();\r\n            });\r\n        }\r\n    }\r\n\r\n\t/*\r\n    startSpinnerDialog(): MatDialogRef<SpinnerDialogComponent> {\r\n        if (this._spinnerDialogIsOpen) {\r\n            return null;\r\n        }\r\n\r\n        this._spinnerDialogIsOpen = true;\r\n\r\n        let configuration: MatDialogConfig = new MatDialogConfig();\r\n        configuration.data = {\r\n            message: \"Please wait...\",\r\n            strokeWidth: 3,\r\n            diameter: 30\r\n        };\r\n        configuration.width = \"13em\";\r\n        configuration.disableClose = true;\r\n\r\n        let dialogRef: MatDialogRef<SpinnerDialogComponent> = this.dialog.open(SpinnerDialogComponent, configuration);\r\n        dialogRef.afterClosed().subscribe(() => { this._spinnerDialogIsOpen = false; });\r\n        this.spinnerDialogRefs.push(dialogRef);\r\n\r\n        return dialogRef;\r\n    }\r\n\r\n    stopSpinnerDialogs(): void {\r\n        for (let dialogRef of this.spinnerDialogRefs) {\r\n            setTimeout(() => {\r\n                dialogRef.close();\r\n            });\r\n        }\r\n        this.spinnerDialogRefs = [];\r\n    }\r\n\t*/\r\n}\r\n"]}
+      `, styles: [".full-width{width:100%}.full-height{height:100%}.flex-column-container{display:flex;flex-direction:row}.flex-row{display:flex}.flex-stretch{display:flex;flex:1}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.editor.js","sourceRoot":"","sources":["../../../../projects/dictionary-editor/src/grid-editors/select.editor.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, OnDestroy} from \"@angular/core\";\r\nimport {ICellEditorAngularComp} from \"ag-grid-angular\";\r\n//import {MatDialog, MatDialogConfig, MatDialogRef} from \"@angular/material/dialog\";\r\n//import {SpinnerDialogComponent} from \"../popup/spinner-dialog.component\";\r\n\r\n@Component(\r\n  {\r\n    template:\r\n      `\r\n        <div class=\"full-width full-height flex-column-container\">\r\n          <div class=\"full-height flex-stretch flex-row\">\r\n            <select class=\"full-width full-height\" [(value)]=\"value\" (change)=\"onChange($event)\">\r\n              <option hidden>\r\n                Select An Option\r\n              </option>\r\n              <option\r\n                *ngFor=\"let option of options\"\r\n                value=\"{{option.hasOwnProperty(optionsValueField) ? option[optionsValueField] : (option.value) ? option.value : option }}\">\r\n                {{option.hasOwnProperty(optionsDisplayField) ? option[optionsDisplayField] : (option.display) ? option.display : option }}\r\n              </option>\r\n            </select>\r\n          </div>\r\n          <div *ngIf=\"showFillButton\" class=\"full-height flex-row button-container\">\r\n            <button class=\"full-height\" (click)=\"onFillButtonClicked()\">Fill</button>\r\n          </div>\r\n        </div>\r\n      `\r\n    ,\r\n    styles: [\r\n      `\r\n        .full-width {\r\n          width: 100%;\r\n        }\r\n\r\n        .full-height {\r\n          height: 100%;\r\n        }\r\n\r\n        .flex-column-container {\r\n          display: flex;\r\n          flex-direction: row;\r\n        }\r\n\r\n        .flex-row {\r\n          display: flex;\r\n        }\r\n\r\n        .flex-stretch {\r\n          display: flex;\r\n          flex: 1;\r\n        }\r\n      `\r\n    ]\r\n  }\r\n)\r\nexport class SelectEditor implements ICellEditorAngularComp, OnDestroy {\r\n    public params: any;\r\n    public value: any;\r\n    private _options: any[];\r\n    public get options(): any[] {\r\n        if (this.using_selectOptionsPerRowFilterFunction) {\r\n            return this._filteredOptions;\r\n        } else {\r\n            return this._options;\r\n        }\r\n    }\r\n    public set options(value: any[]) {\r\n        this._options = value;\r\n    }\r\n\r\n    public optionsValueField: string;\r\n    public optionsDisplayField: string;\r\n\r\n    // variables used for the optional per-row-filtering\r\n    public context: any;\r\n    protected using_selectOptionsPerRowFilterFunction: boolean = false;\r\n    protected selectOptionsPerRowFilterFunction: (context: any, rowData: any, option: any) => boolean;\r\n    private _filteredOptions: any[];\r\n\r\n\r\n\r\n    public gridValueField: string;\r\n\r\n    public showFillButton: boolean;\t\t// This represents whether the editor should show the \"Fill\" button,\r\n                                        // which is used to copy the value of this cell to other cells in this column in the grid\r\n    public fillGroupAttribute: string;\t\t// This attribute is used to specify which \"Group\" a particular\r\n                                            // row belongs to, which is used when the fill button is active.\r\n                                            // When clicked, the fill button will copy the data in that cell\r\n                                            // to the corresponding cells in rows of the same group.\r\n    public fillAll: boolean;                // If fillAll is set, all data will automatically be grouped together\r\n\r\n    private _spinnerDialogIsOpen: boolean = false;\r\n//    private spinnerDialogRefs: MatDialogRef<SpinnerDialogComponent>[] = [];\r\n\r\n    constructor(/*protected dialog: MatDialog*/) { }\r\n\r\n    agInit(params: any): void {\r\n        this.params = params;\r\n        this.options = [];\r\n        this.optionsValueField = \"\";\r\n        this.optionsDisplayField = \"\";\r\n\r\n        if (this.params && this.params.column && this.params.column.colDef) {\r\n            this.gridValueField = this.params.column.colDef.field;\r\n\r\n            this.options = this.params.column.colDef.selectOptions;\r\n            this.optionsValueField = this.params.column.colDef.selectOptionsValueField;\r\n            this.optionsDisplayField = this.params.column.colDef.selectOptionsDisplayField;\r\n\r\n            if (this.params.column.colDef.selectOptionsPerRowFilterFunction) {\r\n                let backup = this.selectOptionsPerRowFilterFunction;\r\n                try {\r\n                    this.selectOptionsPerRowFilterFunction = this.params.column.colDef.selectOptionsPerRowFilterFunction;\r\n                    this.using_selectOptionsPerRowFilterFunction = !!this.selectOptionsPerRowFilterFunction;\r\n                } catch (e) {\r\n                    console.error(\"selectOptionsPerRowFilterFunction option has wrong signature for column : \" + this.params.column.colDef.headerName + \"\\n\"\r\n                        + \"  Requires signature (context:any, rowData: any, option: any) => boolean\"\r\n                    );\r\n                    this.selectOptionsPerRowFilterFunction = backup;\r\n                    this.using_selectOptionsPerRowFilterFunction = !!backup;\r\n                }\r\n            }\r\n\r\n            this.context = this.params.column.colDef.context;\r\n\r\n            this.fillGroupAttribute = this.params.column.colDef.fillGroupAttribute;\r\n            this.fillAll = this.params.column.colDef.fillAll && (\"\" + this.params.column.colDef.fillAll).toLowerCase() !== \"false\";\r\n\r\n            this.showFillButton = this.params.column.colDef.showFillButton && (\"\" + this.params.column.colDef.showFillButton).toLowerCase() !== \"false\";\r\n\r\n            if (this._options\r\n                && this.params.node\r\n                && this.params.node.data\r\n                && this.using_selectOptionsPerRowFilterFunction) {\r\n\r\n                this._filteredOptions = this._options.filter((option: any) => {\r\n                    return this.selectOptionsPerRowFilterFunction(this.context, this.params.node.data, option);\r\n                });\r\n            }\r\n        }\r\n\r\n        if (this.params) {\r\n            this.value = this.params.value ? \"\" + this.params.value : \"\";\r\n        }\r\n\r\n        if (this.showFillButton && !this.fillAll && (!this.fillGroupAttribute || this.fillGroupAttribute === \"\")) {\r\n            throw new Error(\"Invalid state, cannot use fill button without specifying the fillGroupAttribute or fillAll.\");\r\n        }\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        if (this.params && this.params.node && this.params.node[(this.gridValueField + \"_originalValue\")]) {\r\n            this.value = this.params.node[(this.gridValueField + \"_originalValue\")];\r\n        }\r\n    }\r\n\r\n    onChange(event: any): void {\r\n        if (event && event.currentTarget) {\r\n\r\n            if (this.params && this.params.node && !this.params.node[(this.gridValueField + \"_originalValue\")]) {\r\n                this.params.node[(this.gridValueField + \"_originalValue\")] = this.value;\r\n            }\r\n\r\n            // This looks unnecessary, since this.value is linked to the value of the select component, but\r\n            // because this also ends editing, it also queues the destruction of this component and the call to getValue.\r\n            // The problem was that this.value isn't updated with the new value before this event fires,\r\n            // so we need to update it manually here.\r\n            this.value = event.currentTarget.value;\r\n            this.params.node.setDataValue(this.gridValueField, this.value);\r\n        }\r\n        if (this.params) {\r\n\r\n            //  If the fill button, which is part of the editor, is activated, don't stop editing\r\n            // immediately after making a selection.\r\n            if (!this.showFillButton) {\r\n                this.params.stopEditing();\r\n            }\r\n        }\r\n    }\r\n\r\n    getValue(): any {\r\n        return this.value ? this.value : \"\";\r\n    }\r\n\r\n    isPopup(): boolean {\r\n        return false;\r\n    }\r\n\r\n    onFillButtonClicked(): void {\r\n        if (!this.fillAll && (!this.fillGroupAttribute || this.fillGroupAttribute === \"\")) {\r\n            throw new Error('No column attribute \"fillGroupAttribute\" or \"fillAll\" specified. This is required to use the Fill functionality.');\r\n        }\r\n\r\n        if (this.params && this.params.column && this.params.column.gridApi && this.params.node && (this.fillAll || (this.fillGroupAttribute && this.fillGroupAttribute !== \"\"))) {\r\n            let thisRowNode = this.params.node;\r\n\r\n            //this.startSpinnerDialog();\r\n            this.params.column.gridApi.forEachNodeAfterFilter((rowNode) => {\r\n                if (rowNode && rowNode.data && thisRowNode && thisRowNode.data && (this.fillAll || rowNode.data[this.fillGroupAttribute] === thisRowNode.data[this.fillGroupAttribute])) {\r\n                    let spoofedEvent: any = {\r\n                        api: this.params.column.gridApi,\r\n                        colDef: this.params.column.colDef,\r\n                        column: this.params.column,\r\n                        columnApi: this.params.column.columnApi,\r\n                        context: undefined,\r\n                        data: rowNode.data,\r\n                        event: null,\r\n                        newValue: this.value,\r\n                        node: rowNode,\r\n                        oldValue: rowNode.data[this.gridValueField],\r\n                        rowIndex: rowNode.rowIndex,\r\n                        rowPinned: undefined,\r\n                        type: \"cellValueChanged\",\r\n                        value: this.value\r\n                    };\r\n\r\n                    rowNode.data[this.gridValueField] = this.value;\r\n                    rowNode.setDataValue(this.gridValueField, this.value);\r\n                    this.params.column.gridApi.dispatchEvent(spoofedEvent);\r\n                }\r\n            });\r\n\r\n            this.params.column.gridApi.refreshCells();\r\n            setTimeout(() => {\r\n                //this.stopSpinnerDialogs();\r\n            });\r\n        }\r\n    }\r\n\r\n\t/*\r\n    startSpinnerDialog(): MatDialogRef<SpinnerDialogComponent> {\r\n        if (this._spinnerDialogIsOpen) {\r\n            return null;\r\n        }\r\n\r\n        this._spinnerDialogIsOpen = true;\r\n\r\n        let configuration: MatDialogConfig = new MatDialogConfig();\r\n        configuration.data = {\r\n            message: \"Please wait...\",\r\n            strokeWidth: 3,\r\n            diameter: 30\r\n        };\r\n        configuration.width = \"13em\";\r\n        configuration.disableClose = true;\r\n\r\n        let dialogRef: MatDialogRef<SpinnerDialogComponent> = this.dialog.open(SpinnerDialogComponent, configuration);\r\n        dialogRef.afterClosed().subscribe(() => { this._spinnerDialogIsOpen = false; });\r\n        this.spinnerDialogRefs.push(dialogRef);\r\n\r\n        return dialogRef;\r\n    }\r\n\r\n    stopSpinnerDialogs(): void {\r\n        for (let dialogRef of this.spinnerDialogRefs) {\r\n            setTimeout(() => {\r\n                dialogRef.close();\r\n            });\r\n        }\r\n        this.spinnerDialogRefs = [];\r\n    }\r\n\t*/\r\n}\r\n"]}

package/esm2022/grid-renderers/ag-grid-renderer.module.mjs

@@ -1,36 +1,36 @@
-import { NgModule } from "@angular/core";
-import { CommonModule } from "@angular/common";
-import { FormsModule, ReactiveFormsModule } from "@angular/forms";
-import { SelectRenderer } from "./select.renderer";
-import { DateRenderer } from "./date.renderer";
-import * as i0 from "@angular/core";
-export class AgGridRendererModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AgGridRendererModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: AgGridRendererModule, declarations: [SelectRenderer,
-            DateRenderer], imports: [CommonModule,
-            FormsModule,
-            ReactiveFormsModule], exports: [SelectRenderer,
-            DateRenderer] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AgGridRendererModule, imports: [CommonModule,
-            FormsModule,
-            ReactiveFormsModule] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AgGridRendererModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        CommonModule,
-                        FormsModule,
-                        ReactiveFormsModule,
-                    ],
-                    declarations: [
-                        SelectRenderer,
-                        DateRenderer
-                    ],
-                    exports: [
-                        SelectRenderer,
-                        DateRenderer
-                    ]
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWctZ3JpZC1yZW5kZXJlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9kaWN0aW9uYXJ5LWVkaXRvci9zcmMvZ3JpZC1yZW5kZXJlcnMvYWctZ3JpZC1yZW5kZXJlci5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFdBQVcsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRWxFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNuRCxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7O0FBZ0I3QyxNQUFNLE9BQU8sb0JBQW9COytHQUFwQixvQkFBb0I7Z0hBQXBCLG9CQUFvQixpQkFSL0IsY0FBYztZQUNWLFlBQVksYUFOVixZQUFZO1lBQ1osV0FBVztZQUNYLG1CQUFtQixhQU96QixjQUFjO1lBQ1YsWUFBWTtnSEFHTCxvQkFBb0IsWUFiekIsWUFBWTtZQUNaLFdBQVc7WUFDWCxtQkFBbUI7OzRGQVdkLG9CQUFvQjtrQkFmaEMsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUU7d0JBQ0wsWUFBWTt3QkFDWixXQUFXO3dCQUNYLG1CQUFtQjtxQkFDdEI7b0JBQ0QsWUFBWSxFQUFFO3dCQUNoQixjQUFjO3dCQUNWLFlBQVk7cUJBQ2I7b0JBQ0QsT0FBTyxFQUFFO3dCQUNYLGNBQWM7d0JBQ1YsWUFBWTtxQkFDYjtpQkFDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vblwiO1xyXG5pbXBvcnQgeyBGb3Jtc01vZHVsZSwgUmVhY3RpdmVGb3Jtc01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9mb3Jtc1wiO1xyXG5cclxuaW1wb3J0IHsgU2VsZWN0UmVuZGVyZXIgfSBmcm9tIFwiLi9zZWxlY3QucmVuZGVyZXJcIjtcclxuaW1wb3J0IHtEYXRlUmVuZGVyZXJ9IGZyb20gXCIuL2RhdGUucmVuZGVyZXJcIjtcclxuQE5nTW9kdWxlKHtcclxuICAgIGltcG9ydHM6IFtcclxuICAgICAgICBDb21tb25Nb2R1bGUsXHJcbiAgICAgICAgRm9ybXNNb2R1bGUsXHJcbiAgICAgICAgUmVhY3RpdmVGb3Jtc01vZHVsZSxcclxuICAgIF0sXHJcbiAgICBkZWNsYXJhdGlvbnM6IFtcclxuXHRcdFNlbGVjdFJlbmRlcmVyLFxyXG4gICAgICBEYXRlUmVuZGVyZXJcclxuICAgIF0sXHJcbiAgICBleHBvcnRzOiBbXHJcblx0XHRTZWxlY3RSZW5kZXJlcixcclxuICAgICAgRGF0ZVJlbmRlcmVyXHJcbiAgICBdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBBZ0dyaWRSZW5kZXJlck1vZHVsZSB7IH1cclxuIl19
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { FormsModule, ReactiveFormsModule } from "@angular/forms";
+import { SelectRenderer } from "./select.renderer";
+import { DateRenderer } from "./date.renderer";
+import * as i0 from "@angular/core";
+export class AgGridRendererModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AgGridRendererModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: AgGridRendererModule, declarations: [SelectRenderer,
+            DateRenderer], imports: [CommonModule,
+            FormsModule,
+            ReactiveFormsModule], exports: [SelectRenderer,
+            DateRenderer] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AgGridRendererModule, imports: [CommonModule,
+            FormsModule,
+            ReactiveFormsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AgGridRendererModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                    ],
+                    declarations: [
+                        SelectRenderer,
+                        DateRenderer
+                    ],
+                    exports: [
+                        SelectRenderer,
+                        DateRenderer
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWctZ3JpZC1yZW5kZXJlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9kaWN0aW9uYXJ5LWVkaXRvci9zcmMvZ3JpZC1yZW5kZXJlcnMvYWctZ3JpZC1yZW5kZXJlci5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFdBQVcsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRWxFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNuRCxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7O0FBZ0I3QyxNQUFNLE9BQU8sb0JBQW9COzhHQUFwQixvQkFBb0I7K0dBQXBCLG9CQUFvQixpQkFSL0IsY0FBYztZQUNWLFlBQVksYUFOVixZQUFZO1lBQ1osV0FBVztZQUNYLG1CQUFtQixhQU96QixjQUFjO1lBQ1YsWUFBWTsrR0FHTCxvQkFBb0IsWUFiekIsWUFBWTtZQUNaLFdBQVc7WUFDWCxtQkFBbUI7OzJGQVdkLG9CQUFvQjtrQkFmaEMsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUU7d0JBQ0wsWUFBWTt3QkFDWixXQUFXO3dCQUNYLG1CQUFtQjtxQkFDdEI7b0JBQ0QsWUFBWSxFQUFFO3dCQUNoQixjQUFjO3dCQUNWLFlBQVk7cUJBQ2I7b0JBQ0QsT0FBTyxFQUFFO3dCQUNYLGNBQWM7d0JBQ1YsWUFBWTtxQkFDYjtpQkFDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vblwiO1xyXG5pbXBvcnQgeyBGb3Jtc01vZHVsZSwgUmVhY3RpdmVGb3Jtc01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9mb3Jtc1wiO1xyXG5cclxuaW1wb3J0IHsgU2VsZWN0UmVuZGVyZXIgfSBmcm9tIFwiLi9zZWxlY3QucmVuZGVyZXJcIjtcclxuaW1wb3J0IHtEYXRlUmVuZGVyZXJ9IGZyb20gXCIuL2RhdGUucmVuZGVyZXJcIjtcclxuQE5nTW9kdWxlKHtcclxuICAgIGltcG9ydHM6IFtcclxuICAgICAgICBDb21tb25Nb2R1bGUsXHJcbiAgICAgICAgRm9ybXNNb2R1bGUsXHJcbiAgICAgICAgUmVhY3RpdmVGb3Jtc01vZHVsZSxcclxuICAgIF0sXHJcbiAgICBkZWNsYXJhdGlvbnM6IFtcclxuXHRcdFNlbGVjdFJlbmRlcmVyLFxyXG4gICAgICBEYXRlUmVuZGVyZXJcclxuICAgIF0sXHJcbiAgICBleHBvcnRzOiBbXHJcblx0XHRTZWxlY3RSZW5kZXJlcixcclxuICAgICAgRGF0ZVJlbmRlcmVyXHJcbiAgICBdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBBZ0dyaWRSZW5kZXJlck1vZHVsZSB7IH1cclxuIl19