@kirbydesign/designsystem 7.0.0-rc.0 → 7.0.0-rc.4

package/esm2020/lib/components/charts/chart/chart.component.mjs

@@ -0,0 +1,18 @@
+import { Component, Input } from '@angular/core';
+import { BaseChartComponent, ChartJSService } from '../shared';
+import * as i0 from "@angular/core";
+export class ChartComponent extends BaseChartComponent {
+    constructor() {
+        super(...arguments);
+        this.type = 'column';
+    }
+}
+/** @nocollapse */ ChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.9", ngImport: i0, type: ChartComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ ChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.9", type: ChartComponent, selector: "kirby-chart", inputs: { type: "type" }, providers: [ChartJSService], usesInheritance: true, ngImport: i0, template: "<div class=\"chart-container\">\n  <canvas #chartCanvas>\n    <!-- Slotted content makes it possible to insert fallback content for screen readers \n    https://www.chartjs.org/docs/latest/general/accessibility.html-->\n    <ng-content></ng-content>\n  </canvas>\n</div>\n", styles: [":host div{height:var(--kirby-chart-height, 300px);position:relative}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.9", ngImport: i0, type: ChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'kirby-chart', providers: [ChartJSService], template: "<div class=\"chart-container\">\n  <canvas #chartCanvas>\n    <!-- Slotted content makes it possible to insert fallback content for screen readers \n    https://www.chartjs.org/docs/latest/general/accessibility.html-->\n    <ng-content></ng-content>\n  </canvas>\n</div>\n", styles: [":host div{height:var(--kirby-chart-height, 300px);position:relative}\n"] }]
+        }], propDecorators: { type: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhcnQuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9kZXNpZ25zeXN0ZW0vc3JjL2xpYi9jb21wb25lbnRzL2NoYXJ0cy9jaGFydC9jaGFydC5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Rlc2lnbnN5c3RlbS9zcmMvbGliL2NvbXBvbmVudHMvY2hhcnRzL3NoYXJlZC9iYXNlLWNoYXJ0L2Jhc2UtY2hhcnQuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFakQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLGNBQWMsRUFBYSxNQUFNLFdBQVcsQ0FBQzs7QUFRMUUsTUFBTSxPQUFPLGNBQWUsU0FBUSxrQkFBa0I7SUFOdEQ7O1FBT1csU0FBSSxHQUFnQyxRQUFRLENBQUM7S0FDdkQ7OzhIQUZZLGNBQWM7a0hBQWQsY0FBYyxnRUFGZCxDQUFDLGNBQWMsQ0FBQyxpRENSN0Isa1JBT0E7MkZER2EsY0FBYztrQkFOMUIsU0FBUzsrQkFDRSxhQUFhLGFBR1osQ0FBQyxjQUFjLENBQUM7OEJBR2xCLElBQUk7c0JBQVosS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgQmFzZUNoYXJ0Q29tcG9uZW50LCBDaGFydEpTU2VydmljZSwgQ2hhcnRUeXBlIH0gZnJvbSAnLi4vc2hhcmVkJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAna2lyYnktY2hhcnQnLFxuICB0ZW1wbGF0ZVVybDogJy4uL3NoYXJlZC9iYXNlLWNoYXJ0L2Jhc2UtY2hhcnQuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi4vc2hhcmVkL2Jhc2UtY2hhcnQvYmFzZS1jaGFydC5jb21wb25lbnQuc2NzcyddLFxuICBwcm92aWRlcnM6IFtDaGFydEpTU2VydmljZV0sXG59KVxuZXhwb3J0IGNsYXNzIENoYXJ0Q29tcG9uZW50IGV4dGVuZHMgQmFzZUNoYXJ0Q29tcG9uZW50IHtcbiAgQElucHV0KCkgdHlwZTogRXhjbHVkZTxDaGFydFR5cGUsICdzdG9jayc+ID0gJ2NvbHVtbic7XG59XG4iLCI8ZGl2IGNsYXNzPVwiY2hhcnQtY29udGFpbmVyXCI+XG4gIDxjYW52YXMgI2NoYXJ0Q2FudmFzPlxuICAgIDwhLS0gU2xvdHRlZCBjb250ZW50IG1ha2VzIGl0IHBvc3NpYmxlIHRvIGluc2VydCBmYWxsYmFjayBjb250ZW50IGZvciBzY3JlZW4gcmVhZGVycyBcbiAgICBodHRwczovL3d3dy5jaGFydGpzLm9yZy9kb2NzL2xhdGVzdC9nZW5lcmFsL2FjY2Vzc2liaWxpdHkuaHRtbC0tPlxuICAgIDxuZy1jb250ZW50PjwvbmctY29udGVudD5cbiAgPC9jYW52YXM+XG48L2Rpdj5cbiJdfQ==

package/esm2020/lib/components/charts/chart/index.mjs

@@ -0,0 +1,2 @@
+export { ChartComponent } from './chart.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Rlc2lnbnN5c3RlbS9zcmMvbGliL2NvbXBvbmVudHMvY2hhcnRzL2NoYXJ0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IENoYXJ0Q29tcG9uZW50IH0gZnJvbSAnLi9jaGFydC5jb21wb25lbnQnO1xuIl19

package/esm2020/lib/components/charts/charts.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { ChartComponent } from './chart';
+import { ChartConfigService } from './shared';
+import { StockChartComponent } from './stock-chart';
+import * as i0 from "@angular/core";
+export class ChartsModule {
+}
+/** @nocollapse */ ChartsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.9", ngImport: i0, type: ChartsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ ChartsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.9", ngImport: i0, type: ChartsModule, declarations: [ChartComponent, StockChartComponent], exports: [ChartComponent, StockChartComponent] });
+/** @nocollapse */ ChartsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.9", ngImport: i0, type: ChartsModule, providers: [ChartConfigService] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.9", ngImport: i0, type: ChartsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ChartComponent, StockChartComponent],
+                    exports: [ChartComponent, StockChartComponent],
+                    providers: [ChartConfigService],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhcnRzLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGVzaWduc3lzdGVtL3NyYy9saWIvY29tcG9uZW50cy9jaGFydHMvY2hhcnRzLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDekMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQzlDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFPcEQsTUFBTSxPQUFPLFlBQVk7OzRIQUFaLFlBQVk7NkhBQVosWUFBWSxpQkFKUixjQUFjLEVBQUUsbUJBQW1CLGFBQ3hDLGNBQWMsRUFBRSxtQkFBbUI7NkhBR2xDLFlBQVksYUFGWixDQUFDLGtCQUFrQixDQUFDOzJGQUVwQixZQUFZO2tCQUx4QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxDQUFDLGNBQWMsRUFBRSxtQkFBbUIsQ0FBQztvQkFDbkQsT0FBTyxFQUFFLENBQUMsY0FBYyxFQUFFLG1CQUFtQixDQUFDO29CQUM5QyxTQUFTLEVBQUUsQ0FBQyxrQkFBa0IsQ0FBQztpQkFDaEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBDaGFydENvbXBvbmVudCB9IGZyb20gJy4vY2hhcnQnO1xuaW1wb3J0IHsgQ2hhcnRDb25maWdTZXJ2aWNlIH0gZnJvbSAnLi9zaGFyZWQnO1xuaW1wb3J0IHsgU3RvY2tDaGFydENvbXBvbmVudCB9IGZyb20gJy4vc3RvY2stY2hhcnQnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtDaGFydENvbXBvbmVudCwgU3RvY2tDaGFydENvbXBvbmVudF0sXG4gIGV4cG9ydHM6IFtDaGFydENvbXBvbmVudCwgU3RvY2tDaGFydENvbXBvbmVudF0sXG4gIHByb3ZpZGVyczogW0NoYXJ0Q29uZmlnU2VydmljZV0sXG59KVxuZXhwb3J0IGNsYXNzIENoYXJ0c01vZHVsZSB7fVxuIl19

