@rfprodz/client-d3-charts 1.2.24 → 1.3.0

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

@@ -0,0 +1,88 @@
+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";
+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 */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AppBarChartComponent, deps: [{ token: DOCUMENT }, { token: D3_CHART_FACTORY }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", 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 }); }
+}
+export { AppBarChartComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", 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/esm2022/lib/components/chart-examples/chart-examples.component.mjs

@@ -0,0 +1,228 @@
+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";
+class AppChartExamplesComponent {
+    /**
+     * 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() {
+        return [
+            [
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+            ].sort((a, b) => a.timestamp - b.timestamp),
+            [
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+            ].sort((a, b) => a.timestamp - b.timestamp),
+            [
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+                { timestamp: this.randomTimestamp(), value: this.randomValue() },
+            ].sort((a, b) => a.timestamp - b.timestamp),
+        ];
+    }
+    /**
+     * 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;
+    }
+    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(),
+            optionsDateDdMmYy: this.lineChartOptions('dd/mm/yy'),
+            optionsDateDdMmYyyy: this.lineChartOptions('dd/mm/yyyy'),
+            optionsDateMmYyyy: this.lineChartOptions('mm/yyyy'),
+        })))));
+        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;
+    }
+    randomValue(range) {
+        const defaultRange = 100;
+        return Math.floor(Math.random() * (range ?? defaultRange) + 1);
+    }
+    randomTimestamp(range) {
+        const defaultRange = 100000000;
+        return Math.floor(Math.random() * (range ?? defaultRange) + new Date().getTime());
+    }
+    /**
+     * Example bar chart options.
+     */
+    barChartOptions() {
+        return {
+            chartTitle: 'Example bar chart',
+            xAxisTitle: 'long x axis title',
+            yAxisTitle: 'long y axis title',
+        };
+    }
+    /**
+     * Example line chart options.
+     * @param dateFormat date format
+     */
+    lineChartOptions(dateFormat = 'default') {
+        return {
+            chartTitle: `Example line chart, date format ${dateFormat}`,
+            xAxisTitle: 'Date range',
+            yAxisTitle: 'Value range',
+            dateFormat,
+        };
+    }
+    /**
+     * Example radar chart options.
+     */
+    radarChartOptions() {
+        return {
+            chartTitle: 'Example radar chart',
+        };
+    }
+    /**
+     * Example pie chart options.
+     */
+    pieChartOptions() {
+        return {
+            chartTitle: 'Example pie chart',
+        };
+    }
+    /**
+     * Example force directed chart options.
+     */
+    forceDirectedChartOptions() {
+        return {
+            chartTitle: 'Example force directed chart',
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AppChartExamplesComponent, deps: [{ token: i1.BreakpointObserver }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", 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[0]]\" [options]=\"config.options\"></app-line-chart>\n\n  <app-line-chart [chartId]=\"'line-example-2'\" [data]=\"[config.data[1]]\" [options]=\"config.optionsDateDdMmYy\"></app-line-chart>\n\n  <app-line-chart\n    [chartId]=\"'line-example-3'\"\n    [data]=\"[config.data[1], config.data[2]]\"\n    [options]=\"config.optionsDateDdMmYyyy\"\n  ></app-line-chart>\n\n  <app-line-chart [chartId]=\"'line-example-4'\" [data]=\"config.data\" [options]=\"config.optionsDateMmYyyy\"></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{display:flex;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 }); }
+}
+export { AppChartExamplesComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", 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[0]]\" [options]=\"config.options\"></app-line-chart>\n\n  <app-line-chart [chartId]=\"'line-example-2'\" [data]=\"[config.data[1]]\" [options]=\"config.optionsDateDdMmYy\"></app-line-chart>\n\n  <app-line-chart\n    [chartId]=\"'line-example-3'\"\n    [data]=\"[config.data[1], config.data[2]]\"\n    [options]=\"config.optionsDateDdMmYyyy\"\n  ></app-line-chart>\n\n  <app-line-chart [chartId]=\"'line-example-4'\" [data]=\"config.data\" [options]=\"config.optionsDateMmYyyy\"></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{display:flex;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, TDateFormat, 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    return <TLineChartData[]>[\n      [\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n      ].sort((a, b) => a.timestamp - b.timestamp),\n      [\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n      ].sort((a, b) => a.timestamp - b.timestamp),\n      [\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n        { timestamp: this.randomTimestamp(), value: this.randomValue() },\n      ].sort((a, b) => a.timestamp - b.timestamp),\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(() => ({\n          data: this.lineChartData,\n          options: this.lineChartOptions(),\n          optionsDateDdMmYy: this.lineChartOptions('dd/mm/yy'),\n          optionsDateDdMmYyyy: this.lineChartOptions('dd/mm/yyyy'),\n          optionsDateMmYyyy: this.lineChartOptions('mm/yyyy'),\n        })),\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 randomValue(range?: number) {\n    const defaultRange = 100;\n    return Math.floor(Math.random() * (range ?? defaultRange) + 1);\n  }\n\n  public randomTimestamp(range?: number) {\n    const defaultRange = 100000000;\n    return Math.floor(Math.random() * (range ?? defaultRange) + new Date().getTime());\n  }\n\n  /**\n   * Example bar chart options.\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  /**\n   * Example line chart options.\n   * @param dateFormat date format\n   */\n  public lineChartOptions(dateFormat: TDateFormat = 'default') {\n    return <Partial<ILineChartOptions>>{\n      chartTitle: `Example line chart, date format ${dateFormat}`,\n      xAxisTitle: 'Date range',\n      yAxisTitle: 'Value range',\n      dateFormat,\n    };\n  }\n\n  /**\n   * Example radar chart options.\n   */\n  public radarChartOptions() {\n    return <Partial<IRadarChartOptions>>{\n      chartTitle: 'Example radar chart',\n    };\n  }\n\n  /**\n   * Example pie chart options.\n   */\n  public pieChartOptions() {\n    return <Partial<IPieChartOptions>>{\n      chartTitle: 'Example pie chart',\n    };\n  }\n\n  /**\n   * Example force directed chart options.\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[0]]\" [options]=\"config.options\"></app-line-chart>\n\n  <app-line-chart [chartId]=\"'line-example-2'\" [data]=\"[config.data[1]]\" [options]=\"config.optionsDateDdMmYy\"></app-line-chart>\n\n  <app-line-chart\n    [chartId]=\"'line-example-3'\"\n    [data]=\"[config.data[1], config.data[2]]\"\n    [options]=\"config.optionsDateDdMmYyyy\"\n  ></app-line-chart>\n\n  <app-line-chart [chartId]=\"'line-example-4'\" [data]=\"config.data\" [options]=\"config.optionsDateMmYyyy\"></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/esm2022/lib/components/force-directed-chart/force-directed-chart.component.mjs

@@ -0,0 +1,93 @@
+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";
+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 */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AppForceDirectedChartComponent, deps: [{ token: DOCUMENT }, { token: D3_CHART_FACTORY }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", 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 }); }
+}
+export { AppForceDirectedChartComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", 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,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

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

@@ -0,0 +1,93 @@
+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";
+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 height = Math.min(this.options.height ?? width, this.doc.body.clientWidth - defaultLineChartConfig.margin.top - defaultLineChartConfig.margin.bottom - bodyWidthAdjustment);
+        const xTicksScale = 75;
+        const yTicksScale = 25;
+        const ticks = {
+            x: this.options.ticks?.x ?? width / xTicksScale,
+            y: this.options.ticks?.y ?? height / yTicksScale,
+        };
+        const options = {
+            ...this.options,
+            width,
+            height,
+            ticks,
+        };
+        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 */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AppLineChartComponent, deps: [{ token: DOCUMENT }, { token: D3_CHART_FACTORY }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", 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 }); }
+}
+export { AppLineChartComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", 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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