@inobeta/ui 18.0.1-build.1722007687

package/esm2022/src/app/inobeta-ui/ui/kai-filter/filters.module.mjs

@@ -0,0 +1,175 @@
+import { Platform } from "@angular/cdk/platform";
+import { PortalModule } from "@angular/cdk/portal";
+import { CommonModule } from "@angular/common";
+import { NgModule } from "@angular/core";
+import { FormsModule, ReactiveFormsModule } from "@angular/forms";
+import { MatButtonModule } from "@angular/material/button";
+import { MatChipsModule } from "@angular/material/chips";
+import { DateAdapter, MAT_DATE_FORMATS, MAT_DATE_LOCALE, } from "@angular/material/core";
+import { MatDatepickerModule } from "@angular/material/datepicker";
+import { MatDividerModule } from "@angular/material/divider";
+import { MatFormFieldModule } from "@angular/material/form-field";
+import { MatIconModule } from "@angular/material/icon";
+import { MatInputModule } from "@angular/material/input";
+import { MatListModule } from "@angular/material/list";
+import { MatMenuModule } from "@angular/material/menu";
+import { MatRadioModule } from "@angular/material/radio";
+import { MatSelectModule } from "@angular/material/select";
+import { MatSliderModule } from "@angular/material/slider";
+import { MatTooltipModule } from "@angular/material/tooltip";
+import { TranslateModule, TranslateService } from "@ngx-translate/core";
+import { IbFilterPipe } from "../../core";
+import { IbTableActionModule } from "../kai-table/action";
+import { IbMatDateAdapter } from "../material-forms/intl/datepicker.intl";
+import { ibMatDatepickerTranslate } from "../material-forms/material-form.module";
+import { IbFilterActionGroup } from "./filter-button/filter-action-group.component";
+import { IbFilterButton } from "./filter-button/filter-button.component";
+import { IbFilter } from "./filter.component";
+import { IbFilterBase } from "./filters/base/filter-base";
+import { IbBooleanFilter } from "./filters/boolean/boolean-filter.component";
+import { IbDateFilter } from "./filters/date/filter-date.component";
+import { IbNumberFilter } from "./filters/number/filter-number.component";
+import { IbSearchBar } from "./filters/search-bar/search-bar.component";
+import { IbTagFilter } from "./filters/tag/filter-tag.component";
+import { IbTextFilter } from "./filters/text/filter-text.component";
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class IbFilterModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbFilterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.1.1", ngImport: i0, type: IbFilterModule, declarations: [IbFilter,
+            IbFilterBase,
+            IbTextFilter,
+            IbTagFilter,
+            IbNumberFilter,
+            IbDateFilter,
+            IbSearchBar], imports: [CommonModule,
+            PortalModule,
+            FormsModule,
+            ReactiveFormsModule,
+            MatInputModule,
+            MatButtonModule,
+            MatIconModule,
+            MatMenuModule,
+            MatSelectModule,
+            MatChipsModule,
+            MatFormFieldModule,
+            MatDividerModule,
+            MatListModule,
+            MatSliderModule,
+            MatRadioModule,
+            MatDatepickerModule,
+            IbTableActionModule,
+            MatTooltipModule, i1.TranslateModule, IbFilterPipe,
+            IbFilterButton,
+            IbFilterActionGroup,
+            IbBooleanFilter], exports: [IbFilter,
+            IbFilterBase,
+            IbFilterButton,
+            IbTextFilter,
+            IbTagFilter,
+            IbNumberFilter,
+            IbDateFilter,
+            IbSearchBar,
+            IbBooleanFilter,
+            IbFilterActionGroup] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbFilterModule, providers: [
+            {
+                provide: DateAdapter,
+                useClass: IbMatDateAdapter,
+                deps: [MAT_DATE_LOCALE, Platform],
+            },
+            {
+                provide: MAT_DATE_FORMATS,
+                deps: [TranslateService],
+                useFactory: ibMatDatepickerTranslate,
+            },
+        ], imports: [CommonModule,
+            PortalModule,
+            FormsModule,
+            ReactiveFormsModule,
+            MatInputModule,
+            MatButtonModule,
+            MatIconModule,
+            MatMenuModule,
+            MatSelectModule,
+            MatChipsModule,
+            MatFormFieldModule,
+            MatDividerModule,
+            MatListModule,
+            MatSliderModule,
+            MatRadioModule,
+            MatDatepickerModule,
+            IbTableActionModule,
+            MatTooltipModule,
+            TranslateModule.forChild({
+                extend: true,
+            }),
+            IbFilterButton,
+            IbBooleanFilter] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbFilterModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        PortalModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        MatInputModule,
+                        MatButtonModule,
+                        MatIconModule,
+                        MatMenuModule,
+                        MatSelectModule,
+                        MatChipsModule,
+                        MatFormFieldModule,
+                        MatDividerModule,
+                        MatListModule,
+                        MatSliderModule,
+                        MatRadioModule,
+                        MatDatepickerModule,
+                        IbTableActionModule,
+                        MatTooltipModule,
+                        TranslateModule.forChild({
+                            extend: true,
+                        }),
+                        IbFilterPipe,
+                        IbFilterButton,
+                        IbFilterActionGroup,
+                        IbBooleanFilter,
+                    ],
+                    exports: [
+                        IbFilter,
+                        IbFilterBase,
+                        IbFilterButton,
+                        IbTextFilter,
+                        IbTagFilter,
+                        IbNumberFilter,
+                        IbDateFilter,
+                        IbSearchBar,
+                        IbBooleanFilter,
+                        IbFilterActionGroup,
+                    ],
+                    declarations: [
+                        IbFilter,
+                        IbFilterBase,
+                        IbTextFilter,
+                        IbTagFilter,
+                        IbNumberFilter,
+                        IbDateFilter,
+                        IbSearchBar,
+                    ],
+                    providers: [
+                        {
+                            provide: DateAdapter,
+                            useClass: IbMatDateAdapter,
+                            deps: [MAT_DATE_LOCALE, Platform],
+                        },
+                        {
+                            provide: MAT_DATE_FORMATS,
+                            deps: [TranslateService],
+                            useFactory: ibMatDatepickerTranslate,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filters.module.js","sourceRoot":"","sources":["../../../../../../../src/app/inobeta-ui/ui/kai-filter/filters.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { Platform } from \"@angular/cdk/platform\";\nimport { PortalModule } from \"@angular/cdk/portal\";\nimport { CommonModule } from \"@angular/common\";\nimport { NgModule } from \"@angular/core\";\nimport { FormsModule, ReactiveFormsModule } from \"@angular/forms\";\nimport { MatButtonModule } from \"@angular/material/button\";\nimport { MatChipsModule } from \"@angular/material/chips\";\nimport {\n  DateAdapter,\n  MAT_DATE_FORMATS,\n  MAT_DATE_LOCALE,\n} from \"@angular/material/core\";\nimport { MatDatepickerModule } from \"@angular/material/datepicker\";\nimport { MatDividerModule } from \"@angular/material/divider\";\nimport { MatFormFieldModule } from \"@angular/material/form-field\";\nimport { MatIconModule } from \"@angular/material/icon\";\nimport { MatInputModule } from \"@angular/material/input\";\nimport { MatListModule } from \"@angular/material/list\";\nimport { MatMenuModule } from \"@angular/material/menu\";\nimport { MatRadioModule } from \"@angular/material/radio\";\nimport { MatSelectModule } from \"@angular/material/select\";\nimport { MatSliderModule } from \"@angular/material/slider\";\nimport { MatTooltipModule } from \"@angular/material/tooltip\";\nimport { TranslateModule, TranslateService } from \"@ngx-translate/core\";\nimport { IbFilterPipe } from \"../../core\";\nimport { IbTableActionModule } from \"../kai-table/action\";\nimport { IbMatDateAdapter } from \"../material-forms/intl/datepicker.intl\";\nimport { ibMatDatepickerTranslate } from \"../material-forms/material-form.module\";\nimport { IbFilterActionGroup } from \"./filter-button/filter-action-group.component\";\nimport { IbFilterButton } from \"./filter-button/filter-button.component\";\nimport { IbFilter } from \"./filter.component\";\nimport { IbFilterBase } from \"./filters/base/filter-base\";\nimport { IbBooleanFilter } from \"./filters/boolean/boolean-filter.component\";\nimport { IbDateFilter } from \"./filters/date/filter-date.component\";\nimport { IbNumberFilter } from \"./filters/number/filter-number.component\";\nimport { IbSearchBar } from \"./filters/search-bar/search-bar.component\";\nimport { IbTagFilter } from \"./filters/tag/filter-tag.component\";\nimport { IbTextFilter } from \"./filters/text/filter-text.component\";\n\n@NgModule({\n  imports: [\n    CommonModule,\n    PortalModule,\n    FormsModule,\n    ReactiveFormsModule,\n    MatInputModule,\n    MatButtonModule,\n    MatIconModule,\n    MatMenuModule,\n    MatSelectModule,\n    MatChipsModule,\n    MatFormFieldModule,\n    MatDividerModule,\n    MatListModule,\n    MatSliderModule,\n    MatRadioModule,\n    MatDatepickerModule,\n    IbTableActionModule,\n    MatTooltipModule,\n    TranslateModule.forChild({\n      extend: true,\n    }),\n    IbFilterPipe,\n    IbFilterButton,\n    IbFilterActionGroup,\n    IbBooleanFilter,\n  ],\n  exports: [\n    IbFilter,\n    IbFilterBase,\n    IbFilterButton,\n    IbTextFilter,\n    IbTagFilter,\n    IbNumberFilter,\n    IbDateFilter,\n    IbSearchBar,\n    IbBooleanFilter,\n    IbFilterActionGroup,\n  ],\n  declarations: [\n    IbFilter,\n    IbFilterBase,\n    IbTextFilter,\n    IbTagFilter,\n    IbNumberFilter,\n    IbDateFilter,\n    IbSearchBar,\n  ],\n  providers: [\n    {\n      provide: DateAdapter,\n      useClass: IbMatDateAdapter,\n      deps: [MAT_DATE_LOCALE, Platform],\n    },\n    {\n      provide: MAT_DATE_FORMATS,\n      deps: [TranslateService],\n      useFactory: ibMatDatepickerTranslate,\n    },\n  ],\n})\nexport class IbFilterModule {}\n"]}

