@provoly/dashboard 0.11.0

package/esm2022/widgets/widget-aggregated-chart/service/frontend-aggregation.service.mjs

@@ -0,0 +1,206 @@
+import { Injectable } from '@angular/core';
+import { ClassSelectors, DashboardSelectors, ItemUtils, Operation, ResultsetUtils } from '@provoly/dashboard';
+import { combineLatest, map } from 'rxjs';
+import { PryAggregationService } from './base-aggregation.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+export class PryFrontendAggregationService extends PryAggregationService {
+    constructor(store) {
+        super();
+        this.store = store;
+    }
+    // @ts-ignore
+    aggregate(datasource, options) {
+        return combineLatest([
+            this.store.select(DashboardSelectors.resultSets),
+            this.store.select(ClassSelectors.classes)
+        ]).pipe(map(([resultSets, classes]) => {
+            const abscissa = classes
+                .map((clazz) => clazz.attributes.find((attr) => attr.id === options.abscissa.attribute))
+                .find((attr) => !!attr)?.name;
+            const ordinate = classes
+                .map((clazz) => clazz.attributes.find((attr) => attr.id === options.ordinate.attribute))
+                .find((attr) => !!attr)?.name;
+            if (!abscissa || !ordinate) {
+                throw new Error('abscissaorodinateinvalid');
+            }
+            let data = datasource.map((rsName) => resultSets[rsName ?? '']).filter((rsName) => !!rsName);
+            const resultSet = data.reduce((rs1, rs2) => ResultsetUtils.mergeResultSets(rs1, rs2), {
+                items: {},
+                relations: [],
+                merged: data.length
+            });
+            let items = Object.keys(resultSet.items)
+                .map((classId) => resultSet.items[classId])
+                .reduce((prev, curr) => [...prev, ...curr], []);
+            if (!!options.groupBy) {
+                const groupBy = classes
+                    .map((clazz) => clazz.attributes.find((attr) => attr.id === options.groupBy?.attribute))
+                    .find((attr) => !!attr)?.name;
+                if (!groupBy) {
+                    throw new Error('groupByAttributeisinvalid');
+                }
+                const itemsGrouped = this.groupBy(items, groupBy);
+                const values = [];
+                Object.keys(itemsGrouped).forEach((key) => {
+                    values.push({
+                        key,
+                        groupBy: this.getValueFromOperation(itemsGrouped[key], options.ordinate.operation, abscissa, ordinate, options.abscissa.limit)
+                    });
+                });
+                return { operation: options.ordinate.operation, values: values };
+            }
+            const values = this.getValueFromOperation(items, options.ordinate.operation, abscissa, ordinate, options.abscissa.limit);
+            return { operation: options.ordinate.operation, values: values };
+        }));
+    }
+    getValueFromOperation(items, operation, abscissa, ordinate, limit) {
+        let result = [];
+        const groupByAbscissa = this.groupBy(items, abscissa);
+        groupByAbscissa.map((test) => console.log(groupByAbscissa[test]));
+        switch (operation) {
+            case Operation.COUNT:
+                result.push(...Object.keys(groupByAbscissa).map((key) => ({
+                    key: key,
+                    value: groupByAbscissa[key].length
+                })));
+                break;
+            case Operation.SUM:
+                result.push(...Object.keys(groupByAbscissa).map((key) => ({
+                    key: key,
+                    value: this.getSum(groupByAbscissa[key], ordinate)
+                })));
+                break;
+            case Operation.DISTINCT:
+                result.push(...Object.keys(groupByAbscissa).map((key) => ({
+                    key: key,
+                    value: this.getDistinct(groupByAbscissa[key], ordinate)
+                })));
+                break;
+            case Operation.AVERAGE:
+                result.push(...Object.keys(groupByAbscissa).map((key) => ({
+                    key: key,
+                    value: this.getAverage(groupByAbscissa[key], ordinate)
+                })));
+                break;
+            case Operation.MEDIAN:
+                result.push(...Object.keys(groupByAbscissa).map((key) => ({
+                    key: key,
+                    value: this.getQuartile(groupByAbscissa[key], ordinate, 0.5)
+                })));
+                break;
+            case Operation.Q1:
+                result.push(...Object.keys(groupByAbscissa).map((key) => ({
+                    key: key,
+                    value: this.getQuartile(groupByAbscissa[key], ordinate, 0.25)
+                })));
+                break;
+            case Operation.Q3:
+                result.push(...Object.keys(groupByAbscissa).map((key) => ({
+                    key: key,
+                    value: this.getQuartile(groupByAbscissa[key], ordinate, 0.75)
+                })));
+                break;
+            case Operation.MIN:
+                result.push(...Object.keys(groupByAbscissa).map((key) => ({
+                    key: key,
+                    value: this.getMin(groupByAbscissa[key], ordinate)
+                })));
+                break;
+            default:
+                result.push(...Object.keys(groupByAbscissa).map((key) => ({
+                    key: key,
+                    value: this.getMax(groupByAbscissa[key], ordinate)
+                })));
+                break;
+        }
+        if (limit) {
+            result = this.formatByLimit(result, limit);
+        }
+        return result;
+    }
+    groupBy(items, attribute) {
+        let distincts = [];
+        items.forEach((item) => {
+            let value = this.getValueFromAttribute(item, attribute);
+            if (distincts[value.value]) {
+                distincts[value.value].push(item);
+            }
+            else {
+                distincts[value.value] = [item];
+            }
+        });
+        return distincts;
+    }
+    getValueFromAttribute(item, attribute) {
+        let value = ItemUtils.getAttributeValue(item, attribute);
+        return Array.isArray(value) ? value[0] : value;
+    }
+    getSum(items, attribute) {
+        let sum = 0;
+        items.forEach((item) => {
+            sum += this.getValueFromAttribute(item, attribute).value;
+        });
+        return sum;
+    }
+    getMin(items, attribute) {
+        const result = items.reduce((prev, curr) => {
+            const prevValue = this.getValueFromAttribute(prev, attribute).value;
+            const currValue = this.getValueFromAttribute(curr, attribute).value;
+            return prevValue < currValue ? prev : curr;
+        });
+        return this.getValueFromAttribute(result, attribute).value;
+    }
+    getMax(items, attribute) {
+        const result = items.reduce((prev, curr) => {
+            const prevValue = this.getValueFromAttribute(prev, attribute).value;
+            const currValue = this.getValueFromAttribute(curr, attribute).value;
+            return prevValue > currValue ? prev : curr;
+        });
+        return this.getValueFromAttribute(result, attribute).value;
+    }
+    getAverage(items, attribute) {
+        const allValues = items.map((item) => this.getValueFromAttribute(item, attribute).value);
+        return allValues.reduce((acc, val) => acc + val, 0) / allValues.length;
+    }
+    getDistinct(items, attribute) {
+        return [...new Set(items.map((item) => this.getValueFromAttribute(item, attribute).value))].length;
+    }
+    getQuartile(items, attribute, q) {
+        const allValues = items.map((item) => this.getValueFromAttribute(item, attribute).value);
+        const allValuesSorted = allValues.sort((a, b) => a - b);
+        let pos = (allValuesSorted.length - 1) * q;
+        if (pos % 1 === 0) {
+            return allValuesSorted[pos];
+        }
+        pos = Math.floor(pos);
+        if (allValuesSorted[pos + 1] !== undefined) {
+            return (allValuesSorted[pos] + allValuesSorted[pos + 1]) / 2;
+        }
+        return allValuesSorted[pos];
+    }
+    getPercentile(items, attribute, q) {
+        const allValues = items.map((item) => this.getValueFromAttribute(item, attribute).value);
+        const allValuesSorted = allValues.sort((a, b) => a - b);
+        return ((100 * allValuesSorted.reduce((acc, v) => acc + (v < q ? 1 : 0) + (v === q ? 0.5 : 0), 0)) /
+            allValuesSorted.length);
+    }
+    formatByLimit(data, limit) {
+        if (!limit.isTimeLimit) {
+            data
+                .sort((a, b) => (limit.order === 'asc' ? (a.value > b.value ? 1 : -1) : a.value < b.value ? 1 : -1))
+                .splice(limit.at);
+            return data;
+        }
+        return data;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: PryFrontendAggregationService, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: PryFrontendAggregationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: PryFrontendAggregationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frontend-aggregation.service.js","sourceRoot":"","sources":["../../../../../../../projects/provoly/dashboard/widgets/widget-aggregated-chart/service/frontend-aggregation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport {\n  AtLimit,\n  ChartAggregatedWidgetOptions,\n  ClassSelectors,\n  DashboardSelectors,\n  Item,\n  ItemUtils,\n  Operation,\n  ResultsetUtils,\n  TimeLimit,\n  ValueType\n} from '@provoly/dashboard';\nimport { combineLatest, map, Observable } from 'rxjs';\nimport { AggregationResult, PryAggregationService } from './base-aggregation.service';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PryFrontendAggregationService extends PryAggregationService {\n  constructor(private store: Store) {\n    super();\n  }\n\n  // @ts-ignore\n  override aggregate(datasource: string[], options: ChartAggregatedWidgetOptions): Observable<AggregationResult> {\n    return combineLatest([\n      this.store.select(DashboardSelectors.resultSets),\n      this.store.select(ClassSelectors.classes)\n    ]).pipe(\n      map(([resultSets, classes]) => {\n        const abscissa = classes\n          .map((clazz) => clazz.attributes.find((attr) => attr.id === options.abscissa.attribute))\n          .find((attr) => !!attr)?.name;\n        const ordinate = classes\n          .map((clazz) => clazz.attributes.find((attr) => attr.id === options.ordinate.attribute))\n          .find((attr) => !!attr)?.name;\n        if (!abscissa || !ordinate) {\n          throw new Error('abscissaorodinateinvalid');\n        }\n        let data = datasource.map((rsName) => resultSets[rsName ?? '']).filter((rsName) => !!rsName);\n        const resultSet = data.reduce((rs1, rs2) => ResultsetUtils.mergeResultSets(rs1, rs2), {\n          items: {},\n          relations: [],\n          merged: data.length\n        });\n        let items: Item[] = Object.keys(resultSet.items)\n          .map((classId) => resultSet.items[classId])\n          .reduce((prev, curr) => [...prev, ...curr], []) as Item[];\n        if (!!options.groupBy) {\n          const groupBy = classes\n            .map((clazz) => clazz.attributes.find((attr) => attr.id === options.groupBy?.attribute))\n            .find((attr) => !!attr)?.name;\n          if (!groupBy) {\n            throw new Error('groupByAttributeisinvalid');\n          }\n          const itemsGrouped: { [key: string | number]: Item[] } = this.groupBy(items, groupBy);\n          const values: { key: ValueType; groupBy: {}[] }[] = [];\n          Object.keys(itemsGrouped).forEach((key) => {\n            values.push({\n              key,\n              groupBy: this.getValueFromOperation(\n                itemsGrouped[key],\n                options.ordinate.operation,\n                abscissa,\n                ordinate,\n                options.abscissa.limit\n              )\n            });\n          });\n          return { operation: options.ordinate.operation, values: values } as AggregationResult;\n        }\n        const values = this.getValueFromOperation(\n          items,\n          options.ordinate.operation,\n          abscissa,\n          ordinate,\n          options.abscissa.limit\n        );\n        return { operation: options.ordinate.operation, values: values } as AggregationResult;\n      })\n    );\n  }\n\n  getValueFromOperation(\n    items: Item[],\n    operation: Operation,\n    abscissa: string,\n    ordinate: string,\n    limit?: AtLimit | TimeLimit\n  ) {\n    let result: { key: ValueType; value: ValueType }[] = [];\n    const groupByAbscissa = this.groupBy(items, abscissa);\n    groupByAbscissa.map((test: any) => console.log(groupByAbscissa[test]));\n    switch (operation) {\n      case Operation.COUNT:\n        result.push(\n          ...Object.keys(groupByAbscissa).map((key) => ({\n            key: key,\n            value: groupByAbscissa[key].length\n          }))\n        );\n        break;\n      case Operation.SUM:\n        result.push(\n          ...Object.keys(groupByAbscissa).map((key) => ({\n            key: key,\n            value: this.getSum(groupByAbscissa[key], ordinate)\n          }))\n        );\n        break;\n      case Operation.DISTINCT:\n        result.push(\n          ...Object.keys(groupByAbscissa).map((key) => ({\n            key: key,\n            value: this.getDistinct(groupByAbscissa[key], ordinate)\n          }))\n        );\n        break;\n      case Operation.AVERAGE:\n        result.push(\n          ...Object.keys(groupByAbscissa).map((key) => ({\n            key: key,\n            value: this.getAverage(groupByAbscissa[key], ordinate)\n          }))\n        );\n        break;\n      case Operation.MEDIAN:\n        result.push(\n          ...Object.keys(groupByAbscissa).map((key) => ({\n            key: key,\n            value: this.getQuartile(groupByAbscissa[key], ordinate, 0.5)\n          }))\n        );\n        break;\n      case Operation.Q1:\n        result.push(\n          ...Object.keys(groupByAbscissa).map((key) => ({\n            key: key,\n            value: this.getQuartile(groupByAbscissa[key], ordinate, 0.25)\n          }))\n        );\n        break;\n      case Operation.Q3:\n        result.push(\n          ...Object.keys(groupByAbscissa).map((key) => ({\n            key: key,\n            value: this.getQuartile(groupByAbscissa[key], ordinate, 0.75)\n          }))\n        );\n        break;\n      case Operation.MIN:\n        result.push(\n          ...Object.keys(groupByAbscissa).map((key) => ({\n            key: key,\n            value: this.getMin(groupByAbscissa[key], ordinate)\n          }))\n        );\n        break;\n      default:\n        result.push(\n          ...Object.keys(groupByAbscissa).map((key) => ({\n            key: key,\n            value: this.getMax(groupByAbscissa[key], ordinate)\n          }))\n        );\n        break;\n    }\n    if (limit) {\n      result = this.formatByLimit(result, limit);\n    }\n    return result;\n  }\n\n  groupBy(items: Item[], attribute: string) {\n    let distincts: any = [];\n    items.forEach((item: Item) => {\n      let value = this.getValueFromAttribute(item, attribute);\n      if (distincts[value.value as string | number]) {\n        distincts[value.value as string | number].push(item);\n      } else {\n        distincts[value.value as string | number] = [item];\n      }\n    });\n    return distincts;\n  }\n\n  getValueFromAttribute(item: Item, attribute: string) {\n    let value = ItemUtils.getAttributeValue(item, attribute);\n    return Array.isArray(value) ? value[0] : value;\n  }\n\n  getSum(items: Item[], attribute: string) {\n    let sum: number = 0;\n    items.forEach((item) => {\n      sum += this.getValueFromAttribute(item, attribute).value as number;\n    });\n    return sum;\n  }\n\n  getMin(items: Item[], attribute: string) {\n    const result = items.reduce((prev: any, curr: any) => {\n      const prevValue = this.getValueFromAttribute(prev, attribute).value;\n      const currValue = this.getValueFromAttribute(curr, attribute).value;\n      return prevValue < currValue ? prev : curr;\n    });\n    return this.getValueFromAttribute(result, attribute).value;\n  }\n\n  getMax(items: Item[], attribute: string) {\n    const result = items.reduce((prev: any, curr: any) => {\n      const prevValue = this.getValueFromAttribute(prev, attribute).value;\n      const currValue = this.getValueFromAttribute(curr, attribute).value;\n      return prevValue > currValue ? prev : curr;\n    });\n    return this.getValueFromAttribute(result, attribute).value;\n  }\n\n  getAverage(items: Item[], attribute: string) {\n    const allValues = items.map((item) => this.getValueFromAttribute(item, attribute).value as number);\n    return allValues.reduce((acc, val) => acc + val, 0) / allValues.length;\n  }\n\n  getDistinct(items: Item[], attribute: string) {\n    return [...new Set(items.map((item) => this.getValueFromAttribute(item, attribute).value))].length;\n  }\n\n  getQuartile(items: Item[], attribute: string, q: number) {\n    const allValues = items.map((item) => this.getValueFromAttribute(item, attribute).value as number);\n    const allValuesSorted = allValues.sort((a: number, b: number) => a - b);\n\n    let pos = (allValuesSorted.length - 1) * q;\n    if (pos % 1 === 0) {\n      return allValuesSorted[pos];\n    }\n\n    pos = Math.floor(pos);\n    if (allValuesSorted[pos + 1] !== undefined) {\n      return (allValuesSorted[pos] + allValuesSorted[pos + 1]) / 2;\n    }\n\n    return allValuesSorted[pos];\n  }\n\n  getPercentile(items: Item[], attribute: string, q: number) {\n    const allValues = items.map((item) => this.getValueFromAttribute(item, attribute).value as number);\n    const allValuesSorted = allValues.sort((a: number, b: number) => a - b);\n    return (\n      (100 * allValuesSorted.reduce((acc, v) => acc + (v < q ? 1 : 0) + (v === q ? 0.5 : 0), 0)) /\n      allValuesSorted.length\n    );\n  }\n\n  formatByLimit(data: { key: ValueType; value: ValueType }[], limit: AtLimit | TimeLimit) {\n    if (!limit.isTimeLimit) {\n      data\n        .sort((a, b) => (limit.order === 'asc' ? (a.value > b.value ? 1 : -1) : a.value < b.value ? 1 : -1))\n        .splice(limit.at);\n      return data;\n    }\n    return data;\n  }\n}\n"]}

package/esm2022/widgets/widget-aggregated-chart/style/css.component.mjs

@@ -0,0 +1,11 @@
+import { Component, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PryWidgetAggregatedChartCssComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: PryWidgetAggregatedChartCssComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.6", type: PryWidgetAggregatedChartCssComponent, selector: "pry-widget-aggregated-chart-css", ngImport: i0, template: '', isInline: true, styles: [".o-widget--chart-color-thumb{display:flex;flex-direction:row;margin-bottom:20px}.o-widget--chart-color-thumb-item{flex:1 1 20px;height:20px;border-radius:4px}.o-widget--chart div.vega-embed{display:block}.o-widget--chart div.vega-embed.has-actions{display:block;height:100%;padding-right:0}.o-widget--chart div.vega-embed.has-actions>div.chart-wrapper.fit-y.fit-x{height:100%;overflow:hidden}.o-widget--chart div.vega-embed.has-actions>details>summary{right:25px}.o-widget--chart div.vega-embed.has-actions>details .vega-actions{right:16px}\n"], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: PryWidgetAggregatedChartCssComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pry-widget-aggregated-chart-css', template: '', encapsulation: ViewEncapsulation.None, styles: [".o-widget--chart-color-thumb{display:flex;flex-direction:row;margin-bottom:20px}.o-widget--chart-color-thumb-item{flex:1 1 20px;height:20px;border-radius:4px}.o-widget--chart div.vega-embed{display:block}.o-widget--chart div.vega-embed.has-actions{display:block;height:100%;padding-right:0}.o-widget--chart div.vega-embed.has-actions>div.chart-wrapper.fit-y.fit-x{height:100%;overflow:hidden}.o-widget--chart div.vega-embed.has-actions>details>summary{right:25px}.o-widget--chart div.vega-embed.has-actions>details .vega-actions{right:16px}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3NzLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3Byb3ZvbHkvZGFzaGJvYXJkL3dpZGdldHMvd2lkZ2V0LWFnZ3JlZ2F0ZWQtY2hhcnQvc3R5bGUvY3NzLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVE3RCxNQUFNLE9BQU8sb0NBQW9DOzhHQUFwQyxvQ0FBb0M7a0dBQXBDLG9DQUFvQyx1RUFKckMsRUFBRTs7MkZBSUQsb0NBQW9DO2tCQU5oRCxTQUFTOytCQUNFLGlDQUFpQyxZQUNqQyxFQUFFLGlCQUVHLGlCQUFpQixDQUFDLElBQUkiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIFZpZXdFbmNhcHN1bGF0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ3ByeS13aWRnZXQtYWdncmVnYXRlZC1jaGFydC1jc3MnLFxuICB0ZW1wbGF0ZTogJycsXG4gIHN0eWxlVXJsczogWycuL19vLXdpZGdldC1jaGFydC5zY3NzJ10sXG4gIGVuY2Fwc3VsYXRpb246IFZpZXdFbmNhcHN1bGF0aW9uLk5vbmVcbn0pXG5leHBvcnQgY2xhc3MgUHJ5V2lkZ2V0QWdncmVnYXRlZENoYXJ0Q3NzQ29tcG9uZW50IHt9XG4iXX0=

package/esm2022/widgets/widget-aggregated-chart/widget-aggregated-chart.module.mjs

@@ -0,0 +1,72 @@
+import { OverlayModule } from '@angular/cdk/overlay';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { BaseWidgetModule, PryCoreModule, PryDashboardModule, PryEditInputModule, PryI18nModule, PryIconModule, PryRangeModule, PrySelectModule, PryToggleModule } from '@provoly/dashboard';
+import { PryCheckboxModule } from '@provoly/dashboard/components/checkbox';
+import { WidgetAggregatedChartComponent } from './component/widget-aggregated-chart.component';
+import { enTranslations } from './i18n/en.translations';
+import { frTranslations } from './i18n/fr.translations';
+import { PryAggregationService } from './service/base-aggregation.service';
+import { PryWidgetAggregatedChartCssComponent } from './style/css.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@provoly/dashboard";
+export class WidgetAggregatedChartModule extends BaseWidgetModule {
+    constructor(pryTranslateService) {
+        super();
+        this.pryTranslateService = pryTranslateService;
+        this.pryTranslateService.addLangObject('fr', 'widget-aggregated-chart', frTranslations);
+        this.pryTranslateService.addLangObject('en', 'widget-aggregated-chart', enTranslations);
+    }
+    getComponent() {
+        return WidgetAggregatedChartComponent;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetAggregatedChartModule, deps: [{ token: i1.PryI18nService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.6", ngImport: i0, type: WidgetAggregatedChartModule, declarations: [WidgetAggregatedChartComponent, PryWidgetAggregatedChartCssComponent], imports: [CommonModule,
+            FormsModule,
+            OverlayModule,
+            PryCoreModule,
+            PryDashboardModule,
+            PrySelectModule,
+            PryIconModule,
+            PryCheckboxModule,
+            PryToggleModule,
+            PryEditInputModule,
+            PryI18nModule,
+            PryRangeModule], exports: [WidgetAggregatedChartComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetAggregatedChartModule, providers: [PryAggregationService], imports: [CommonModule,
+            FormsModule,
+            OverlayModule,
+            PryCoreModule,
+            PryDashboardModule,
+            PrySelectModule,
+            PryIconModule,
+            PryCheckboxModule,
+            PryToggleModule,
+            PryEditInputModule,
+            PryI18nModule,
+            PryRangeModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetAggregatedChartModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [WidgetAggregatedChartComponent, PryWidgetAggregatedChartCssComponent],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        OverlayModule,
+                        PryCoreModule,
+                        PryDashboardModule,
+                        PrySelectModule,
+                        PryIconModule,
+                        PryCheckboxModule,
+                        PryToggleModule,
+                        PryEditInputModule,
+                        PryI18nModule,
+                        PryRangeModule
+                    ],
+                    exports: [WidgetAggregatedChartComponent],
+                    providers: [PryAggregationService]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PryI18nService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/widgets/widget-chart/component/vega-error.handler.mjs

@@ -0,0 +1,36 @@
+import { PRY_CUSTOMEVENT_TYPE } from '@provoly/dashboard';
+import { View } from 'vega';
+let pryLogger = {
+    ...console,
+    debug: () => { },
+    level: () => { },
+    // @ts-ignore
+    error: (err) => {
+        // Making specific Vega error message trapping
+        const customEvent = new CustomEvent(PRY_CUSTOMEVENT_TYPE, {
+            detail: {
+                type: 'error',
+                message: '@pry.snack.default'
+            },
+            bubbles: true,
+            cancelable: true
+        });
+        if (err.stack.includes('Error: missing:')) {
+            customEvent.detail.message = '@pry.snack.missingParent';
+        }
+        else if (err.stack.includes("TypeError: Cannot read properties of undefined (reading 'value')")) {
+            customEvent.detail.message = '@pry.snack.missingValue';
+        }
+        else if (err.stack.includes('Expected number')) {
+            customEvent.detail.message = '@pry.snack.emptyValues';
+        }
+        document.dispatchEvent(customEvent);
+    }
+};
+export class VegaErrorHandler extends View {
+    constructor(runtime, opt) {
+        // @ts-ignore
+        super(runtime, { ...opt, logger: pryLogger });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVnYS1lcnJvci5oYW5kbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvcHJvdm9seS9kYXNoYm9hcmQvd2lkZ2V0cy93aWRnZXQtY2hhcnQvY29tcG9uZW50L3ZlZ2EtZXJyb3IuaGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0JBQW9CLEVBQW1CLE1BQU0sb0JBQW9CLENBQUM7QUFDM0UsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUk1QixJQUFJLFNBQVMsR0FBRztJQUNkLEdBQUcsT0FBTztJQUNWLEtBQUssRUFBRSxHQUFHLEVBQUUsR0FBRSxDQUFDO0lBQ2YsS0FBSyxFQUFFLEdBQUcsRUFBRSxHQUFFLENBQUM7SUFDZixhQUFhO0lBQ2IsS0FBSyxFQUFFLENBQUMsR0FBRyxFQUFFLEVBQUU7UUFDYiw4Q0FBOEM7UUFDOUMsTUFBTSxXQUFXLEdBQUcsSUFBSSxXQUFXLENBQWtCLG9CQUFvQixFQUFFO1lBQ3pFLE1BQU0sRUFBRTtnQkFDTixJQUFJLEVBQUUsT0FBTztnQkFDYixPQUFPLEVBQUUsb0JBQW9CO2FBQzlCO1lBQ0QsT0FBTyxFQUFFLElBQUk7WUFDYixVQUFVLEVBQUUsSUFBSTtTQUNqQixDQUFDLENBQUM7UUFFSCxJQUFJLEdBQUcsQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLGlCQUFpQixDQUFDLEVBQUU7WUFDekMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxPQUFPLEdBQUcsMEJBQTBCLENBQUM7U0FDekQ7YUFBTSxJQUFJLEdBQUcsQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLGtFQUFrRSxDQUFDLEVBQUU7WUFDakcsV0FBVyxDQUFDLE1BQU0sQ0FBQyxPQUFPLEdBQUcseUJBQXlCLENBQUM7U0FDeEQ7YUFBTSxJQUFJLEdBQUcsQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLGlCQUFpQixDQUFDLEVBQUU7WUFDaEQsV0FBVyxDQUFDLE1BQU0sQ0FBQyxPQUFPLEdBQUcsd0JBQXdCLENBQUM7U0FDdkQ7UUFFRCxRQUFRLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ3RDLENBQUM7Q0FDRixDQUFDO0FBRUYsTUFBTSxPQUFPLGdCQUFpQixTQUFRLElBQUk7SUFDeEMsWUFBWSxPQUFnQixFQUFFLEdBQWlCO1FBQzdDLGFBQWE7UUFDYixLQUFLLENBQUMsT0FBTyxFQUFFLEVBQUUsR0FBRyxHQUFHLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDaEQsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUFJZX0NVU1RPTUVWRU5UX1RZUEUsIFByeVNuYWNrTWVzc2FnZSB9IGZyb20gJ0Bwcm92b2x5L2Rhc2hib2FyZCc7XG5pbXBvcnQgeyBWaWV3IH0gZnJvbSAndmVnYSc7XG5pbXBvcnQgeyBWaWV3T3B0aW9ucyB9IGZyb20gJ3ZlZ2EtdHlwaW5ncy90eXBlcy9ydW50aW1lJztcbmltcG9ydCB7IFJ1bnRpbWUgfSBmcm9tICd2ZWdhLXR5cGluZ3MvdHlwZXMvcnVudGltZS9ydW50aW1lJztcblxubGV0IHByeUxvZ2dlciA9IHtcbiAgLi4uY29uc29sZSxcbiAgZGVidWc6ICgpID0+IHt9LFxuICBsZXZlbDogKCkgPT4ge30sXG4gIC8vIEB0cy1pZ25vcmVcbiAgZXJyb3I6IChlcnIpID0+IHtcbiAgICAvLyBNYWtpbmcgc3BlY2lmaWMgVmVnYSBlcnJvciBtZXNzYWdlIHRyYXBwaW5nXG4gICAgY29uc3QgY3VzdG9tRXZlbnQgPSBuZXcgQ3VzdG9tRXZlbnQ8UHJ5U25hY2tNZXNzYWdlPihQUllfQ1VTVE9NRVZFTlRfVFlQRSwge1xuICAgICAgZGV0YWlsOiB7XG4gICAgICAgIHR5cGU6ICdlcnJvcicsXG4gICAgICAgIG1lc3NhZ2U6ICdAcHJ5LnNuYWNrLmRlZmF1bHQnXG4gICAgICB9LFxuICAgICAgYnViYmxlczogdHJ1ZSxcbiAgICAgIGNhbmNlbGFibGU6IHRydWVcbiAgICB9KTtcblxuICAgIGlmIChlcnIuc3RhY2suaW5jbHVkZXMoJ0Vycm9yOiBtaXNzaW5nOicpKSB7XG4gICAgICBjdXN0b21FdmVudC5kZXRhaWwubWVzc2FnZSA9ICdAcHJ5LnNuYWNrLm1pc3NpbmdQYXJlbnQnO1xuICAgIH0gZWxzZSBpZiAoZXJyLnN0YWNrLmluY2x1ZGVzKFwiVHlwZUVycm9yOiBDYW5ub3QgcmVhZCBwcm9wZXJ0aWVzIG9mIHVuZGVmaW5lZCAocmVhZGluZyAndmFsdWUnKVwiKSkge1xuICAgICAgY3VzdG9tRXZlbnQuZGV0YWlsLm1lc3NhZ2UgPSAnQHByeS5zbmFjay5taXNzaW5nVmFsdWUnO1xuICAgIH0gZWxzZSBpZiAoZXJyLnN0YWNrLmluY2x1ZGVzKCdFeHBlY3RlZCBudW1iZXInKSkge1xuICAgICAgY3VzdG9tRXZlbnQuZGV0YWlsLm1lc3NhZ2UgPSAnQHByeS5zbmFjay5lbXB0eVZhbHVlcyc7XG4gICAgfVxuXG4gICAgZG9jdW1lbnQuZGlzcGF0Y2hFdmVudChjdXN0b21FdmVudCk7XG4gIH1cbn07XG5cbmV4cG9ydCBjbGFzcyBWZWdhRXJyb3JIYW5kbGVyIGV4dGVuZHMgVmlldyB7XG4gIGNvbnN0cnVjdG9yKHJ1bnRpbWU6IFJ1bnRpbWUsIG9wdD86IFZpZXdPcHRpb25zKSB7XG4gICAgLy8gQHRzLWlnbm9yZVxuICAgIHN1cGVyKHJ1bnRpbWUsIHsgLi4ub3B0LCBsb2dnZXI6IHByeUxvZ2dlciB9KTtcbiAgfVxufVxuIl19