package/esm2020/lib/components/charts/index.mjs

@@ -0,0 +1,6 @@
+export * from './chart';
+export * from './stock-chart';
+export * from './shared/charts.types';
+export { Chart } from 'chart.js';
+export { ChartsModule } from './charts.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Rlc2lnbnN5c3RlbS9zcmMvbGliL2NvbXBvbmVudHMvY2hhcnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsT0FBTyxFQUEyQyxLQUFLLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFHMUUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jaGFydCc7XG5leHBvcnQgKiBmcm9tICcuL3N0b2NrLWNoYXJ0JztcbmV4cG9ydCAqIGZyb20gJy4vc2hhcmVkL2NoYXJ0cy50eXBlcyc7XG5leHBvcnQgeyBDaGFydE9wdGlvbnMsIENoYXJ0RXZlbnQsIEFjdGl2ZUVsZW1lbnQsIENoYXJ0IH0gZnJvbSAnY2hhcnQuanMnO1xuZXhwb3J0IHsgQW5ub3RhdGlvbk9wdGlvbnMgfSBmcm9tICdjaGFydGpzLXBsdWdpbi1hbm5vdGF0aW9uJztcblxuZXhwb3J0IHsgQ2hhcnRzTW9kdWxlIH0gZnJvbSAnLi9jaGFydHMubW9kdWxlJztcbiJdfQ==