package/esm2022/src/app/inobeta-ui/ui/kai-filter/index.mjs

@@ -0,0 +1,14 @@
+export * from "./filter-button/filter-action-group.component";
+export * from "./filter-button/filter-button.component";
+export * from "./filter.component";
+export * from "./filter.types";
+export * from "./filters";
+export * from "./filters.module";
+export * from "./filters/base/filter-base";
+export * from "./filters/date/filter-date.component";
+export * from "./filters/number/filter-number.component";
+export * from "./filters/search-bar/search-bar.component";
+export * from "./filters/tag/filter-tag.component";
+export * from "./filters/text/filter-text.component";
+export * from "./filters/boolean/boolean-filter.component";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL2lub2JldGEtdWkvdWkva2FpLWZpbHRlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtDQUErQyxDQUFDO0FBQzlELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYywyQ0FBMkMsQ0FBQztBQUMxRCxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyw0Q0FBNEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2ZpbHRlci1idXR0b24vZmlsdGVyLWFjdGlvbi1ncm91cC5jb21wb25lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZpbHRlci1idXR0b24vZmlsdGVyLWJ1dHRvbi5jb21wb25lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZpbHRlci5jb21wb25lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZpbHRlci50eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZmlsdGVyc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZmlsdGVycy5tb2R1bGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZpbHRlcnMvYmFzZS9maWx0ZXItYmFzZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZmlsdGVycy9kYXRlL2ZpbHRlci1kYXRlLmNvbXBvbmVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZmlsdGVycy9udW1iZXIvZmlsdGVyLW51bWJlci5jb21wb25lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZpbHRlcnMvc2VhcmNoLWJhci9zZWFyY2gtYmFyLmNvbXBvbmVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZmlsdGVycy90YWcvZmlsdGVyLXRhZy5jb21wb25lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZpbHRlcnMvdGV4dC9maWx0ZXItdGV4dC5jb21wb25lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZpbHRlcnMvYm9vbGVhbi9ib29sZWFuLWZpbHRlci5jb21wb25lbnRcIjtcbiJdfQ==

