@rfprodz/client-d3-charts 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 rfprod.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,88 @@
+# Angular D3 Chart Components Module
+
+This library was generated with [Nx](https://nx.dev).
+
+## Description
+
+The Angular chart components based on the [D3.js](https://d3js.org/) library.
+
+Supported chart types:
+
+- bar chart;
+- line chart;
+- pie chart;
+- radar chart;
+- force-directed chart;
+
+The library contains Angular components as well as basic utility functions that can be used to implement the chart types mentioned above in TypeScript.
+
+## Development commands reference
+
+Run `nx test client-d3-charts` to execute the unit tests.
+
+Run `nx lint client-d3-charts` to lint the library.
+
+Run `nx build client-d3-charts` to build the library.
+
+## Usage
+
+### Within the development workspace
+
+Import the charts module
+
+```typescript
+import { AppClientD3ChartsModule } from '@app/client-d3-charts';
+```
+
+### As an external package
+
+Install the package
+
+```bash
+yarn add @rfprodz/client-d3-charts d3 @types/d3
+```
+
+Import the charts module
+
+```typescript
+import { AppClientD3ChartsModule } from '@rfprodz/client-d3-charts';
+```
+
+### Use the chart components
+
+#### in templates
+
+```html
+<!-- bar chart -->
+<app-bar-chart></app-bar-chart>
+<!-- line chart -->
+<app-line-chart></app-line-chart>
+<!-- pie chart -->
+<app-pie-chart></app-pie-chart>
+<!-- radar chart -->
+<app-radar-chart></app-radar-chart>
+<!-- force-directed chart -->
+<app-force-directed-chart></app-force-directed-chart>
+```
+
+#### in classes
+
+```typescript
+import {
+  AppPieChartComponent,
+  AppRadarChartComponent,
+  AppForceDirectedChartComponent,
+  AppBarChartComponent,
+  AppLineChartComponent,
+} from '@rfprodz/client-d3-charts';
+```
+
+### Chart examples
+
+See the chart eamples components
+
+```typescript
+import { AppChartExamplesComponent } from '@rfprodz/client-d3-charts';
+```
+
+or the [source code](https://github.com/rfprod/nx-ng-starter/blob/main/libs/client-d3-charts/src/lib/components/chart-examples/chart-examples.component.ts) of the chart examples component

package/esm2020/index.mjs

@@ -0,0 +1,5 @@
+export * from './lib/client-d3-charts.module';
+export * from './lib/components';
+export * from './lib/interfaces';
+export * from './lib/util';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL2NsaWVudC1kMy1jaGFydHMvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvY2xpZW50LWQzLWNoYXJ0cy5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9pbnRlcmZhY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3V0aWwnO1xuIl19

package/esm2020/lib/client-d3-charts.module.mjs

@@ -0,0 +1,47 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { AppBarChartComponent } from './components/bar-chart/bar-chart.component';
+import { AppChartExamplesComponent } from './components/chart-examples/chart-examples.component';
+import { AppForceDirectedChartComponent } from './components/force-directed-chart/force-directed-chart.component';
+import { AppLineChartComponent } from './components/line-chart/line-chart.component';
+import { AppPieChartComponent } from './components/pie-chart/pie-chart.component';
+import { AppRadarChartComponent } from './components/radar-chart/radar-chart.component';
+import * as i0 from "@angular/core";
+export class AppClientD3ChartsModule {
+}
+/** @nocollapse */ AppClientD3ChartsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppClientD3ChartsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ AppClientD3ChartsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.0.6", ngImport: i0, type: AppClientD3ChartsModule, declarations: [AppPieChartComponent,
+        AppRadarChartComponent,
+        AppForceDirectedChartComponent,
+        AppBarChartComponent,
+        AppLineChartComponent,
+        AppChartExamplesComponent], imports: [CommonModule], exports: [AppPieChartComponent,
+        AppRadarChartComponent,
+        AppForceDirectedChartComponent,
+        AppBarChartComponent,
+        AppLineChartComponent,
+        AppChartExamplesComponent] });
+/** @nocollapse */ AppClientD3ChartsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppClientD3ChartsModule, imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppClientD3ChartsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [
+                        AppPieChartComponent,
+                        AppRadarChartComponent,
+                        AppForceDirectedChartComponent,
+                        AppBarChartComponent,
+                        AppLineChartComponent,
+                        AppChartExamplesComponent,
+                    ],
+                    exports: [
+                        AppPieChartComponent,
+                        AppRadarChartComponent,
+                        AppForceDirectedChartComponent,
+                        AppBarChartComponent,
+                        AppLineChartComponent,
+                        AppChartExamplesComponent,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,87 @@
+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 { defaultBarChartConfig } from '../../util';
+import * as i0 from "@angular/core";
+export class AppBarChartComponent {
+    constructor(doc, d3Factory) {
+        this.doc = doc;
+        this.d3Factory = d3Factory;
+        /**
+         * The chart id.
+         */
+        this.chartId = 'bar-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 ?? defaultBarChartConfig.width, this.doc.body.clientWidth - defaultBarChartConfig.margin.left - defaultBarChartConfig.margin.right - bodyWidthAdjustment);
+        const height = Math.min(this.options.height ?? width, this.doc.body.clientWidth - defaultBarChartConfig.margin.top - defaultBarChartConfig.margin.bottom - bodyWidthAdjustment);
+        const yAxisTicks = Math.max(...this.data.map(item => item.value));
+        const options = {
+            width,
+            height,
+            yAxisTicks,
+            ...this.options,
+        };
+        return options;
+    }
+    /**
+     * Draws the chart.
+     */
+    drawChart() {
+        if (typeof this.container !== 'undefined') {
+            const options = this.chartOptions();
+            this.d3Factory.drawBarChart(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 */ AppBarChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppBarChartComponent, deps: [{ token: DOCUMENT }, { token: D3_CHART_FACTORY }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ AppBarChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.6", type: AppBarChartComponent, selector: "app-bar-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: AppBarChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-bar-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/chart-examples/chart-examples.component.mjs

@@ -0,0 +1,181 @@
+import { BreakpointObserver, Breakpoints } from '@angular/cdk/layout';
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { first, map, switchMap, timer } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/layout";
+import * as i2 from "@angular/common";
+import * as i3 from "../pie-chart/pie-chart.component";
+import * as i4 from "../radar-chart/radar-chart.component";
+import * as i5 from "../force-directed-chart/force-directed-chart.component";
+import * as i6 from "../bar-chart/bar-chart.component";
+import * as i7 from "../line-chart/line-chart.component";
+export class AppChartExamplesComponent {
+    constructor(breakpointObserver) {
+        this.breakpointObserver = breakpointObserver;
+        this.breakpoint$ = this.breakpointObserver
+            .observe([Breakpoints.XSmall, Breakpoints.Small, Breakpoints.Medium, Breakpoints.Large, Breakpoints.XLarge])
+            .pipe(map(result => Object.keys(result.breakpoints).find(item => result.breakpoints[item]) ?? 'unknown'));
+        this.barChartConfig$ = this.breakpoint$.pipe(switchMap(() => timer(this.timeout).pipe(first(), map(() => ({ data: this.barChartData, options: this.barChartOptions() })))));
+        this.lineChartConfig$ = this.breakpoint$.pipe(switchMap(() => timer(this.timeout).pipe(first(), map(() => ({ data: this.lineChartData, options: this.lineChartOptions() })))));
+        this.radarChartConfig$ = this.breakpoint$.pipe(switchMap(() => timer(this.timeout).pipe(first(), map(() => ({ data: this.radarChartData, options: this.radarChartOptions() })))));
+        this.pieChartConfig$ = this.breakpoint$.pipe(switchMap(() => timer(this.timeout).pipe(first(), map(() => ({ data: this.pieChartData, options: this.pieChartOptions() })))));
+        this.forceDirectedChartConfig$ = this.breakpoint$.pipe(switchMap(() => timer(this.timeout).pipe(first(), map(() => ({ data: this.forceDirectedChartData, options: this.forceDirectedChartOptions() })))));
+        this.timeout = 100;
+    }
+    /**
+     * Sample bar chart data.
+     */
+    get barChartData() {
+        return [
+            { title: 'one', value: 1 },
+            { title: 'two', value: 2 },
+            { title: 'three', value: 3 },
+            { title: 'four', value: 4 },
+            { title: 'five', value: 5 },
+        ];
+    }
+    /**
+     * Sample line chart data.
+     */
+    get lineChartData() {
+        const increment = 10000;
+        const multiplier = 2;
+        return [
+            { timestamp: new Date().getTime(), value: 1 },
+            { timestamp: new Date().getTime() + increment, value: 10 },
+            { timestamp: new Date().getTime() + increment * multiplier, value: 3 },
+            { timestamp: new Date().getTime() + increment * Math.pow(multiplier, multiplier), value: 5 },
+            { timestamp: new Date().getTime() + increment * Math.pow(multiplier, multiplier) * multiplier, value: 4 },
+            { timestamp: new Date().getTime() + increment * Math.pow(multiplier, multiplier) * Math.pow(multiplier, multiplier), value: 7 },
+            {
+                timestamp: new Date().getTime() + increment * Math.pow(multiplier, multiplier) * Math.pow(multiplier, multiplier) * multiplier,
+                value: 8,
+            },
+        ];
+    }
+    /**
+     * Sample radar chart data.
+     */
+    get radarChartData() {
+        return [
+            [
+                { axis: 'one', value: 1, unit: 'x' },
+                { axis: 'two', value: 2, unit: 'x' },
+                { axis: 'three', value: 3, unit: 'x' },
+                { axis: 'four', value: 4, unit: 'x' },
+                { axis: 'five', value: 5, unit: 'x' },
+                { axis: 'six', value: 6, unit: 'x' },
+                { axis: 'seven', value: 7, unit: 'x' },
+                { axis: 'eight', value: 8, unit: 'x' },
+                { axis: 'nine (long labels are wrapped)', value: 9, unit: 'x' },
+            ],
+            [
+                { axis: 'one', value: 9, unit: 'y' },
+                { axis: 'two', value: 8, unit: 'y' },
+                { axis: 'three', value: 7, unit: 'y' },
+                { axis: 'four', value: 6, unit: 'y' },
+                { axis: 'five', value: 5, unit: 'y' },
+                { axis: 'six', value: 4, unit: 'y' },
+                { axis: 'seven', value: 3, unit: 'y' },
+                { axis: 'eight', value: 2, unit: 'y' },
+                { axis: 'nine (long labels are wrapped)', value: 1, unit: 'y' },
+            ],
+        ];
+    }
+    /**
+     * Sample pie chart data.
+     */
+    get pieChartData() {
+        return [
+            { key: 'one', y: 1 },
+            { key: 'two', y: 2 },
+            { key: 'three', y: 3 },
+            { key: 'four', y: 4 },
+            { key: 'five', y: 5 },
+            { key: 'six', y: 6 },
+        ];
+    }
+    /**
+     * Sample force directed chart data.
+     */
+    get forceDirectedChartData() {
+        const input = {
+            domains: ['first', 'second', 'third'],
+            entities: [
+                { name: 'one', domains: ['first'], img: '' },
+                { name: 'two', domains: ['second'], img: '' },
+                { name: 'three', domains: ['third'], img: '' },
+                { name: 'four', domains: ['first', 'second'], img: '' },
+                { name: 'five', domains: ['second'], img: '' },
+                { name: 'six', domains: ['third', 'second'], img: '' },
+                { name: 'seven', domains: ['second'], img: '' },
+                { name: 'eight', domains: ['third'], img: '' },
+            ],
+        };
+        const domains = input.domains.map((name, index) => ({ index, name, value: 1 }));
+        const entities = input.entities.map((app, index) => ({
+            index: index,
+            name: app.name,
+            domains: [...app.domains],
+            img: app.img,
+            linksCount: 0,
+        }));
+        const nodes = [...entities];
+        const links = entities
+            .map(entity => {
+            return entity.domains.map(domain => {
+                const source = domains.find(value => domain === value.name)?.index ?? -1;
+                const target = entity.index;
+                return { source, target };
+            });
+        })
+            .reduce((accumulator, item) => (Array.isArray(item) ? [...accumulator, ...item] : [...accumulator, item]), [])
+            .filter(link => link.source !== -1 && link.target !== -1 && typeof link.target !== 'undefined');
+        const chartData = {
+            domains,
+            entities: entities.map(item => ({
+                ...item,
+                linksCount: links.reduce((acc, link) => (link.target === item.index ? acc + 1 : acc), 0),
+            })),
+            links,
+            nodes,
+        };
+        return chartData;
+    }
+    barChartOptions() {
+        return {
+            chartTitle: 'Example bar chart',
+            xAxisTitle: 'long x axis title',
+            yAxisTitle: 'long y axis title',
+        };
+    }
+    lineChartOptions() {
+        return {
+            chartTitle: 'Example line chart',
+            xAxisTitle: 'Date range',
+            yAxisTitle: 'Value range',
+        };
+    }
+    radarChartOptions() {
+        return {
+            chartTitle: 'Example radar chart',
+        };
+    }
+    pieChartOptions() {
+        return {
+            chartTitle: 'Example pie chart',
+        };
+    }
+    forceDirectedChartOptions() {
+        return {
+            chartTitle: 'Example force directed chart',
+        };
+    }
+}
+/** @nocollapse */ AppChartExamplesComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppChartExamplesComponent, deps: [{ token: i1.BreakpointObserver }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ AppChartExamplesComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.6", type: AppChartExamplesComponent, selector: "app-chart-examples", ngImport: i0, template: "<div class=\"container\" *ngIf=\"barChartConfig$ | async as config\">\n  <app-bar-chart [chartId]=\"'bar-example-1'\" [data]=\"config.data\" [options]=\"config.options\"></app-bar-chart>\n</div>\n\n<hr [ngStyle]=\"{ width: '100%' }\" />\n\n<div class=\"container\" *ngIf=\"lineChartConfig$ | async as config\">\n  <app-line-chart [chartId]=\"'line-example-1'\" [data]=\"config.data\" [options]=\"config.options\"></app-line-chart>\n</div>\n\n<hr [ngStyle]=\"{ width: '100%' }\" />\n\n<div class=\"container\" *ngIf=\"radarChartConfig$ | async as config\">\n  <app-radar-chart [chartId]=\"'radar-example-1'\" [data]=\"config.data\" [options]=\"config.options\"></app-radar-chart>\n</div>\n\n<hr [ngStyle]=\"{ width: '100%' }\" />\n\n<div class=\"container\" *ngIf=\"pieChartConfig$ | async as config\">\n  <app-pie-chart [chartId]=\"'pie-example-1'\" [data]=\"config.data\" [options]=\"config.options\"></app-pie-chart>\n</div>\n\n<hr [ngStyle]=\"{ width: '100%' }\" />\n\n<div class=\"container\" *ngIf=\"forceDirectedChartConfig$ | async as config\">\n  <app-force-directed-chart\n    [chartId]=\"'force-directed-example-1'\"\n    [data]=\"config.data\"\n    [options]=\"config.options\"\n  ></app-force-directed-chart>\n</div>\n", styles: [":host{display:flex;flex-direction:row;flex-wrap:wrap;justify-content:center}:host .container{flex:1 1 auto;width:100%}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: i3.AppPieChartComponent, selector: "app-pie-chart", inputs: ["chartId", "data", "options"] }, { kind: "component", type: i4.AppRadarChartComponent, selector: "app-radar-chart", inputs: ["chartId", "data", "options"] }, { kind: "component", type: i5.AppForceDirectedChartComponent, selector: "app-force-directed-chart", inputs: ["chartId", "data", "options"] }, { kind: "component", type: i6.AppBarChartComponent, selector: "app-bar-chart", inputs: ["chartId", "data", "options"] }, { kind: "component", type: i7.AppLineChartComponent, selector: "app-line-chart", inputs: ["chartId", "data", "options"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppChartExamplesComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-chart-examples', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"container\" *ngIf=\"barChartConfig$ | async as config\">\n  <app-bar-chart [chartId]=\"'bar-example-1'\" [data]=\"config.data\" [options]=\"config.options\"></app-bar-chart>\n</div>\n\n<hr [ngStyle]=\"{ width: '100%' }\" />\n\n<div class=\"container\" *ngIf=\"lineChartConfig$ | async as config\">\n  <app-line-chart [chartId]=\"'line-example-1'\" [data]=\"config.data\" [options]=\"config.options\"></app-line-chart>\n</div>\n\n<hr [ngStyle]=\"{ width: '100%' }\" />\n\n<div class=\"container\" *ngIf=\"radarChartConfig$ | async as config\">\n  <app-radar-chart [chartId]=\"'radar-example-1'\" [data]=\"config.data\" [options]=\"config.options\"></app-radar-chart>\n</div>\n\n<hr [ngStyle]=\"{ width: '100%' }\" />\n\n<div class=\"container\" *ngIf=\"pieChartConfig$ | async as config\">\n  <app-pie-chart [chartId]=\"'pie-example-1'\" [data]=\"config.data\" [options]=\"config.options\"></app-pie-chart>\n</div>\n\n<hr [ngStyle]=\"{ width: '100%' }\" />\n\n<div class=\"container\" *ngIf=\"forceDirectedChartConfig$ | async as config\">\n  <app-force-directed-chart\n    [chartId]=\"'force-directed-example-1'\"\n    [data]=\"config.data\"\n    [options]=\"config.options\"\n  ></app-force-directed-chart>\n</div>\n", styles: [":host{display:flex;flex-direction:row;flex-wrap:wrap;justify-content:center}:host .container{flex:1 1 auto;width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.BreakpointObserver }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-examples.component.js","sourceRoot":"","sources":["../../../../../../../libs/client-d3-charts/src/lib/components/chart-examples/chart-examples.component.ts","../../../../../../../libs/client-d3-charts/src/lib/components/chart-examples/chart-examples.component.html"],"names":[],"mappings":"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","sourcesContent":["import { BreakpointObserver, Breakpoints } from '@angular/cdk/layout';\nimport { ChangeDetectionStrategy, Component } from '@angular/core';\nimport { first, map, switchMap, timer } from 'rxjs';\n\nimport { IBarChartOptions, TBarChartData } from '../../interfaces/bar-chart.interface';\nimport {\n  IForceDirectedChartData,\n  IForceDirectedChartOptions,\n  IForceDirectedGraphEntity,\n} from '../../interfaces/force-directed-chart.interface';\nimport { ILineChartOptions, TLineChartData } from '../../interfaces/line-chart.interface';\nimport { IPieChartDataNode, IPieChartOptions } from '../../interfaces/pie-chart.interface';\nimport { IRadarChartDataNode, IRadarChartOptions } from '../../interfaces/radar-chart.interface';\n\n@Component({\n  selector: 'app-chart-examples',\n  templateUrl: './chart-examples.component.html',\n  styleUrls: ['./chart-examples.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class AppChartExamplesComponent {\n  /**\n   * Sample bar chart data.\n   */\n  public get barChartData() {\n    return <TBarChartData>[\n      { title: 'one', value: 1 },\n      { title: 'two', value: 2 },\n      { title: 'three', value: 3 },\n      { title: 'four', value: 4 },\n      { title: 'five', value: 5 },\n    ];\n  }\n\n  /**\n   * Sample line chart data.\n   */\n  public get lineChartData() {\n    const increment = 10000;\n    const multiplier = 2;\n    return <TLineChartData>[\n      { timestamp: new Date().getTime(), value: 1 },\n      { timestamp: new Date().getTime() + increment, value: 10 },\n      { timestamp: new Date().getTime() + increment * multiplier, value: 3 },\n      { timestamp: new Date().getTime() + increment * Math.pow(multiplier, multiplier), value: 5 },\n      { timestamp: new Date().getTime() + increment * Math.pow(multiplier, multiplier) * multiplier, value: 4 },\n      { timestamp: new Date().getTime() + increment * Math.pow(multiplier, multiplier) * Math.pow(multiplier, multiplier), value: 7 },\n      {\n        timestamp: new Date().getTime() + increment * Math.pow(multiplier, multiplier) * Math.pow(multiplier, multiplier) * multiplier,\n        value: 8,\n      },\n    ];\n  }\n\n  /**\n   * Sample radar chart data.\n   */\n  public get radarChartData() {\n    return <IRadarChartDataNode[][]>[\n      [\n        { axis: 'one', value: 1, unit: 'x' },\n        { axis: 'two', value: 2, unit: 'x' },\n        { axis: 'three', value: 3, unit: 'x' },\n        { axis: 'four', value: 4, unit: 'x' },\n        { axis: 'five', value: 5, unit: 'x' },\n        { axis: 'six', value: 6, unit: 'x' },\n        { axis: 'seven', value: 7, unit: 'x' },\n        { axis: 'eight', value: 8, unit: 'x' },\n        { axis: 'nine (long labels are wrapped)', value: 9, unit: 'x' },\n      ],\n      [\n        { axis: 'one', value: 9, unit: 'y' },\n        { axis: 'two', value: 8, unit: 'y' },\n        { axis: 'three', value: 7, unit: 'y' },\n        { axis: 'four', value: 6, unit: 'y' },\n        { axis: 'five', value: 5, unit: 'y' },\n        { axis: 'six', value: 4, unit: 'y' },\n        { axis: 'seven', value: 3, unit: 'y' },\n        { axis: 'eight', value: 2, unit: 'y' },\n        { axis: 'nine (long labels are wrapped)', value: 1, unit: 'y' },\n      ],\n    ];\n  }\n\n  /**\n   * Sample pie chart data.\n   */\n  public get pieChartData() {\n    return <IPieChartDataNode[]>[\n      { key: 'one', y: 1 },\n      { key: 'two', y: 2 },\n      { key: 'three', y: 3 },\n      { key: 'four', y: 4 },\n      { key: 'five', y: 5 },\n      { key: 'six', y: 6 },\n    ];\n  }\n\n  /**\n   * Sample force directed chart data.\n   */\n  public get forceDirectedChartData() {\n    const input = {\n      domains: ['first', 'second', 'third'],\n      entities: [\n        { name: 'one', domains: ['first'], img: '' },\n        { name: 'two', domains: ['second'], img: '' },\n        { name: 'three', domains: ['third'], img: '' },\n        { name: 'four', domains: ['first', 'second'], img: '' },\n        { name: 'five', domains: ['second'], img: '' },\n        { name: 'six', domains: ['third', 'second'], img: '' },\n        { name: 'seven', domains: ['second'], img: '' },\n        { name: 'eight', domains: ['third'], img: '' },\n      ],\n    };\n    const domains: IForceDirectedChartData['domains'] = input.domains.map((name, index) => ({ index, name, value: 1 }));\n    const entities: IForceDirectedChartData['entities'] = input.entities.map((app, index) => ({\n      index: index,\n      name: app.name,\n      domains: [...app.domains],\n      img: app.img,\n      linksCount: 0,\n    }));\n    const nodes: IForceDirectedGraphEntity[] = [...entities];\n    const links: IForceDirectedChartData['links'] = entities\n      .map(entity => {\n        return entity.domains.map(domain => {\n          const source = domains.find(value => domain === value.name)?.index ?? -1;\n          const target = entity.index;\n          return { source, target };\n        });\n      })\n      .reduce((accumulator, item) => (Array.isArray(item) ? [...accumulator, ...item] : [...accumulator, item]), [])\n      .filter(link => link.source !== -1 && link.target !== -1 && typeof link.target !== 'undefined');\n    const chartData: IForceDirectedChartData = {\n      domains,\n      entities: entities.map(item => ({\n        ...item,\n        linksCount: links.reduce((acc, link) => (link.target === item.index ? acc + 1 : acc), 0),\n      })),\n      links,\n      nodes,\n    };\n    return chartData;\n  }\n\n  private readonly breakpoint$ = this.breakpointObserver\n    .observe([Breakpoints.XSmall, Breakpoints.Small, Breakpoints.Medium, Breakpoints.Large, Breakpoints.XLarge])\n    .pipe(map(result => Object.keys(result.breakpoints).find(item => result.breakpoints[item]) ?? 'unknown'));\n\n  public readonly barChartConfig$ = this.breakpoint$.pipe(\n    switchMap(() =>\n      timer(this.timeout).pipe(\n        first(),\n        map(() => ({ data: this.barChartData, options: this.barChartOptions() })),\n      ),\n    ),\n  );\n\n  public readonly lineChartConfig$ = this.breakpoint$.pipe(\n    switchMap(() =>\n      timer(this.timeout).pipe(\n        first(),\n        map(() => ({ data: this.lineChartData, options: this.lineChartOptions() })),\n      ),\n    ),\n  );\n\n  public readonly radarChartConfig$ = this.breakpoint$.pipe(\n    switchMap(() =>\n      timer(this.timeout).pipe(\n        first(),\n        map(() => ({ data: this.radarChartData, options: this.radarChartOptions() })),\n      ),\n    ),\n  );\n\n  public readonly pieChartConfig$ = this.breakpoint$.pipe(\n    switchMap(() =>\n      timer(this.timeout).pipe(\n        first(),\n        map(() => ({ data: this.pieChartData, options: this.pieChartOptions() })),\n      ),\n    ),\n  );\n\n  public readonly forceDirectedChartConfig$ = this.breakpoint$.pipe(\n    switchMap(() =>\n      timer(this.timeout).pipe(\n        first(),\n        map(() => ({ data: this.forceDirectedChartData, options: this.forceDirectedChartOptions() })),\n      ),\n    ),\n  );\n\n  constructor(private readonly breakpointObserver: BreakpointObserver) {}\n\n  private readonly timeout = 100;\n\n  public barChartOptions() {\n    return <Partial<IBarChartOptions>>{\n      chartTitle: 'Example bar chart',\n      xAxisTitle: 'long x axis title',\n      yAxisTitle: 'long y axis title',\n    };\n  }\n\n  public lineChartOptions() {\n    return <Partial<ILineChartOptions>>{\n      chartTitle: 'Example line chart',\n      xAxisTitle: 'Date range',\n      yAxisTitle: 'Value range',\n    };\n  }\n\n  public radarChartOptions() {\n    return <Partial<IRadarChartOptions>>{\n      chartTitle: 'Example radar chart',\n    };\n  }\n\n  public pieChartOptions() {\n    return <Partial<IPieChartOptions>>{\n      chartTitle: 'Example pie chart',\n    };\n  }\n\n  public forceDirectedChartOptions() {\n    return <Partial<IForceDirectedChartOptions>>{\n      chartTitle: 'Example force directed chart',\n    };\n  }\n}\n","<div class=\"container\" *ngIf=\"barChartConfig$ | async as config\">\n  <app-bar-chart [chartId]=\"'bar-example-1'\" [data]=\"config.data\" [options]=\"config.options\"></app-bar-chart>\n</div>\n\n<hr [ngStyle]=\"{ width: '100%' }\" />\n\n<div class=\"container\" *ngIf=\"lineChartConfig$ | async as config\">\n  <app-line-chart [chartId]=\"'line-example-1'\" [data]=\"config.data\" [options]=\"config.options\"></app-line-chart>\n</div>\n\n<hr [ngStyle]=\"{ width: '100%' }\" />\n\n<div class=\"container\" *ngIf=\"radarChartConfig$ | async as config\">\n  <app-radar-chart [chartId]=\"'radar-example-1'\" [data]=\"config.data\" [options]=\"config.options\"></app-radar-chart>\n</div>\n\n<hr [ngStyle]=\"{ width: '100%' }\" />\n\n<div class=\"container\" *ngIf=\"pieChartConfig$ | async as config\">\n  <app-pie-chart [chartId]=\"'pie-example-1'\" [data]=\"config.data\" [options]=\"config.options\"></app-pie-chart>\n</div>\n\n<hr [ngStyle]=\"{ width: '100%' }\" />\n\n<div class=\"container\" *ngIf=\"forceDirectedChartConfig$ | async as config\">\n  <app-force-directed-chart\n    [chartId]=\"'force-directed-example-1'\"\n    [data]=\"config.data\"\n    [options]=\"config.options\"\n  ></app-force-directed-chart>\n</div>\n"]}

package/esm2020/lib/components/force-directed-chart/force-directed-chart.component.mjs

@@ -0,0 +1,92 @@
+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 AppForceDirectedChartComponent {
+    constructor(doc, d3Factory) {
+        this.doc = doc;
+        this.d3Factory = d3Factory;
+        /**
+         * The chart identifier.
+         */
+        this.chartId = 'force-0';
+        /**
+         * The chart data.
+         */
+        this.data = {
+            domains: [],
+            entities: [],
+            links: [],
+            nodes: [],
+        };
+        /**
+         * 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.drawForceDirectedChart(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 prevData = changes.data?.previousValue;
+        const nextData = changes.data?.currentValue;
+        const options = changes.options?.currentValue;
+        if ((Boolean(changes.data?.currentValue) && (prevData?.nodes ?? []).length !== (nextData?.nodes ?? []).length) ||
+            (typeof options !== 'undefined' && options !== null)) {
+            this.drawChart();
+        }
+    }
+}
+/** @nocollapse */ AppForceDirectedChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AppForceDirectedChartComponent, deps: [{ token: DOCUMENT }, { token: D3_CHART_FACTORY }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ AppForceDirectedChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.6", type: AppForceDirectedChartComponent, selector: "app-force-directed-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 .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: AppForceDirectedChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-force-directed-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 .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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9yY2UtZGlyZWN0ZWQtY2hhcnQuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jbGllbnQtZDMtY2hhcnRzL3NyYy9saWIvY29tcG9uZW50cy9mb3JjZS1kaXJlY3RlZC1jaGFydC9mb3JjZS1kaXJlY3RlZC1jaGFydC5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NsaWVudC1kMy1jaGFydHMvc3JjL2xpYi9jb21wb25lbnRzL2ZvcmNlLWRpcmVjdGVkLWNoYXJ0L2ZvcmNlLWRpcmVjdGVkLWNoYXJ0LmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMzQyxPQUFPLEVBRUwsdUJBQXVCLEVBQ3ZCLFNBQVMsRUFDVCxVQUFVLEVBQ1YsTUFBTSxFQUNOLEtBQUssRUFHTCxTQUFTLEdBQ1YsTUFBTSxlQUFlLENBQUM7QUFHdkIsT0FBTyxFQUFFLGdCQUFnQixFQUFtQixNQUFNLDJDQUEyQyxDQUFDOztBQWE5RixNQUFNLE9BQU8sOEJBQThCO0lBMEJ6QyxZQUErQyxHQUFhLEVBQTZDLFNBQTBCO1FBQXBGLFFBQUcsR0FBSCxHQUFHLENBQVU7UUFBNkMsY0FBUyxHQUFULFNBQVMsQ0FBaUI7UUF6Qm5JOztXQUVHO1FBQ2EsWUFBTyxHQUFHLFNBQVMsQ0FBQztRQUVwQzs7V0FFRztRQUNhLFNBQUksR0FBNEI7WUFDOUMsT0FBTyxFQUFFLEVBQUU7WUFDWCxRQUFRLEVBQUUsRUFBRTtZQUNaLEtBQUssRUFBRSxFQUFFO1lBQ1QsS0FBSyxFQUFFLEVBQUU7U0FDVixDQUFDO1FBRUY7O1dBRUc7UUFDYSxZQUFPLEdBQXdDLEVBQUUsQ0FBQztJQU9vRSxDQUFDO0lBRXZJOzs7T0FHRztJQUNLLFlBQVk7UUFDbEIsTUFBTSxNQUFNLEdBQUcsRUFBRSxHQUFHLEVBQUUsRUFBRSxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLENBQUM7UUFDNUQsTUFBTSxRQUFRLEdBQUcsR0FBRyxDQUFDO1FBQ3JCLE1BQU0sU0FBUyxHQUFHO1lBQ2hCLEtBQUssRUFBRSxFQUFFO1lBQ1QsTUFBTSxFQUFFLEVBQUU7U0FDWCxDQUFDO1FBQ0YsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsV0FBVyxHQUFHLFNBQVMsQ0FBQyxLQUFLLENBQUMsR0FBRyxNQUFNLENBQUMsSUFBSSxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUM7UUFDM0csTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsWUFBWSxHQUFHLE1BQU0sQ0FBQyxHQUFHLEdBQUcsTUFBTSxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDM0csTUFBTSxPQUFPLEdBQXdDLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsR0FBRyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDaEcsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQztJQUVEOztPQUVHO0lBQ0ssU0FBUztRQUNmLElBQUksT0FBTyxJQUFJLENBQUMsU0FBUyxLQUFLLFdBQVcsRUFBRTtZQUN6QyxNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7WUFDcEMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxzQkFBc0IsQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLElBQUksQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7U0FDM0U7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxlQUFlO1FBQ3BCLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztJQUNuQixDQUFDO0lBRUQ7O09BRUc7SUFDSSxXQUFXLENBQUMsT0FBc0I7UUFDdkMsTUFBTSxRQUFRLEdBQXdDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsYUFBYSxDQUFDO1FBQ2xGLE1BQU0sUUFBUSxHQUF3QyxPQUFPLENBQUMsSUFBSSxFQUFFLFlBQVksQ0FBQztRQUNqRixNQUFNLE9BQU8sR0FBd0MsT0FBTyxDQUFDLE9BQU8sRUFBRSxZQUFZLENBQUM7UUFDbkYsSUFDRSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLFlBQVksQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLEtBQUssSUFBSSxFQUFFLENBQUMsQ0FBQyxNQUFNLEtBQUssQ0FBQyxRQUFRLEVBQUUsS0FBSyxJQUFJLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQztZQUMxRyxDQUFDLE9BQU8sT0FBTyxLQUFLLFdBQVcsSUFBSSxPQUFPLEtBQUssSUFBSSxDQUFDLEVBQ3BEO1lBQ0EsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1NBQ2xCO0lBQ0gsQ0FBQzs7OElBM0VVLDhCQUE4QixrQkEwQnJCLFFBQVEsYUFBMEMsZ0JBQWdCO2tJQTFCM0UsOEJBQThCLCtQQzNCM0Msa0tBS0E7MkZEc0JhLDhCQUE4QjtrQkFOMUMsU0FBUzsrQkFDRSwwQkFBMEIsbUJBR25CLHVCQUF1QixDQUFDLE1BQU07MERBNEJLLFFBQVE7MEJBQS9DLE1BQU07MkJBQUMsUUFBUTs7MEJBQW1DLE1BQU07MkJBQUMsZ0JBQWdCOzRDQXRCdEUsT0FBTztzQkFBdEIsS0FBSztnQkFLVSxJQUFJO3NCQUFuQixLQUFLO2dCQVVVLE9BQU87c0JBQXRCLEtBQUs7Z0JBS21DLFNBQVM7c0JBQWpELFNBQVM7dUJBQUMsV0FBVyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERPQ1VNRU5UIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7XG4gIEFmdGVyVmlld0luaXQsXG4gIENoYW5nZURldGVjdGlvblN0cmF0ZWd5LFxuICBDb21wb25lbnQsXG4gIEVsZW1lbnRSZWYsXG4gIEluamVjdCxcbiAgSW5wdXQsXG4gIE9uQ2hhbmdlcyxcbiAgU2ltcGxlQ2hhbmdlLFxuICBWaWV3Q2hpbGQsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBJRm9yY2VEaXJlY3RlZENoYXJ0RGF0YSwgSUZvcmNlRGlyZWN0ZWRDaGFydE9wdGlvbnMgfSBmcm9tICcuLi8uLi9pbnRlcmZhY2VzL2ZvcmNlLWRpcmVjdGVkLWNoYXJ0LmludGVyZmFjZSc7XG5pbXBvcnQgeyBEM19DSEFSVF9GQUNUT1JZLCBJRDNDaGFydEZhY3RvcnkgfSBmcm9tICcuLi8uLi9wcm92aWRlcnMvZDMtY2hhcnQtZmFjdG9yeS5wcm92aWRlcic7XG5cbmludGVyZmFjZSBJSW5wdXRDaGFuZ2VzIHtcbiAgZGF0YT86IFNpbXBsZUNoYW5nZSB8IG51bGw7XG4gIG9wdGlvbnM/OiBTaW1wbGVDaGFuZ2UgfCBudWxsO1xufVxuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdhcHAtZm9yY2UtZGlyZWN0ZWQtY2hhcnQnLFxuICB0ZW1wbGF0ZVVybDogJy4vZm9yY2UtZGlyZWN0ZWQtY2hhcnQuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9mb3JjZS1kaXJlY3RlZC1jaGFydC5jb21wb25lbnQuc2NzcyddLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbn0pXG5leHBvcnQgY2xhc3MgQXBwRm9yY2VEaXJlY3RlZENoYXJ0Q29tcG9uZW50IGltcGxlbWVudHMgQWZ0ZXJWaWV3SW5pdCwgT25DaGFuZ2VzIHtcbiAgLyoqXG4gICAqIFRoZSBjaGFydCBpZGVudGlmaWVyLlxuICAgKi9cbiAgQElucHV0KCkgcHVibGljIGNoYXJ0SWQgPSAnZm9yY2UtMCc7XG5cbiAgLyoqXG4gICAqIFRoZSBjaGFydCBkYXRhLlxuICAgKi9cbiAgQElucHV0KCkgcHVibGljIGRhdGE6IElGb3JjZURpcmVjdGVkQ2hhcnREYXRhID0ge1xuICAgIGRvbWFpbnM6IFtdLFxuICAgIGVudGl0aWVzOiBbXSxcbiAgICBsaW5rczogW10sXG4gICAgbm9kZXM6IFtdLFxuICB9O1xuXG4gIC8qKlxuICAgKiBUaGUgY2hhcnQgb3B0aW9ucy5cbiAgICovXG4gIEBJbnB1dCgpIHB1YmxpYyBvcHRpb25zOiBQYXJ0aWFsPElGb3JjZURpcmVjdGVkQ2hhcnRPcHRpb25zPiA9IHt9O1xuXG4gIC8qKlxuICAgKiBUaGUgY2hhcnQgY29udGFpbmVyIHZpZXcgY2hpbGQgcmVmZXJlbmNlLlxuICAgKi9cbiAgQFZpZXdDaGlsZCgnY29udGFpbmVyJykgcHJpdmF0ZSByZWFkb25seSBjb250YWluZXI/OiBFbGVtZW50UmVmPEhUTUxEaXZFbGVtZW50PjtcblxuICBjb25zdHJ1Y3RvcihASW5qZWN0KERPQ1VNRU5UKSBwcml2YXRlIHJlYWRvbmx5IGRvYzogRG9jdW1lbnQsIEBJbmplY3QoRDNfQ0hBUlRfRkFDVE9SWSkgcHJpdmF0ZSByZWFkb25seSBkM0ZhY3Rvcnk6IElEM0NoYXJ0RmFjdG9yeSkge31cblxuICAvKipcbiAgICogVGhlIGNoYXJ0IG9wdGlvbnMgY29uc3RydWN0b3IuXG4gICAqIEByZXR1cm5zIGNoYXJ0IG9wdGlvbnNcbiAgICovXG4gIHByaXZhdGUgY2hhcnRPcHRpb25zKCkge1xuICAgIGNvbnN0IG1hcmdpbiA9IHsgdG9wOiA1MCwgcmlnaHQ6IDUwLCBib3R0b206IDUwLCBsZWZ0OiA1MCB9O1xuICAgIGNvbnN0IG1pbldpZHRoID0gMzUwO1xuICAgIGNvbnN0IG1vZGlmaWVycyA9IHtcbiAgICAgIHdpZHRoOiAxMCxcbiAgICAgIGhlaWdodDogMjAsXG4gICAgfTtcbiAgICBjb25zdCB3aWR0aCA9IE1hdGgubWluKG1pbldpZHRoLCB0aGlzLmRvYy5ib2R5LmNsaWVudFdpZHRoIC0gbW9kaWZpZXJzLndpZHRoKSAtIG1hcmdpbi5sZWZ0IC0gbWFyZ2luLnJpZ2h0O1xuICAgIGNvbnN0IGhlaWdodCA9IE1hdGgubWluKHdpZHRoLCB0aGlzLmRvYy5ib2R5LmNsaWVudEhlaWdodCAtIG1hcmdpbi50b3AgLSBtYXJnaW4uYm90dG9tIC0gbW9kaWZpZXJzLmhlaWdodCk7XG4gICAgY29uc3Qgb3B0aW9uczogUGFydGlhbDxJRm9yY2VEaXJlY3RlZENoYXJ0T3B0aW9ucz4gPSB7IHdpZHRoLCBoZWlnaHQsIG1hcmdpbiwgLi4udGhpcy5vcHRpb25zIH07XG4gICAgcmV0dXJuIG9wdGlvbnM7XG4gIH1cblxuICAvKipcbiAgICogRHJhd3MgdGhlIGNoYXJ0LlxuICAgKi9cbiAgcHJpdmF0ZSBkcmF3Q2hhcnQoKSB7XG4gICAgaWYgKHR5cGVvZiB0aGlzLmNvbnRhaW5lciAhPT0gJ3VuZGVmaW5lZCcpIHtcbiAgICAgIGNvbnN0IG9wdGlvbnMgPSB0aGlzLmNoYXJ0T3B0aW9ucygpO1xuICAgICAgdGhpcy5kM0ZhY3RvcnkuZHJhd0ZvcmNlRGlyZWN0ZWRDaGFydCh0aGlzLmNvbnRhaW5lciwgdGhpcy5kYXRhLCBvcHRpb25zKTtcbiAgICB9XG4gIH1cblxuICAvKipcbiAgICogQWN0dWFsbHkgZHJhd3MgdGhlIGNoYXJ0IGFmdGVyIHRoZSBjb21wb25lbnQgdmlldyBpcyBpbml0aWFsaXplZC5cbiAgICovXG4gIHB1YmxpYyBuZ0FmdGVyVmlld0luaXQoKTogdm9pZCB7XG4gICAgdGhpcy5kcmF3Q2hhcnQoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZWRyYXdzIHRoZSBjaGFydCBvbiBjaGFuZ2VzLlxuICAgKi9cbiAgcHVibGljIG5nT25DaGFuZ2VzKGNoYW5nZXM6IElJbnB1dENoYW5nZXMpOiB2b2lkIHtcbiAgICBjb25zdCBwcmV2RGF0YTogSUZvcmNlRGlyZWN0ZWRDaGFydERhdGEgfCB1bmRlZmluZWQgPSBjaGFuZ2VzLmRhdGE/LnByZXZpb3VzVmFsdWU7XG4gICAgY29uc3QgbmV4dERhdGE6IElGb3JjZURpcmVjdGVkQ2hhcnREYXRhIHwgdW5kZWZpbmVkID0gY2hhbmdlcy5kYXRhPy5jdXJyZW50VmFsdWU7XG4gICAgY29uc3Qgb3B0aW9uczogUGFydGlhbDxJRm9yY2VEaXJlY3RlZENoYXJ0T3B0aW9ucz4gPSBjaGFuZ2VzLm9wdGlvbnM/LmN1cnJlbnRWYWx1ZTtcbiAgICBpZiAoXG4gICAgICAoQm9vbGVhbihjaGFuZ2VzLmRhdGE/LmN1cnJlbnRWYWx1ZSkgJiYgKHByZXZEYXRhPy5ub2RlcyA/PyBbXSkubGVuZ3RoICE9PSAobmV4dERhdGE/Lm5vZGVzID8/IFtdKS5sZW5ndGgpIHx8XG4gICAgICAodHlwZW9mIG9wdGlvbnMgIT09ICd1bmRlZmluZWQnICYmIG9wdGlvbnMgIT09IG51bGwpXG4gICAgKSB7XG4gICAgICB0aGlzLmRyYXdDaGFydCgpO1xuICAgIH1cbiAgfVxufVxuIiwiPGRpdiBjbGFzcz1cImNvbnRhaW5lclwiPlxuICA8ZGl2IGlkPVwie3sgY2hhcnRJZCB9fVwiICNjb250YWluZXI+PC9kaXY+XG5cbiAgPHNtYWxsIGNsYXNzPVwiY29udGFpbmVyLS1jaGFydC10aXRsZVwiPnt7IG9wdGlvbnMuY2hhcnRUaXRsZSB9fTwvc21hbGw+XG48L2Rpdj5cbiJdfQ==

package/esm2020/lib/components/index.mjs

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