package/esm2020/lib/components/charts/shared/base-chart/base-chart.component.mjs

@@ -0,0 +1,121 @@
+import { Component, ElementRef, HostBinding, Input, ViewChild, } from '@angular/core';
+import { ResizeObserverFactory } from '../../../shared';
+import { ChartJSService } from '../chart-js-service/';
+import * as i0 from "@angular/core";
+import * as i1 from "../chart-js-service/";
+export class BaseChartComponent {
+    constructor(chartJSService) {
+        this.chartJSService = chartJSService;
+        this.chartHasBeenRendered = false;
+    }
+    set height(value) {
+        this._height = typeof value === 'number' ? `${value}px` : value;
+    }
+    ngAfterViewInit() {
+        /*
+           A chart is not rendered until it has both a height and a width.
+           If ChartComponent is slotted in an ionic component it will
+           not have any height or width on afterViewInit. This will cause
+           the animation to not be played on first draw.
+        */
+        const canvasElement = this.canvasElement.nativeElement;
+        this.whenElementHasHeightAndWidth(canvasElement).then(() => this.renderChart());
+    }
+    whenElementHasHeightAndWidth(element) {
+        const rectIs2D = ({ width, height }) => height > 0 && width > 0;
+        return new Promise((resolve) => {
+            const initialClientRect = element.getBoundingClientRect();
+            if (rectIs2D(initialClientRect))
+                resolve();
+            const resizeObserver = new ResizeObserverFactory().create(([resizeObserverEntry]) => {
+                if (rectIs2D(resizeObserverEntry.contentRect)) {
+                    resizeObserver.unobserve(element);
+                    resolve();
+                }
+            });
+            resizeObserver.observe(element);
+        });
+    }
+    ngOnChanges(simpleChanges) {
+        if (this.chartHasBeenRendered) {
+            let shouldRedrawChart = false;
+            const keyUpdateFnPairs = {
+                data: () => this.updateData(),
+                labels: () => this.updateLabels(),
+                type: () => this.updateType(),
+                customOptions: () => this.updateCustomOptions(),
+                annotations: () => this.updateAnnotations(),
+                highlightedElements: () => this.updateHighlightedElements(),
+            };
+            Object.entries(simpleChanges).forEach(([key]) => {
+                if (simpleChanges[key].firstChange || !keyUpdateFnPairs[key])
+                    return;
+                shouldRedrawChart = true;
+                keyUpdateFnPairs[key]();
+            });
+            if (shouldRedrawChart)
+                this.redrawChart();
+        }
+    }
+    renderChart(additionalArgs) {
+        this.chartHasBeenRendered = true;
+        this.chartJSService.renderChart({
+            targetElement: this.canvasElement,
+            type: this.type,
+            data: this.data,
+            labels: this.labels,
+            customOptions: this.customOptions,
+            annotations: this.annotations,
+            highlightedElements: this.highlightedElements,
+            ...additionalArgs,
+        });
+    }
+    updateData() {
+        this.chartJSService.updateData(this.data);
+    }
+    updateLabels() {
+        this.chartJSService.updateLabels(this.labels);
+    }
+    updateType() {
+        this.chartJSService.updateType(this.type, this.customOptions);
+    }
+    updateCustomOptions() {
+        this.chartJSService.updateOptions(this.customOptions, this.type);
+    }
+    updateAnnotations() {
+        this.chartJSService.updateAnnotations(this.annotations);
+    }
+    updateHighlightedElements() {
+        this.chartJSService.updateHighlightedElements(this.highlightedElements);
+    }
+    redrawChart() {
+        this.chartJSService.redrawChart();
+    }
+}
+/** @nocollapse */ BaseChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.9", ngImport: i0, type: BaseChartComponent, deps: [{ token: i1.ChartJSService }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ BaseChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.9", type: BaseChartComponent, selector: "kirby-base-chart", inputs: { type: "type", data: "data", labels: "labels", customOptions: "customOptions", annotations: "annotations", highlightedElements: "highlightedElements", height: "height" }, host: { properties: { "style.--kirby-chart-height": "this._height" } }, viewQueries: [{ propertyName: "canvasElement", first: true, predicate: ["chartCanvas"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"chart-container\">\n  <canvas #chartCanvas>\n    <!-- Slotted content makes it possible to insert fallback content for screen readers \n    https://www.chartjs.org/docs/latest/general/accessibility.html-->\n    <ng-content></ng-content>\n  </canvas>\n</div>\n", styles: [":host div{height:var(--kirby-chart-height, 300px);position:relative}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.9", ngImport: i0, type: BaseChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'kirby-base-chart', template: "<div class=\"chart-container\">\n  <canvas #chartCanvas>\n    <!-- Slotted content makes it possible to insert fallback content for screen readers \n    https://www.chartjs.org/docs/latest/general/accessibility.html-->\n    <ng-content></ng-content>\n  </canvas>\n</div>\n", styles: [":host div{height:var(--kirby-chart-height, 300px);position:relative}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ChartJSService }]; }, propDecorators: { type: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], labels: [{
+                type: Input
+            }], customOptions: [{
+                type: Input
+            }], annotations: [{
+                type: Input
+            }], highlightedElements: [{
+                type: Input
+            }], _height: [{
+                type: HostBinding,
+                args: ['style.--kirby-chart-height']
+            }], height: [{
+                type: Input
+            }], canvasElement: [{
+                type: ViewChild,
+                args: ['chartCanvas']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-chart.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/designsystem/src/lib/components/charts/shared/base-chart/base-chart.component.ts","../../../../../../../../../libs/designsystem/src/lib/components/charts/shared/base-chart/base-chart.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  HostBinding,\n  Input,\n  OnChanges,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core';\nimport { ChartOptions } from 'chart.js';\nimport { AnnotationOptions } from 'chartjs-plugin-annotation';\n\nimport { ChartDataset, ChartHighlightedElements, ChartLabel, ChartType } from '../';\nimport { ResizeObserverFactory } from '../../../shared';\nimport { ChartJSService } from '../chart-js-service/';\n\n@Component({\n  selector: 'kirby-base-chart',\n  templateUrl: './base-chart.component.html',\n  styleUrls: ['./base-chart.component.scss'],\n})\nexport class BaseChartComponent implements AfterViewInit, OnChanges {\n  @Input() type: ChartType;\n  @Input() data: ChartDataset[] | number[];\n\n  @Input() labels: ChartLabel[];\n\n  @Input() customOptions?: ChartOptions;\n  @Input() annotations?: AnnotationOptions[];\n  @Input() highlightedElements?: ChartHighlightedElements;\n\n  @HostBinding('style.--kirby-chart-height')\n  _height: string;\n  @Input() set height(value: string | number) {\n    this._height = typeof value === 'number' ? `${value}px` : value;\n  }\n\n  @ViewChild('chartCanvas')\n  canvasElement: ElementRef<HTMLCanvasElement>;\n\n  private chartHasBeenRendered: boolean = false;\n\n  constructor(protected chartJSService: ChartJSService) {}\n\n  ngAfterViewInit() {\n    /* \n       A chart is not rendered until it has both a height and a width. \n       If ChartComponent is slotted in an ionic component it will\n       not have any height or width on afterViewInit. This will cause \n       the animation to not be played on first draw. \n    */\n    const canvasElement = this.canvasElement.nativeElement;\n    this.whenElementHasHeightAndWidth(canvasElement).then(() => this.renderChart());\n  }\n\n  private whenElementHasHeightAndWidth(element: HTMLElement): Promise<void> {\n    const rectIs2D = ({ width, height }) => height > 0 && width > 0;\n\n    return new Promise((resolve) => {\n      const initialClientRect = element.getBoundingClientRect();\n      if (rectIs2D(initialClientRect)) resolve();\n\n      const resizeObserver = new ResizeObserverFactory().create(([resizeObserverEntry]) => {\n        if (rectIs2D(resizeObserverEntry.contentRect)) {\n          resizeObserver.unobserve(element);\n          resolve();\n        }\n      });\n\n      resizeObserver.observe(element);\n    });\n  }\n\n  ngOnChanges(simpleChanges: SimpleChanges) {\n    if (this.chartHasBeenRendered) {\n      let shouldRedrawChart = false;\n\n      const keyUpdateFnPairs = {\n        data: () => this.updateData(),\n        labels: () => this.updateLabels(),\n        type: () => this.updateType(),\n        customOptions: () => this.updateCustomOptions(),\n        annotations: () => this.updateAnnotations(),\n        highlightedElements: () => this.updateHighlightedElements(),\n      };\n\n      Object.entries(simpleChanges).forEach(([key]) => {\n        if (simpleChanges[key].firstChange || !keyUpdateFnPairs[key]) return;\n        shouldRedrawChart = true;\n        keyUpdateFnPairs[key]();\n      });\n\n      if (shouldRedrawChart) this.redrawChart();\n    }\n  }\n\n  protected renderChart(additionalArgs?: any) {\n    this.chartHasBeenRendered = true;\n    this.chartJSService.renderChart({\n      targetElement: this.canvasElement,\n      type: this.type,\n      data: this.data,\n      labels: this.labels,\n      customOptions: this.customOptions,\n      annotations: this.annotations,\n      highlightedElements: this.highlightedElements,\n      ...additionalArgs,\n    });\n  }\n\n  private updateData() {\n    this.chartJSService.updateData(this.data);\n  }\n\n  private updateLabels() {\n    this.chartJSService.updateLabels(this.labels);\n  }\n\n  private updateType() {\n    this.chartJSService.updateType(this.type, this.customOptions);\n  }\n\n  private updateCustomOptions() {\n    this.chartJSService.updateOptions(this.customOptions, this.type);\n  }\n\n  private updateAnnotations() {\n    this.chartJSService.updateAnnotations(this.annotations);\n  }\n\n  private updateHighlightedElements() {\n    this.chartJSService.updateHighlightedElements(this.highlightedElements);\n  }\n\n  private redrawChart() {\n    this.chartJSService.redrawChart();\n  }\n}\n","<div class=\"chart-container\">\n  <canvas #chartCanvas>\n    <!-- Slotted content makes it possible to insert fallback content for screen readers \n    https://www.chartjs.org/docs/latest/general/accessibility.html-->\n    <ng-content></ng-content>\n  </canvas>\n</div>\n"]}

package/esm2020/lib/components/charts/shared/base-chart/index.mjs

@@ -0,0 +1,2 @@
+export { BaseChartComponent } from './base-chart.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Rlc2lnbnN5c3RlbS9zcmMvbGliL2NvbXBvbmVudHMvY2hhcnRzL3NoYXJlZC9iYXNlLWNoYXJ0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgQmFzZUNoYXJ0Q29tcG9uZW50IH0gZnJvbSAnLi9iYXNlLWNoYXJ0LmNvbXBvbmVudCc7XG4iXX0=

package/esm2020/lib/components/charts/shared/chart-config-service/chart-config.service.mjs

@@ -0,0 +1,75 @@
+import { Injectable } from '@angular/core';
+import { toDate } from 'date-fns';
+import { deepCopy } from '../../../../helpers/deep-copy';
+import { CHART_ANNOTATIONS_CONFIG } from './configs/annotations.config';
+import { CHART_INTERACTION_FUNCTIONS_EXTENSIONS } from './configs/interaction-functions-extensions.config';
+import { CHART_TYPES_CONFIG } from './configs/type.config';
+import * as i0 from "@angular/core";
+export class ChartConfigService {
+    getTypeConfig(chartType) {
+        /* Deep copy to avoid Chart object modifying parts of CHART_TYPES_CONFIG
+        as it copies by reference when initialized */
+        return deepCopy(CHART_TYPES_CONFIG[chartType]);
+    }
+    getAnnotationDefaults(type) {
+        return CHART_ANNOTATIONS_CONFIG[type];
+    }
+    /* Our types does not always map 1 to 1 to the same type
+    that the chart.js chart is actually configured with. Therefore this function
+    for looking up the ChartJSType of a type.  */
+    chartTypeToChartJSType(chartType) {
+        return CHART_TYPES_CONFIG[chartType]['type'];
+    }
+    applyInteractionFunctionsExtensions(options) {
+        const interactionFunctionsExtensions = CHART_INTERACTION_FUNCTIONS_EXTENSIONS;
+        Object.entries(interactionFunctionsExtensions).forEach(([key, _]) => {
+            const callback = options[key];
+            options[key] = (e, a, c) => {
+                interactionFunctionsExtensions[key](e, a, c, callback);
+            };
+        });
+        return options;
+    }
+    getStockChartOptions(dataLabelOptions, locale) {
+        return {
+            locale: locale,
+            plugins: {
+                tooltip: {
+                    callbacks: {
+                        title: (tooltipItems) => {
+                            const date = toDate(tooltipItems[0]?.raw?.x);
+                            if (date.valueOf()) {
+                                return date.toLocaleTimeString(locale, {
+                                    day: 'numeric',
+                                    month: 'short',
+                                    hour: '2-digit',
+                                    minute: '2-digit',
+                                });
+                            }
+                        },
+                        label: (context) => {
+                            // It's not possible to add spacing between color legend and text so we
+                            // prefix with a space.
+                            return ' ' + context.formattedValue + (dataLabelOptions.valueSuffix || '');
+                        },
+                    },
+                },
+            },
+            scales: {
+                y: {
+                    ticks: {
+                        callback: (value) => {
+                            return value + (dataLabelOptions.valueSuffix || '');
+                        },
+                    },
+                },
+            },
+        };
+    }
+}
+/** @nocollapse */ ChartConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.9", ngImport: i0, type: ChartConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ ChartConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.9", ngImport: i0, type: ChartConfigService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.9", ngImport: i0, type: ChartConfigService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/charts/shared/chart-config-service/configs/annotations.config.mjs

@@ -0,0 +1,32 @@
+import { ColorHelper } from '../../../../../helpers';
+const { getThemeColorHexString } = ColorHelper;
+/* The chart.js annotation does not allow for changing the
+defaults it comes with. In order to have sensible defaults
+this object is used instead and manually merged with the
+rest of the annotations object */
+const borderColor = getThemeColorHexString('semi-dark');
+const borderDash = [6, 3];
+const borderWidth = 1;
+export const CHART_ANNOTATIONS_CONFIG = {
+    line: {
+        borderDash,
+        borderWidth,
+        borderColor,
+    },
+    ellipse: {
+        borderDash,
+        borderWidth,
+        borderColor,
+        backgroundColor: 'transparent',
+    },
+    box: {
+        borderDash,
+        borderWidth,
+        borderColor,
+        backgroundColor: 'transparent',
+    },
+    point: {
+        backgroundColor: 'initial',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/charts/shared/chart-config-service/configs/global-defaults.config.mjs

@@ -0,0 +1,65 @@
+import { ColorHelper } from '../../../../../helpers';
+const { getThemeColorHexString } = ColorHelper;
+const hoverBackgroundColor = getThemeColorHexString('primary');
+const backgroundColor = getThemeColorHexString('secondary');
+function scriptedBackgroundColor(context) {
+    const dataset = context.dataset;
+    const highlightedElements = dataset?.kirbyOptions?.highlightedElements;
+    if (highlightedElements && highlightedElements.includes(context.dataIndex)) {
+        return hoverBackgroundColor;
+    }
+    else {
+        return backgroundColor;
+    }
+}
+// Only adds a hovercolor if an onClick handler is provided
+function scriptedHoverBackgroundColor(context) {
+    if (context.chart.options.onClick) {
+        return hoverBackgroundColor;
+    }
+}
+export const CHART_GLOBAL_DEFAULTS = {
+    maintainAspectRatio: false,
+    color: getThemeColorHexString('black'),
+    resizeDelay: 10,
+    elements: {
+        bar: {
+            backgroundColor: scriptedBackgroundColor,
+            hoverBackgroundColor: scriptedHoverBackgroundColor,
+        },
+        line: {
+            borderColor: scriptedBackgroundColor,
+            borderWidth: 2,
+            tension: 0.3,
+        },
+    },
+    scales: {
+        linear: {
+            display: false,
+            ticks: {
+                display: false,
+            },
+        },
+        category: {
+            display: true,
+            grid: {
+                display: false,
+            },
+        },
+    },
+    font: {
+        family: 'Roboto',
+    },
+    plugins: {
+        legend: {
+            display: false,
+        },
+        datalabels: {
+            display: false,
+        },
+        tooltip: {
+            enabled: false,
+        },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/charts/shared/chart-config-service/configs/interaction-functions-extensions.config.mjs

@@ -0,0 +1,13 @@
+/* Allows for adding functionality to interactions chart.js while
+preserving the interaction functionality the consumer of the component has
+passed by being provided as a callback. */
+export const CHART_INTERACTION_FUNCTIONS_EXTENSIONS = {
+    onHover: (_event, activeElements, _chart, callback) => {
+        if (_chart.options.onClick) {
+            _chart.canvas.style.cursor = activeElements[0] ? 'pointer' : 'default';
+        }
+        if (callback)
+            callback(_event, activeElements, _chart);
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJhY3Rpb24tZnVuY3Rpb25zLWV4dGVuc2lvbnMuY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9kZXNpZ25zeXN0ZW0vc3JjL2xpYi9jb21wb25lbnRzL2NoYXJ0cy9zaGFyZWQvY2hhcnQtY29uZmlnLXNlcnZpY2UvY29uZmlncy9pbnRlcmFjdGlvbi1mdW5jdGlvbnMtZXh0ZW5zaW9ucy5jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7OzBDQUUwQztBQUMxQyxNQUFNLENBQUMsTUFBTSxzQ0FBc0MsR0FBRztJQUNwRCxPQUFPLEVBQUUsQ0FDUCxNQUFrQixFQUNsQixjQUErQixFQUMvQixNQUFhLEVBQ2IsUUFBaUMsRUFDakMsRUFBRTtRQUNGLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUU7WUFDMUIsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsTUFBTSxHQUFHLGNBQWMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUM7U0FDeEU7UUFFRCxJQUFJLFFBQVE7WUFBRSxRQUFRLENBQUMsTUFBTSxFQUFFLGNBQWMsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUN6RCxDQUFDO0NBQ0YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFjdGl2ZUVsZW1lbnQsIENoYXJ0LCBDaGFydEV2ZW50LCBDaGFydE9wdGlvbnMgfSBmcm9tICdjaGFydC5qcyc7XG5cbi8qIEFsbG93cyBmb3IgYWRkaW5nIGZ1bmN0aW9uYWxpdHkgdG8gaW50ZXJhY3Rpb25zIGNoYXJ0LmpzIHdoaWxlIFxucHJlc2VydmluZyB0aGUgaW50ZXJhY3Rpb24gZnVuY3Rpb25hbGl0eSB0aGUgY29uc3VtZXIgb2YgdGhlIGNvbXBvbmVudCBoYXMgXG5wYXNzZWQgYnkgYmVpbmcgcHJvdmlkZWQgYXMgYSBjYWxsYmFjay4gKi9cbmV4cG9ydCBjb25zdCBDSEFSVF9JTlRFUkFDVElPTl9GVU5DVElPTlNfRVhURU5TSU9OUyA9IHtcbiAgb25Ib3ZlcjogKFxuICAgIF9ldmVudDogQ2hhcnRFdmVudCxcbiAgICBhY3RpdmVFbGVtZW50czogQWN0aXZlRWxlbWVudFtdLFxuICAgIF9jaGFydDogQ2hhcnQsXG4gICAgY2FsbGJhY2s6IENoYXJ0T3B0aW9uc1snb25Ib3ZlciddXG4gICkgPT4ge1xuICAgIGlmIChfY2hhcnQub3B0aW9ucy5vbkNsaWNrKSB7XG4gICAgICBfY2hhcnQuY2FudmFzLnN0eWxlLmN1cnNvciA9IGFjdGl2ZUVsZW1lbnRzWzBdID8gJ3BvaW50ZXInIDogJ2RlZmF1bHQnO1xuICAgIH1cblxuICAgIGlmIChjYWxsYmFjaykgY2FsbGJhY2soX2V2ZW50LCBhY3RpdmVFbGVtZW50cywgX2NoYXJ0KTtcbiAgfSxcbn07XG4iXX0=