package/esm2022/src/app/inobeta-ui/ui/kai-filter/tokens.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from "@angular/core";
+export const IB_FILTER = new InjectionToken("IbFilter");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9pbm9iZXRhLXVpL3VpL2thaS1maWx0ZXIvdG9rZW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFL0MsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLElBQUksY0FBYyxDQUFNLFVBQVUsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuXG5leHBvcnQgY29uc3QgSUJfRklMVEVSID0gbmV3IEluamVjdGlvblRva2VuPGFueT4oXCJJYkZpbHRlclwiKTtcbiJdfQ==

package/esm2022/src/app/inobeta-ui/ui/kai-filter/translations.mjs

@@ -0,0 +1,51 @@
+export const ibKaiFilterTranslations = {
+    it: {
+        ibKaiFilter: {
+            required: 'è obbligatorio'
+        },
+        "ibFilter": {
+            "search": "Cerca",
+            "condition": "Condizione",
+            "eq": "Uguale a",
+            "contains": "Contiene",
+            "startsWith": "Inizia con",
+            "endsWith": "Finisce con",
+            "update": "Aggiorna",
+            "clear": "Cancella",
+            "value": "Valore",
+            "min": "Min",
+            "max": "Max",
+            "between": "Tra {{min}} e {{max}}",
+            "date": {
+                "withinTheLast": "A partire da",
+                "moreThan": "Da oltre",
+                "between": "Tra",
+                "minutes": "minuti",
+                "hours": "ore",
+                "days": "giorni",
+                "weeks": "settimane",
+                "minutesAgo": "minuti fa",
+                "hoursAgo": "ore fa",
+                "daysAgo": "giorni fa",
+                "weeksAgo": "settimane fa",
+                "dateRangeLabel": "Inserisci un intervallo",
+                "dateRangeInvalid": "Intervallo non valido"
+            },
+            "label": {
+                "text": "{{condition}} \"{{value}}\"",
+                "tag": {
+                    "default": "{{name}}",
+                    "empty": "senza valore",
+                    "singleItem": "{{item}}",
+                    "multipleItems": "{{item}} +{{length}}"
+                },
+                "number": "tra {{min}} e {{max}}"
+            },
+            includeEmpty: "Includi senza valore",
+            noItems: "Nessun elemento.",
+            true: "Vero",
+            false: "Falso"
+        },
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/inobeta-ui/ui/kai-table/action.mjs

@@ -0,0 +1,48 @@
+import { Directive, NgModule, Optional, TemplateRef, ViewChild, } from "@angular/core";
+import * as i0 from "@angular/core";
+export class IbKaiTableAction {
+    _templateRef;
+    viewContainerRef;
+    templateRef;
+    constructor(_templateRef, viewContainerRef) {
+        this._templateRef = _templateRef;
+        this.viewContainerRef = viewContainerRef;
+        this.templateRef = this.templateRef ?? this._templateRef;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbKaiTableAction, deps: [{ token: i0.TemplateRef, optional: true }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: IbKaiTableAction, selector: "[ibTableAction]", viewQueries: [{ propertyName: "templateRef", first: true, predicate: TemplateRef, descendants: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbKaiTableAction, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[ibTableAction]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ViewContainerRef }], propDecorators: { templateRef: [{
+                type: ViewChild,
+                args: [TemplateRef]
+            }] } });
+export class IbKaiTableActionGroup {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbKaiTableActionGroup, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: IbKaiTableActionGroup, selector: "ib-table-action-group, [ib-table-action-group]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbKaiTableActionGroup, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "ib-table-action-group, [ib-table-action-group]",
+                }]
+        }] });
+export class IbTableActionModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbTableActionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.1.1", ngImport: i0, type: IbTableActionModule, declarations: [IbKaiTableAction, IbKaiTableActionGroup], exports: [IbKaiTableAction, IbKaiTableActionGroup] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbTableActionModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbTableActionModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [IbKaiTableAction, IbKaiTableActionGroup],
+                    declarations: [IbKaiTableAction, IbKaiTableActionGroup],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/inobeta-ui/ui/kai-table/cells.mjs

