@rfprodz/client-d3-charts 1.0.0

package/esm2020/lib/components/line-chart/line-chart.component.mjs

@@ -0,0 +1,91 @@
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ElementRef, Inject, Input, ViewChild, } from '@angular/core';
+import { D3_CHART_FACTORY } from '../../providers/d3-chart-factory.provider';
+import { defaultLineChartConfig } from '../../util';
+import * as i0 from "@angular/core";
+export class AppLineChartComponent {
+    constructor(doc, d3Factory) {
+        this.doc = doc;
+        this.d3Factory = d3Factory;
+        /**
+         * The chart id.
+         */
+        this.chartId = 'line-0';
+        /**
+         * The chart data.
+         */
+        this.data = [];
+        /**
+         * The chart options.
+         */
+        this.options = {};
+    }
+    /**
+     * The chart options constructor.
+     * @returns chart options
+     */
+    chartOptions() {
+        const bodyWidthAdjustment = 10;
+        const width = Math.min(this.options.width ?? defaultLineChartConfig.width, this.doc.body.clientWidth - defaultLineChartConfig.margin.left - defaultLineChartConfig.margin.right - bodyWidthAdjustment);
+        const xTicksScale = 50;
+        const ticks = {
+            x: width / xTicksScale,
+            y: Math.max(...this.data.map(item => item.value)),
+        };
+        const height = Math.min(this.options.height ?? width, this.doc.body.clientWidth - defaultLineChartConfig.margin.top - defaultLineChartConfig.margin.bottom - bodyWidthAdjustment);
+        const options = {
+            width,
+            height,
+            ticks,
+            ...this.options,
+        };
+        return options;
+    }
+    /**
+     * Draws the chart.
+     */
+    drawChart() {
+        if (typeof this.container !== 'undefined') {
+            const options = this.chartOptions();
+            this.d3Factory.drawLineChart(this.container, this.data, options);
+        }
+    }
+    /**
+     * Actually draws the chart after the component view is initialized.
+     */
+    ngAfterViewInit() {
+        this.drawChart();
+    }
+    /**
+     * Redraws the chart on changes.
+     */
+    ngOnChanges(changes) {
+        const data = changes.data?.currentValue;
+        const options = changes.options?.currentValue;
+        if ((typeof data !== 'undefined' && data !== null) || (typeof options !== 'undefined' && options !== null)) {
+            this.drawChart();
+        }
+    }
+}
+/** @nocollapse */ AppLineChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppLineChartComponent, deps: [{ token: DOCUMENT }, { token: D3_CHART_FACTORY }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ AppLineChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.6", type: AppLineChartComponent, selector: "app-line-chart", inputs: { chartId: "chartId", data: "data", options: "options" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"container\" id=\"{{ chartId }}\" #container></div>\n", styles: [":host{display:flex;flex-direction:row;flex-wrap:nowrap;justify-content:center}:host .container{flex:0 1 auto}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppLineChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-line-chart', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"container\" id=\"{{ chartId }}\" #container></div>\n", styles: [":host{display:flex;flex-direction:row;flex-wrap:nowrap;justify-content:center}:host .container{flex:0 1 auto}\n"] }]
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [D3_CHART_FACTORY]
+                }] }]; }, propDecorators: { chartId: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ['container']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/pie-chart/pie-chart.component.mjs

@@ -0,0 +1,90 @@
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ElementRef, Inject, Input, ViewChild, } from '@angular/core';
+import { D3_CHART_FACTORY } from '../../providers/d3-chart-factory.provider';
+import * as i0 from "@angular/core";
+export class AppPieChartComponent {
+    constructor(doc, d3Factory) {
+        this.doc = doc;
+        this.d3Factory = d3Factory;
+        /**
+         * The chart id.
+         */
+        this.chartId = 'pie-0';
+        /**
+         * The chart data.
+         */
+        this.data = [];
+        /**
+         * The chart options.
+         */
+        this.options = {};
+    }
+    /**
+     * The chart options constructor.
+     * @returns chart options
+     */
+    chartOptions() {
+        const margin = { top: 50, right: 50, bottom: 50, left: 50 };
+        const minWidth = 350;
+        const modifiers = {
+            width: 10,
+            height: 20,
+        };
+        const width = Math.min(minWidth, this.doc.body.clientWidth - modifiers.width) - margin.left - margin.right;
+        const height = Math.min(width, this.doc.body.clientHeight - margin.top - margin.bottom - modifiers.height);
+        const options = {
+            width,
+            height,
+            margin,
+            ...this.options,
+        };
+        return options;
+    }
+    /**
+     * Draws the chart.
+     */
+    drawChart() {
+        if (typeof this.container !== 'undefined') {
+            const options = this.chartOptions();
+            this.d3Factory.drawPieChart(this.container, this.data, options);
+        }
+    }
+    /**
+     * Actually draws the chart after the component view is initialized.
+     */
+    ngAfterViewInit() {
+        this.drawChart();
+    }
+    /**
+     * Redraws the chart on changes.
+     */
+    ngOnChanges(changes) {
+        const data = changes.data?.currentValue;
+        const options = changes.options?.currentValue;
+        if ((typeof data !== 'undefined' && data !== null) || (typeof options !== 'undefined' && options !== null)) {
+            this.drawChart();
+        }
+    }
+}
+/** @nocollapse */ AppPieChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppPieChartComponent, deps: [{ token: DOCUMENT }, { token: D3_CHART_FACTORY }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ AppPieChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.6", type: AppPieChartComponent, selector: "app-pie-chart", inputs: { chartId: "chartId", data: "data", options: "options" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"container\">\n  <div id=\"{{ chartId }}\" #container></div>\n\n  <small class=\"container--chart-title\">{{ options.chartTitle }}</small>\n</div>\n", styles: [":host{display:flex;flex-direction:row;flex-wrap:nowrap;justify-content:center}:host canvas{width:auto!important;height:150px}:host .container{flex:0 1 auto}:host .container--chart-title{display:block;text-align:center}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppPieChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-pie-chart', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"container\">\n  <div id=\"{{ chartId }}\" #container></div>\n\n  <small class=\"container--chart-title\">{{ options.chartTitle }}</small>\n</div>\n", styles: [":host{display:flex;flex-direction:row;flex-wrap:nowrap;justify-content:center}:host canvas{width:auto!important;height:150px}:host .container{flex:0 1 auto}:host .container--chart-title{display:block;text-align:center}\n"] }]
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [D3_CHART_FACTORY]
+                }] }]; }, propDecorators: { chartId: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ['container']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/radar-chart/radar-chart.component.mjs

@@ -0,0 +1,102 @@
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ElementRef, Inject, Input, ViewChild, } from '@angular/core';
+import { D3_CHART_FACTORY } from '../../providers/d3-chart-factory.provider';
+import { defaultRadarChartConfig } from '../../util';
+import * as i0 from "@angular/core";
+export class AppRadarChartComponent {
+    constructor(doc, d3Factory) {
+        this.doc = doc;
+        this.d3Factory = d3Factory;
+        /**
+         * The chart id.
+         */
+        this.chartId = 'radar-0';
+        /**
+         * The chart data.
+         */
+        this.data = [[]];
+        /**
+         * The chart options.
+         */
+        this.options = {};
+    }
+    /**
+     * The chart options constructor.
+     * @returns chart options
+     */
+    chartOptions() {
+        const xsOffset = 500;
+        const smOffset = 800;
+        const mdOffset = 1024;
+        const labelFactorDefault = 1.15;
+        const labelFactorMd = 1.15;
+        const labelFactorSm = 1.15;
+        const labelFactorXs = 1.4;
+        const wrapWidthDefault = 85;
+        const wrapWidthMd = 80;
+        const wrapWidthXs = 70;
+        const bodyWidthAdjustment = 10;
+        const width = Math.min(this.options.width ?? defaultRadarChartConfig.width, this.doc.body.clientWidth - defaultRadarChartConfig.margin.left - defaultRadarChartConfig.margin.right - bodyWidthAdjustment);
+        const height = Math.min(width, this.doc.body.clientHeight - defaultRadarChartConfig.margin.top - defaultRadarChartConfig.margin.bottom - bodyWidthAdjustment);
+        const labelFactor = width <= xsOffset ? labelFactorXs : width <= smOffset ? labelFactorSm : width <= mdOffset ? labelFactorMd : labelFactorDefault;
+        const labelTextWrapWidth = width <= xsOffset ? wrapWidthXs : width <= mdOffset ? wrapWidthMd : wrapWidthDefault;
+        const options = {
+            width,
+            height,
+            maxValue: this.data[0].reduce((accumulator, item) => (item.value > accumulator ? item.value : accumulator), 0) + 1,
+            levels: 5,
+            roundStrokes: true,
+            labelFactor,
+            labelTextWrapWidth,
+            ...this.options,
+        };
+        return options;
+    }
+    /**
+     * Draws the chart.
+     */
+    drawChart() {
+        if (typeof this.container !== 'undefined') {
+            const options = this.chartOptions();
+            this.d3Factory.drawRadarChart(this.container, this.data, options);
+        }
+    }
+    /**
+     * Actually draws the chart after the component view is initialized.
+     */
+    ngAfterViewInit() {
+        this.drawChart();
+    }
+    /**
+     * Redraws the chart on changes.
+     */
+    ngOnChanges(changes) {
+        const currentValue = changes.data?.currentValue;
+        const options = changes.options?.currentValue;
+        if ((typeof currentValue !== 'undefined' && currentValue !== null) || (typeof options !== 'undefined' && options !== null)) {
+            this.drawChart();
+        }
+    }
+}
+/** @nocollapse */ AppRadarChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppRadarChartComponent, deps: [{ token: DOCUMENT }, { token: D3_CHART_FACTORY }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ AppRadarChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.6", type: AppRadarChartComponent, selector: "app-radar-chart", inputs: { chartId: "chartId", data: "data", options: "options" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"container\" id=\"{{ chartId }}\" #container></div>\n", styles: [":host{display:flex;flex-direction:row;flex-wrap:nowrap;justify-content:center}:host .container{flex:0 1 auto}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppRadarChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-radar-chart', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"container\" id=\"{{ chartId }}\" #container></div>\n", styles: [":host{display:flex;flex-direction:row;flex-wrap:nowrap;justify-content:center}:host .container{flex:0 1 auto}\n"] }]
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [D3_CHART_FACTORY]
+                }] }]; }, propDecorators: { chartId: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ['container']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"radar-chart.component.js","sourceRoot":"","sources":["../../../../../../../libs/client-d3-charts/src/lib/components/radar-chart/radar-chart.component.ts","../../../../../../../libs/client-d3-charts/src/lib/components/radar-chart/radar-chart.component.html"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  Inject,\n  Input,\n  OnChanges,\n  SimpleChange,\n  ViewChild,\n} from '@angular/core';\n\nimport { IRadarChartDataNode, IRadarChartOptions } from '../../interfaces/radar-chart.interface';\nimport { D3_CHART_FACTORY, ID3ChartFactory } from '../../providers/d3-chart-factory.provider';\nimport { defaultRadarChartConfig } from '../../util';\n\ninterface IInputChanges {\n  data?: SimpleChange | null;\n  options?: SimpleChange | null;\n}\n\n@Component({\n  selector: 'app-radar-chart',\n  templateUrl: './radar-chart.component.html',\n  styleUrls: ['./radar-chart.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class AppRadarChartComponent implements AfterViewInit, OnChanges {\n  /**\n   * The chart id.\n   */\n  @Input() public chartId = 'radar-0';\n\n  /**\n   * The chart data.\n   */\n  @Input() public data: IRadarChartDataNode[][] = [[]];\n\n  /**\n   * The chart options.\n   */\n  @Input() public options: Partial<IRadarChartOptions> = {};\n\n  /**\n   * D3 chart view child reference.\n   */\n  @ViewChild('container') private readonly container?: ElementRef<HTMLDivElement>;\n\n  constructor(@Inject(DOCUMENT) private readonly doc: Document, @Inject(D3_CHART_FACTORY) private readonly d3Factory: ID3ChartFactory) {}\n\n  /**\n   * The chart options constructor.\n   * @returns chart options\n   */\n  private chartOptions() {\n    const xsOffset = 500;\n    const smOffset = 800;\n    const mdOffset = 1024;\n    const labelFactorDefault = 1.15;\n    const labelFactorMd = 1.15;\n    const labelFactorSm = 1.15;\n    const labelFactorXs = 1.4;\n    const wrapWidthDefault = 85;\n    const wrapWidthMd = 80;\n    const wrapWidthXs = 70;\n    const bodyWidthAdjustment = 10;\n    const width = Math.min(\n      this.options.width ?? defaultRadarChartConfig.width,\n      this.doc.body.clientWidth - defaultRadarChartConfig.margin.left - defaultRadarChartConfig.margin.right - bodyWidthAdjustment,\n    );\n    const height = Math.min(\n      width,\n      this.doc.body.clientHeight - defaultRadarChartConfig.margin.top - defaultRadarChartConfig.margin.bottom - bodyWidthAdjustment,\n    );\n    const labelFactor =\n      width <= xsOffset ? labelFactorXs : width <= smOffset ? labelFactorSm : width <= mdOffset ? labelFactorMd : labelFactorDefault;\n    const labelTextWrapWidth = width <= xsOffset ? wrapWidthXs : width <= mdOffset ? wrapWidthMd : wrapWidthDefault;\n    const options: Partial<IRadarChartOptions> = {\n      width,\n      height,\n      maxValue: this.data[0].reduce((accumulator, item) => (item.value > accumulator ? item.value : accumulator), 0) + 1,\n      levels: 5,\n      roundStrokes: true,\n      labelFactor,\n      labelTextWrapWidth,\n      ...this.options,\n    };\n    return options;\n  }\n\n  /**\n   * Draws the chart.\n   */\n  private drawChart() {\n    if (typeof this.container !== 'undefined') {\n      const options = this.chartOptions();\n      this.d3Factory.drawRadarChart(this.container, this.data, options);\n    }\n  }\n\n  /**\n   * Actually draws the chart after the component view is initialized.\n   */\n  public ngAfterViewInit(): void {\n    this.drawChart();\n  }\n\n  /**\n   * Redraws the chart on changes.\n   */\n  public ngOnChanges(changes: IInputChanges): void {\n    const currentValue: IRadarChartDataNode[][] = changes.data?.currentValue;\n    const options: Partial<IRadarChartOptions> = changes.options?.currentValue;\n    if ((typeof currentValue !== 'undefined' && currentValue !== null) || (typeof options !== 'undefined' && options !== null)) {\n      this.drawChart();\n    }\n  }\n}\n","<div class=\"container\" id=\"{{ chartId }}\" #container></div>\n"]}

package/esm2020/lib/interfaces/bar-chart.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFyLWNoYXJ0LmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2xpZW50LWQzLWNoYXJ0cy9zcmMvbGliL2ludGVyZmFjZXMvYmFyLWNoYXJ0LmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgZDMgZnJvbSAnZDMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIElCYXJDaGFydERhdGFOb2RlIHtcbiAgdGl0bGU6IHN0cmluZztcbiAgdmFsdWU6IG51bWJlcjtcbn1cblxuZXhwb3J0IHR5cGUgVEJhckNoYXJ0RGF0YSA9IElCYXJDaGFydERhdGFOb2RlW107XG5cbmV4cG9ydCBpbnRlcmZhY2UgSUJhckNoYXJ0T3B0aW9ucyB7XG4gIGNoYXJ0VGl0bGU6IHN0cmluZztcbiAgd2lkdGg6IG51bWJlcjtcbiAgaGVpZ2h0OiBudW1iZXI7XG4gIG1hcmdpbjoge1xuICAgIHRvcDogbnVtYmVyO1xuICAgIHJpZ2h0OiBudW1iZXI7XG4gICAgYm90dG9tOiBudW1iZXI7XG4gICAgbGVmdDogbnVtYmVyO1xuICB9O1xuICB0cmFuc2l0aW9uRHVyYXRpb246IG51bWJlcjtcbiAgeEF4aXNQYWRkaW5nOiBudW1iZXI7XG4gIHhBeGlzVGl0bGU6IHN0cmluZztcbiAgeUF4aXNUaXRsZTogc3RyaW5nO1xuICB5QXhpc1RpY2tzOiBudW1iZXI7XG4gIGRpc3BsYXlBeGlzTGFiZWxzOiBib29sZWFuO1xuICBsYWJlbFRleHRXcmFwV2lkdGg6IG51bWJlcjtcbiAgY29sb3I6IGQzLlNjYWxlT3JkaW5hbDxzdHJpbmcsIHN0cmluZz47XG59XG4iXX0=

package/esm2020/lib/interfaces/force-directed-chart.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9yY2UtZGlyZWN0ZWQtY2hhcnQuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jbGllbnQtZDMtY2hhcnRzL3NyYy9saWIvaW50ZXJmYWNlcy9mb3JjZS1kaXJlY3RlZC1jaGFydC5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGQzIGZyb20gJ2QzJztcblxuZXhwb3J0IGludGVyZmFjZSBJRm9yY2VEaXJlY3RlZEdyYXBoRG9tYWluIHtcbiAgaW5kZXg6IG51bWJlcjtcbiAgbmFtZTogc3RyaW5nO1xuICB2YWx1ZTogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIElGb3JjZURpcmVjdGVkR3JhcGhFbnRpdHkge1xuICBpbmRleDogbnVtYmVyO1xuICBuYW1lOiBzdHJpbmc7XG4gIGRvbWFpbnM6IHN0cmluZ1tdO1xuICBpbWc6IHN0cmluZztcbiAgbGlua3NDb3VudDogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIElGb3JjZURpcmVjdGVkQ2hhcnREYXRhTm9kZSBleHRlbmRzIGQzLlNpbXVsYXRpb25Ob2RlRGF0dW0ge1xuICBpbmRleDogbnVtYmVyO1xuICBkb21haW5zPzogc3RyaW5nW107XG4gIHZhbHVlPzogbnVtYmVyO1xuICBuYW1lPzogc3RyaW5nO1xuICBpbWc/OiBzdHJpbmc7XG4gIGxpbmtzQ291bnQ/OiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSUZvcmNlRGlyZWN0ZWRDaGFydERhdGEge1xuICBkb21haW5zOiBJRm9yY2VEaXJlY3RlZEdyYXBoRG9tYWluW107XG4gIGVudGl0aWVzOiBJRm9yY2VEaXJlY3RlZEdyYXBoRW50aXR5W107XG4gIGxpbmtzOiBkMy5TaW11bGF0aW9uTGlua0RhdHVtPElGb3JjZURpcmVjdGVkQ2hhcnREYXRhTm9kZT5bXTtcbiAgbm9kZXM6IElGb3JjZURpcmVjdGVkQ2hhcnREYXRhTm9kZVtdO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIElGb3JjZURpcmVjdGVkQ2hhcnRPcHRpb25zIHtcbiAgY2hhcnRUaXRsZTogc3RyaW5nO1xuICB3aWR0aDogbnVtYmVyO1xuICBoZWlnaHQ6IG51bWJlcjtcbiAgY2VudGVyQ2FsY01vZDogbnVtYmVyO1xuICBjaGFyZ2U6IHtcbiAgICBzdHJlbmd0aDogbnVtYmVyO1xuICAgIHRoZXRhOiBudW1iZXI7XG4gICAgZGlzdGFuY2VNYXg6IG51bWJlcjtcbiAgfTtcbiAgZGlzdGFuY2U6IG51bWJlcjtcbiAgZm9udFNpemU6IG51bWJlcjtcbiAgY29sbGlzaW9uUmFkaXVzOiBudW1iZXI7XG4gIG1hcmdpbjoge1xuICAgIHRvcDogbnVtYmVyO1xuICAgIHJpZ2h0OiBudW1iZXI7XG4gICAgYm90dG9tOiBudW1iZXI7XG4gICAgbGVmdDogbnVtYmVyO1xuICB9O1xuICBzdHJva2VXaWR0aDogbnVtYmVyO1xuICBsYWJlbFRleHRXcmFwV2lkdGg6IG51bWJlcjtcbiAgY29sb3I6IGQzLlNjYWxlT3JkaW5hbDxzdHJpbmcsIHN0cmluZz47XG59XG4iXX0=

package/esm2020/lib/interfaces/index.mjs

@@ -0,0 +1,6 @@
+export * from './bar-chart.interface';
+export * from './force-directed-chart.interface';
+export * from './line-chart.interface';
+export * from './pie-chart.interface';
+export * from './radar-chart.interface';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NsaWVudC1kMy1jaGFydHMvc3JjL2xpYi9pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmFyLWNoYXJ0LmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2ZvcmNlLWRpcmVjdGVkLWNoYXJ0LmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpbmUtY2hhcnQuaW50ZXJmYWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcGllLWNoYXJ0LmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL3JhZGFyLWNoYXJ0LmludGVyZmFjZSc7XG4iXX0=

package/esm2020/lib/interfaces/line-chart.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGluZS1jaGFydC5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NsaWVudC1kMy1jaGFydHMvc3JjL2xpYi9pbnRlcmZhY2VzL2xpbmUtY2hhcnQuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBkMyBmcm9tICdkMyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgSUxpbmVDaGFydERhdGFOb2RlIHtcbiAgdGltZXN0YW1wOiBudW1iZXI7XG4gIHZhbHVlOiBudW1iZXI7XG59XG5cbmV4cG9ydCB0eXBlIFRMaW5lQ2hhcnREYXRhID0gSUxpbmVDaGFydERhdGFOb2RlW107XG5cbmV4cG9ydCBpbnRlcmZhY2UgSUxpbmVDaGFydE9wdGlvbnMge1xuICBjaGFydFRpdGxlOiBzdHJpbmc7XG4gIHdpZHRoOiBudW1iZXI7XG4gIGhlaWdodDogbnVtYmVyO1xuICBtYXJnaW46IHtcbiAgICB0b3A6IG51bWJlcjtcbiAgICByaWdodDogbnVtYmVyO1xuICAgIGJvdHRvbTogbnVtYmVyO1xuICAgIGxlZnQ6IG51bWJlcjtcbiAgfTtcbiAgdHJhbnNpdGlvbkR1cmF0aW9uOiBudW1iZXI7XG4gIGRvdFJhZGl1czogbnVtYmVyO1xuICB4QXhpc1RpdGxlOiBzdHJpbmc7XG4gIHlBeGlzVGl0bGU6IHN0cmluZztcbiAgdGlja3M6IHtcbiAgICB4OiBudW1iZXI7XG4gICAgeTogbnVtYmVyO1xuICB9O1xuICBkaXNwbGF5QXhpc0xhYmVsczogYm9vbGVhbjtcbiAgbGFiZWxUZXh0V3JhcFdpZHRoOiBudW1iZXI7XG4gIGNvbG9yOiBkMy5TY2FsZU9yZGluYWw8c3RyaW5nLCBzdHJpbmc+O1xufVxuIl19

package/esm2020/lib/interfaces/pie-chart.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGllLWNoYXJ0LmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2xpZW50LWQzLWNoYXJ0cy9zcmMvbGliL2ludGVyZmFjZXMvcGllLWNoYXJ0LmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBJUGllQ2hhcnREYXRhTm9kZSB7XG4gIGtleTogc3RyaW5nO1xuICB5OiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSVBpZUNoYXJ0T3B0aW9ucyB7XG4gIGNoYXJ0VGl0bGU6IHN0cmluZztcbiAgd2lkdGg6IG51bWJlcjtcbiAgaGVpZ2h0OiBudW1iZXI7XG4gIG1hcmdpbjoge1xuICAgIHRvcDogbnVtYmVyO1xuICAgIHJpZ2h0OiBudW1iZXI7XG4gICAgYm90dG9tOiBudW1iZXI7XG4gICAgbGVmdDogbnVtYmVyO1xuICB9O1xuICBpbm5lclJhZGl1czogbnVtYmVyO1xuICBsYWJlbFJhZGl1c01vZGlmaWVyOiBudW1iZXI7XG4gIGxhYmVsVGV4dFdyYXBXaWR0aDogbnVtYmVyO1xuICBjb2xvcjogZDMuU2NhbGVPcmRpbmFsPHN0cmluZywgc3RyaW5nPjtcbn1cbiJdfQ==

package/esm2020/lib/interfaces/radar-chart.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFkYXItY2hhcnQuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jbGllbnQtZDMtY2hhcnRzL3NyYy9saWIvaW50ZXJmYWNlcy9yYWRhci1jaGFydC5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGQzIGZyb20gJ2QzJztcblxuZXhwb3J0IGludGVyZmFjZSBJUmFkYXJDaGFydERhdGFOb2RlIHtcbiAgYXhpczogc3RyaW5nO1xuICB2YWx1ZTogbnVtYmVyO1xuICB1bml0OiBzdHJpbmc7XG59XG5cbmV4cG9ydCB0eXBlIFRSYWRhckNoYXJ0RGF0YSA9IElSYWRhckNoYXJ0RGF0YU5vZGVbXVtdO1xuXG5leHBvcnQgaW50ZXJmYWNlIElSYWRhckNoYXJ0T3B0aW9ucyB7XG4gIGNoYXJ0VGl0bGU6IHN0cmluZztcbiAgd2lkdGg6IG51bWJlcjtcbiAgaGVpZ2h0OiBudW1iZXI7XG4gIG1hcmdpbjoge1xuICAgIHRvcDogbnVtYmVyO1xuICAgIHJpZ2h0OiBudW1iZXI7XG4gICAgYm90dG9tOiBudW1iZXI7XG4gICAgbGVmdDogbnVtYmVyO1xuICB9O1xuICBtYXhWYWx1ZTogbnVtYmVyO1xuICBsZXZlbHM6IG51bWJlcjtcbiAgbGluZUZhY3RvcjogbnVtYmVyO1xuICBsYWJlbEZhY3RvcjogbnVtYmVyO1xuICBsYWJlbFRleHRXcmFwV2lkdGg6IG51bWJlcjtcbiAgb3BhY2l0eUFyZWE6IG51bWJlcjtcbiAgZG90UmFkaXVzOiBudW1iZXI7XG4gIG9wYWNpdHlDaXJjbGVzOiBudW1iZXI7XG4gIHN0cm9rZVdpZHRoOiBudW1iZXI7XG4gIHJvdW5kU3Ryb2tlczogYm9vbGVhbjtcbiAgdHJhbnNpdGlvbkR1cmF0aW9uOiBudW1iZXI7XG4gIGNvbG9yOiBkMy5TY2FsZU9yZGluYWw8c3RyaW5nLCBzdHJpbmc+O1xufVxuIl19

package/esm2020/lib/providers/d3-chart-factory.provider.mjs

@@ -0,0 +1,18 @@
+import { InjectionToken } from '@angular/core';
+import { drawBarChart } from '../util/bar-chart.util';
+import { drawForceDirectedChart } from '../util/force-directed-chart.util';
+import { drawLineChart } from '../util/line-chart.util';
+import { drawPieChart } from '../util/pie-chart.util';
+import { drawRadarChart } from '../util/radar-chart.util';
+export const d3ChartFactory = () => ({
+    drawPieChart,
+    drawRadarChart,
+    drawBarChart,
+    drawLineChart,
+    drawForceDirectedChart,
+});
+export const D3_CHART_FACTORY = new InjectionToken('D3_CHART_FACTORY', {
+    providedIn: 'root',
+    factory: d3ChartFactory,
+});
+//# sourceMappingURL=data:application/json;base64,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