@@ -0,0 +1,212 @@
+import { Component, Directive, EventEmitter, Inject, Input, Optional, Output, } from "@angular/core";
+import { IB_AGGREGATE, IB_AGGREGATE_TYPE, IB_COLUMN } from "./tokens";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/menu";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/tooltip";
+import * as i6 from "@ngx-translate/core";
+export class IbCellDef {
+    templateRef;
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbCellDef, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: IbCellDef, selector: "[ibCellDef]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbCellDef, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[ibCellDef]",
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+export class IbAggregate {
+    /**
+     * Calls {@link aggregateData} twice and returns an {@link IbAggregateResult}
+     * with the aggregated value for the entire column and the current visible page.
+     *
+     * It takes into account only filtered data.
+     *
+     * @param dataSource `IbTableDataSource` compatible data source instance
+     * @param column Column name
+     */
+    aggregate(
+    /**
+     * Note: this is any to avoid an importing cycle
+     */
+    dataSource, column) {
+        const dataset = dataSource
+            ._orderData(dataSource.filteredData)
+            .map((i) => i[column]);
+        const pagedData = dataSource._pageData(dataset);
+        return {
+            currentPage: this.aggregateData(pagedData),
+            total: this.aggregateData(dataset),
+        };
+    }
+}
+class IbSumAggregate extends IbAggregate {
+    id = "sum";
+    name = "shared.aggregate.sum.name";
+    label = "shared.aggregate.sum.label";
+    type = "number";
+    aggregateData(data) {
+        return data.reduce((acc, cur) => acc + cur, 0);
+    }
+}
+export const IbSumAggregateProvider = {
+    provide: IB_AGGREGATE,
+    useClass: IbSumAggregate,
+    multi: true,
+};
+class IbAverageAggregate extends IbAggregate {
+    id = "avg";
+    name = "shared.aggregate.avg.name";
+    label = "shared.aggregate.avg.label";
+    type = "number";
+    aggregateData(data) {
+        const length = Math.max(data.length, 1);
+        return data.reduce((acc, cur) => acc + cur, 0) / length;
+    }
+}
+export const IbAverageAggregateProvider = {
+    provide: IB_AGGREGATE,
+    useClass: IbAverageAggregate,
+    multi: true,
+};
+export class IbAggregateCell {
+    column;
+    type;
+    functions;
+    set function(fun) {
+        this.updateDisplayName(fun);
+    }
+    result = {
+        currentPage: undefined,
+        total: undefined,
+    };
+    showTotal = true;
+    ibFunctionChange = new EventEmitter();
+    availableFunctions = [];
+    displayName = "";
+    constructor(column, type, functions) {
+        this.column = column;
+        this.type = type;
+        this.functions = functions;
+        this.availableFunctions = functions.filter((f) => f.type === type);
+    }
+    apply(fun) {
+        this.ibFunctionChange.emit(fun);
+    }
+    updateDisplayName(fun) {
+        const strategy = this.availableFunctions.find((f) => f.id === fun);
+        if (!strategy) {
+            this.displayName = "";
+            this.result = { currentPage: undefined, total: undefined };
+            return;
+        }
+        this.displayName = strategy.name;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbAggregateCell, deps: [{ token: IB_COLUMN }, { token: IB_AGGREGATE_TYPE, optional: true }, { token: IB_AGGREGATE, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: IbAggregateCell, selector: "ib-aggregate", inputs: { function: "function", result: "result", showTotal: "showTotal" }, outputs: { ibFunctionChange: "ibFunctionChange" }, ngImport: i0, template: `
+    <section class="ib-aggregate__function">
+      <button
+        mat-icon-button
+        [matMenuTriggerFor]="menu"
+        [matTooltip]="'shared.aggregate.apply' | translate"
+      >
+        <mat-icon>functions</mat-icon>
+      </button>
+      <span class="mat-caption">{{ displayName | translate }}</span>
+    </section>
+    <mat-menu #menu="matMenu">
+      <button
+        *ngFor="let function of availableFunctions"
+        mat-menu-item
+        (click)="apply(function.id)"
+      >
+        {{ function.label | translate }}
+      </button>
+    </mat-menu>
+    <section class="ib-aggregate__display-value">
+      <div>
+        <span class="mat-caption">{{
+          "shared.aggregate.currentPage" | translate
+        }}</span>
+        {{ result?.currentPage ? (result.currentPage | number) : "--" }}
+      </div>
+
+      <div *ngIf="showTotal">
+        <span class="mat-caption">{{
+          "shared.aggregate.total" | translate
+        }}</span>
+        {{ result?.total ? (result.total | number) : "--" }}
+      </div>
+    </section>
+  `, isInline: true, 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.MatMenu, selector: "mat-menu", inputs: ["backdropClass", "aria-label", "aria-labelledby", "aria-describedby", "xPosition", "yPosition", "overlapTrigger", "hasBackdrop", "class", "classList"], outputs: ["closed", "close"], exportAs: ["matMenu"] }, { kind: "component", type: i2.MatMenuItem, selector: "[mat-menu-item]", inputs: ["role", "disabled", "disableRipple"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i2.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", inputs: ["mat-menu-trigger-for", "matMenuTriggerFor", "matMenuTriggerData", "matMenuTriggerRestoreFocus"], outputs: ["menuOpened", "onMenuOpen", "menuClosed", "onMenuClose"], exportAs: ["matMenuTrigger"] }, { kind: "component", type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i4.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "directive", type: i5.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "pipe", type: i1.DecimalPipe, name: "number" }, { kind: "pipe", type: i6.TranslatePipe, name: "translate" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbAggregateCell, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "ib-aggregate",
+                    template: `
+    <section class="ib-aggregate__function">
+      <button
+        mat-icon-button
+        [matMenuTriggerFor]="menu"
+        [matTooltip]="'shared.aggregate.apply' | translate"
+      >
+        <mat-icon>functions</mat-icon>
+      </button>
+      <span class="mat-caption">{{ displayName | translate }}</span>
+    </section>
+    <mat-menu #menu="matMenu">
+      <button
+        *ngFor="let function of availableFunctions"
+        mat-menu-item
+        (click)="apply(function.id)"
+      >
+        {{ function.label | translate }}
+      </button>
+    </mat-menu>
+    <section class="ib-aggregate__display-value">
+      <div>
+        <span class="mat-caption">{{
+          "shared.aggregate.currentPage" | translate
+        }}</span>
+        {{ result?.currentPage ? (result.currentPage | number) : "--" }}
+      </div>
+
+      <div *ngIf="showTotal">
+        <span class="mat-caption">{{
+          "shared.aggregate.total" | translate
+        }}</span>
+        {{ result?.total ? (result.total | number) : "--" }}
+      </div>
+    </section>
+  `,
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [IB_COLUMN]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [IB_AGGREGATE_TYPE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [IB_AGGREGATE]
+                }] }], propDecorators: { function: [{
+                type: Input
+            }], result: [{
+                type: Input
+            }], showTotal: [{
+                type: Input
+            }], ibFunctionChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cells.js","sourceRoot":"","sources":["../../../../../../../src/app/inobeta-ui/ui/kai-table/cells.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,SAAS,EACT,YAAY,EACZ,MAAM,EACN,KAAK,EACL,QAAQ,EACR,MAAM,GAEP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;;;;;;;;AAKtE,MAAM,OAAO,SAAS;IACD;IAAnB,YAAmB,WAAiC;QAAjC,gBAAW,GAAX,WAAW,CAAsB;IAAG,CAAC;uGAD7C,SAAS;2FAAT,SAAS;;2FAAT,SAAS;kBAHrB,SAAS;mBAAC;oBACT,QAAQ,EAAE,aAAa;iBACxB;;AAUD,MAAM,OAAgB,WAAW;IAc/B;;;;;;;;OAQG;IACH,SAAS;IACP;;OAEG;IACH,UAAe,EACf,MAAc;QAEd,MAAM,OAAO,GAAG,UAAU;aACvB,UAAU,CAAC,UAAU,CAAC,YAAY,CAAC;aACnC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;QACzB,MAAM,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAChD,OAAO;YACL,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;YAC1C,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;SACnC,CAAC;IACJ,CAAC;CASF;AAED,MAAM,cAAe,SAAQ,WAAW;IACtC,EAAE,GAAG,KAAK,CAAC;IACX,IAAI,GAAG,2BAA2B,CAAC;IACnC,KAAK,GAAG,4BAA4B,CAAC;IACrC,IAAI,GAAG,QAAQ,CAAC;IAEhB,aAAa,CAAC,IAAc;QAC1B,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC;IACjD,CAAC;CACF;AAED,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,OAAO,EAAE,YAAY;IACrB,QAAQ,EAAE,cAAc;IACxB,KAAK,EAAE,IAAI;CACZ,CAAC;AAEF,MAAM,kBAAmB,SAAQ,WAAW;IAC1C,EAAE,GAAG,KAAK,CAAC;IACX,IAAI,GAAG,2BAA2B,CAAC;IACnC,KAAK,GAAG,4BAA4B,CAAC;IACrC,IAAI,GAAG,QAAQ,CAAC;IAEhB,aAAa,CAAC,IAAc;QAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QACxC,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC;IAC1D,CAAC;CACF;AAED,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,OAAO,EAAE,YAAY;IACrB,QAAQ,EAAE,kBAAkB;IAC5B,KAAK,EAAE,IAAI;CACZ,CAAC;AAyCF,MAAM,OAAO,eAAe;IAgBG;IACoB;IACL;IAjB5C,IAAa,QAAQ,CAAC,GAAW;QAC/B,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IACQ,MAAM,GAAsB;QACnC,WAAW,EAAE,SAAS;QACtB,KAAK,EAAE,SAAS;KACjB,CAAC;IAEO,SAAS,GAAG,IAAI,CAAC;IAChB,gBAAgB,GAAG,IAAI,YAAY,EAAU,CAAC;IAExD,kBAAkB,GAAkB,EAAE,CAAC;IACvC,WAAW,GAAG,EAAE,CAAC;IAEjB,YAC6B,MAAW,EACS,IAAY,EACjB,SAAwB;QAFvC,WAAM,GAAN,MAAM,CAAK;QACS,SAAI,GAAJ,IAAI,CAAQ;QACjB,cAAS,GAAT,SAAS,CAAe;QAElE,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;IACrE,CAAC;IAED,KAAK,CAAC,GAAW;QACf,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAED,iBAAiB,CAAC,GAAW;QAC3B,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC;QACnE,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;YACtB,IAAI,CAAC,MAAM,GAAG,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;YAC3D,OAAO;QACT,CAAC;QAED,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,IAAI,CAAC;IACnC,CAAC;uGApCU,eAAe,kBAgBhB,SAAS,aACG,iBAAiB,6BACjB,YAAY;2FAlBvB,eAAe,mLArChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCT;;2FAEU,eAAe;kBAvC3B,SAAS;mBAAC;oBACT,QAAQ,EAAE,cAAc;oBACxB,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCT;iBACF;;0BAiBI,MAAM;2BAAC,SAAS;;0BAChB,QAAQ;;0BAAI,MAAM;2BAAC,iBAAiB;;0BACpC,QAAQ;;0BAAI,MAAM;2BAAC,YAAY;yCAjBrB,QAAQ;sBAApB,KAAK;gBAGG,MAAM;sBAAd,KAAK;gBAKG,SAAS;sBAAjB,KAAK;gBACI,gBAAgB;sBAAzB,MAAM","sourcesContent":["import {\n  Component,\n  Directive,\n  EventEmitter,\n  Inject,\n  Input,\n  Optional,\n  Output,\n  TemplateRef,\n} from \"@angular/core\";\nimport { IB_AGGREGATE, IB_AGGREGATE_TYPE, IB_COLUMN } from \"./tokens\";\n\n@Directive({\n  selector: \"[ibCellDef]\",\n})\nexport class IbCellDef {\n  constructor(public templateRef: TemplateRef<unknown>) {}\n}\n\nexport interface IbAggregateResult {\n  currentPage?: number | string | undefined;\n  total?: number | string | undefined;\n}\n\nexport abstract class IbAggregate {\n  /** Unique identifier for the aggregate function. */\n  abstract id: string;\n  /** Function name displayed before the results. i18n supported. */\n  abstract name: string;\n  /** Menu item label. i18n supported. */\n  abstract label: string;\n  /**\n   * Function type. Used to include this function in the available functions of\n   * a given column with the same `IB_AGGREGATE_TYPE` token value.\n   * Currently, only `number` is supported.\n   */\n  abstract type: string;\n\n  /**\n   * Calls {@link aggregateData} twice and returns an {@link IbAggregateResult}\n   * with the aggregated value for the entire column and the current visible page.\n   *\n   * It takes into account only filtered data.\n   *\n   * @param dataSource `IbTableDataSource` compatible data source instance\n   * @param column Column name\n   */\n  aggregate(\n    /**\n     * Note: this is any to avoid an importing cycle\n     */\n    dataSource: any,\n    column: string\n  ): IbAggregateResult {\n    const dataset = dataSource\n      ._orderData(dataSource.filteredData)\n      .map((i) => i[column]);\n    const pagedData = dataSource._pageData(dataset);\n    return {\n      currentPage: this.aggregateData(pagedData),\n      total: this.aggregateData(dataset),\n    };\n  }\n\n  /**\n   * An aggregate function.\n   *\n   * @param data Data array of a given column.\n   * @returns Aggregated value.\n   */\n  abstract aggregateData(data: any[]): number | string;\n}\n\nclass IbSumAggregate extends IbAggregate {\n  id = \"sum\";\n  name = \"shared.aggregate.sum.name\";\n  label = \"shared.aggregate.sum.label\";\n  type = \"number\";\n\n  aggregateData(data: number[]) {\n    return data.reduce((acc, cur) => acc + cur, 0);\n  }\n}\n\nexport const IbSumAggregateProvider = {\n  provide: IB_AGGREGATE,\n  useClass: IbSumAggregate,\n  multi: true,\n};\n\nclass IbAverageAggregate extends IbAggregate {\n  id = \"avg\";\n  name = \"shared.aggregate.avg.name\";\n  label = \"shared.aggregate.avg.label\";\n  type = \"number\";\n\n  aggregateData(data: number[]) {\n    const length = Math.max(data.length, 1);\n    return data.reduce((acc, cur) => acc + cur, 0) / length;\n  }\n}\n\nexport const IbAverageAggregateProvider = {\n  provide: IB_AGGREGATE,\n  useClass: IbAverageAggregate,\n  multi: true,\n};\n\n@Component({\n  selector: \"ib-aggregate\",\n  template: `\n    <section class=\"ib-aggregate__function\">\n      <button\n        mat-icon-button\n        [matMenuTriggerFor]=\"menu\"\n        [matTooltip]=\"'shared.aggregate.apply' | translate\"\n      >\n        <mat-icon>functions</mat-icon>\n      </button>\n      <span class=\"mat-caption\">{{ displayName | translate }}</span>\n    </section>\n    <mat-menu #menu=\"matMenu\">\n      <button\n        *ngFor=\"let function of availableFunctions\"\n        mat-menu-item\n        (click)=\"apply(function.id)\"\n      >\n        {{ function.label | translate }}\n      </button>\n    </mat-menu>\n    <section class=\"ib-aggregate__display-value\">\n      <div>\n        <span class=\"mat-caption\">{{\n          \"shared.aggregate.currentPage\" | translate\n        }}</span>\n        {{ result?.currentPage ? (result.currentPage | number) : \"--\" }}\n      </div>\n\n      <div *ngIf=\"showTotal\">\n        <span class=\"mat-caption\">{{\n          \"shared.aggregate.total\" | translate\n        }}</span>\n        {{ result?.total ? (result.total | number) : \"--\" }}\n      </div>\n    </section>\n  `,\n})\nexport class IbAggregateCell {\n  @Input() set function(fun: string) {\n    this.updateDisplayName(fun);\n  }\n  @Input() result: IbAggregateResult = {\n    currentPage: undefined,\n    total: undefined,\n  };\n\n  @Input() showTotal = true;\n  @Output() ibFunctionChange = new EventEmitter<string>();\n\n  availableFunctions: IbAggregate[] = [];\n  displayName = \"\";\n\n  constructor(\n    @Inject(IB_COLUMN) private column: any,\n    @Optional() @Inject(IB_AGGREGATE_TYPE) private type: string,\n    @Optional() @Inject(IB_AGGREGATE) private functions: IbAggregate[]\n  ) {\n    this.availableFunctions = functions.filter((f) => f.type === type);\n  }\n\n  apply(fun: string) {\n    this.ibFunctionChange.emit(fun);\n  }\n\n  updateDisplayName(fun: string) {\n    const strategy = this.availableFunctions.find((f) => f.id === fun);\n    if (!strategy) {\n      this.displayName = \"\";\n      this.result = { currentPage: undefined, total: undefined };\n      return;\n    }\n\n    this.displayName = strategy.name;\n  }\n}\n"]}

package/esm2022/src/app/inobeta-ui/ui/kai-table/columns/action-column.mjs

@@ -0,0 +1,23 @@
+import { Directive } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "./column";
+export class IbActionColumn {
+    ibColumn;
+    constructor(ibColumn) {
+        this.ibColumn = ibColumn;
+        this.ibColumn.name = "ib-action";
+    }
+    ngOnInit() {
+        this.ibColumn.headerText = "";
+        this.ibColumn._table.displayedColumns.push("ib-action");
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbActionColumn, deps: [{ token: i1.IbColumn }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: IbActionColumn, selector: "[ib-action-column]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IbActionColumn, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[ib-action-column]",
+                }]
+        }], ctorParameters: () => [{ type: i1.IbColumn }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9uLWNvbHVtbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvaW5vYmV0YS11aS91aS9rYWktdGFibGUvY29sdW1ucy9hY3Rpb24tY29sdW1uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7OztBQU0xQyxNQUFNLE9BQU8sY0FBYztJQUNOO0lBQW5CLFlBQW1CLFFBQTJCO1FBQTNCLGFBQVEsR0FBUixRQUFRLENBQW1CO1FBQzVDLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxHQUFHLFdBQVcsQ0FBQztJQUNuQyxDQUFDO0lBRUQsUUFBUTtRQUNOLElBQUksQ0FBQyxRQUFRLENBQUMsVUFBVSxHQUFHLEVBQUUsQ0FBQztRQUM5QixJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUE7SUFDekQsQ0FBQzt1R0FSVSxjQUFjOzJGQUFkLGNBQWM7OzJGQUFkLGNBQWM7a0JBSDFCLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLG9CQUFvQjtpQkFDL0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgSWJDb2x1bW4gfSBmcm9tIFwiLi9jb2x1bW5cIjtcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiBcIltpYi1hY3Rpb24tY29sdW1uXVwiLFxufSlcbmV4cG9ydCBjbGFzcyBJYkFjdGlvbkNvbHVtbiB7XG4gIGNvbnN0cnVjdG9yKHB1YmxpYyBpYkNvbHVtbjogSWJDb2x1bW48dW5rbm93bj4pIHtcbiAgICB0aGlzLmliQ29sdW1uLm5hbWUgPSBcImliLWFjdGlvblwiO1xuICB9XG5cbiAgbmdPbkluaXQoKSB7XG4gICAgdGhpcy5pYkNvbHVtbi5oZWFkZXJUZXh0ID0gXCJcIjtcbiAgICB0aGlzLmliQ29sdW1uLl90YWJsZS5kaXNwbGF5ZWRDb2x1bW5zLnB1c2goXCJpYi1hY3Rpb25cIilcbiAgfVxufSJdfQ==