angular-google-charts
Version:
A wrapper for the Google Charts library written with Angular
116 lines • 18.4 kB
JavaScript
import { ChangeDetectionStrategy, Component, ContentChildren, ElementRef, EventEmitter, Input, Output, QueryList } from '@angular/core';
import { combineLatest } from 'rxjs';
import { DataTableService } from '../../services/data-table.service';
import { ScriptLoaderService } from '../../services/script-loader.service';
import { ControlWrapperComponent } from '../control-wrapper/control-wrapper.component';
import * as i0 from "@angular/core";
import * as i1 from "../../services/script-loader.service";
import * as i2 from "../../services/data-table.service";
export class DashboardComponent {
constructor(element, loaderService, dataTableService) {
this.element = element;
this.loaderService = loaderService;
this.dataTableService = dataTableService;
/**
* The dashboard has completed drawing and is ready to accept changes.
*
* The ready event will also fire:
* - after the completion of a dashboard refresh triggered by a user or programmatic interaction with one of the controls,
* - after redrawing any chart on the dashboard.
*/
this.ready = new EventEmitter();
/**
* Emits when an error occurs when attempting to render the dashboard.
* One or more of the controls and charts that are part of the dashboard may have failed rendering.
*/
this.error = new EventEmitter();
this.initialized = false;
}
ngOnInit() {
this.loaderService.loadChartPackages('controls').subscribe(() => {
this.dataTable = this.dataTableService.create(this.data, this.columns, this.formatters);
this.createDashboard();
this.initialized = true;
});
}
ngOnChanges(changes) {
if (!this.initialized) {
return;
}
if (changes.data || changes.columns || changes.formatters) {
this.dataTable = this.dataTableService.create(this.data, this.columns, this.formatters);
this.dashboard.draw(this.dataTable);
}
}
createDashboard() {
// TODO: This should happen in the control wrapper
// However, I don't yet know how to do this because then `bind()` would get called multiple times
// for the same control if something changes. This is not supported by google charts as far as I can tell
// from their source code.
const controlWrappersReady$ = this.controlWrappers.map(control => control.wrapperReady$);
const chartsReady$ = this.controlWrappers
.map(control => control.for)
.map(charts => {
if (Array.isArray(charts)) {
// CombineLatest waits for all observables
return combineLatest(charts.map(chart => chart.wrapperReady$));
}
else {
return charts.wrapperReady$;
}
});
// We have to wait for all chart wrappers and control wrappers to be initialized
// before we can compose them together to create the dashboard
combineLatest([...controlWrappersReady$, ...chartsReady$]).subscribe(() => {
this.dashboard = new google.visualization.Dashboard(this.element.nativeElement);
this.initializeBindings();
this.registerEvents();
this.dashboard.draw(this.dataTable);
});
}
registerEvents() {
google.visualization.events.removeAllListeners(this.dashboard);
const registerDashEvent = (object, eventName, callback) => {
google.visualization.events.addListener(object, eventName, callback);
};
registerDashEvent(this.dashboard, 'ready', () => this.ready.emit());
registerDashEvent(this.dashboard, 'error', (error) => this.error.emit(error));
}
initializeBindings() {
this.controlWrappers.forEach(control => {
if (Array.isArray(control.for)) {
const chartWrappers = control.for.map(chart => chart.chartWrapper);
this.dashboard.bind(control.controlWrapper, chartWrappers);
}
else {
this.dashboard.bind(control.controlWrapper, control.for.chartWrapper);
}
});
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DashboardComponent, deps: [{ token: i0.ElementRef }, { token: i1.ScriptLoaderService }, { token: i2.DataTableService }], target: i0.ɵɵFactoryTarget.Component }); }
static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: DashboardComponent, selector: "dashboard", inputs: { data: "data", columns: "columns", formatters: "formatters" }, outputs: { ready: "ready", error: "error" }, host: { classAttribute: "dashboard" }, queries: [{ propertyName: "controlWrappers", predicate: ControlWrapperComponent }], exportAs: ["dashboard"], usesOnChanges: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DashboardComponent, decorators: [{
type: Component,
args: [{
selector: 'dashboard',
template: '<ng-content></ng-content>',
changeDetection: ChangeDetectionStrategy.OnPush,
exportAs: 'dashboard',
host: { class: 'dashboard' }
}]
}], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.ScriptLoaderService }, { type: i2.DataTableService }]; }, propDecorators: { data: [{
type: Input
}], columns: [{
type: Input
}], formatters: [{
type: Input
}], ready: [{
type: Output
}], error: [{
type: Output
}], controlWrappers: [{
type: ContentChildren,
args: [ControlWrapperComponent]
}] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.component.js","sourceRoot":"","sources":["../../../../../../projects/angular-google-charts/src/lib/components/dashboard/dashboard.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  ContentChildren,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnInit,\n  Output,\n  QueryList,\n  SimpleChanges\n} from '@angular/core';\nimport { combineLatest } from 'rxjs';\n\nimport { DataTableService } from '../../services/data-table.service';\nimport { ScriptLoaderService } from '../../services/script-loader.service';\nimport { ChartErrorEvent } from '../../types/events';\nimport { Formatter } from '../../types/formatter';\nimport { Column, Row } from '../chart-base/chart-base.component';\nimport { ControlWrapperComponent } from '../control-wrapper/control-wrapper.component';\n\n@Component({\n  selector: 'dashboard',\n  template: '<ng-content></ng-content>',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  exportAs: 'dashboard',\n  host: { class: 'dashboard' }\n})\nexport class DashboardComponent implements OnInit, OnChanges {\n  /**\n   * Data used to initialize the table.\n   *\n   * This must also contain all roles that are set in the `columns` property.\n   */\n  @Input()\n  public data!: Row[];\n\n  /**\n   * The columns the `data` consists of.\n   * The length of this array must match the length of each row in the `data` object.\n   *\n   * If {@link https://developers.google.com/chart/interactive/docs/roles roles} should be applied, they must be included in this array as well.\n   */\n  @Input()\n  public columns?: Column[];\n\n  /**\n   * Used to change the displayed value of the specified column in all rows.\n   *\n   * Each array element must consist of an instance of a [`formatter`](https://developers.google.com/chart/interactive/docs/reference#formatters)\n   * and the index of the column you want the formatter to get applied to.\n   */\n  @Input()\n  public formatters?: Formatter[];\n\n  /**\n   * The dashboard has completed drawing and is ready to accept changes.\n   *\n   * The ready event will also fire:\n   * - after the completion of a dashboard refresh triggered by a user or programmatic interaction with one of the controls,\n   * - after redrawing any chart on the dashboard.\n   */\n  @Output()\n  public ready = new EventEmitter<void>();\n\n  /**\n   * Emits when an error occurs when attempting to render the dashboard.\n   * One or more of the controls and charts that are part of the dashboard may have failed rendering.\n   */\n  @Output()\n  public error = new EventEmitter<ChartErrorEvent>();\n\n  @ContentChildren(ControlWrapperComponent)\n  private controlWrappers!: QueryList<ControlWrapperComponent>;\n\n  private dashboard?: google.visualization.Dashboard;\n  private dataTable?: google.visualization.DataTable;\n  private initialized = false;\n\n  constructor(\n    private element: ElementRef,\n    private loaderService: ScriptLoaderService,\n    private dataTableService: DataTableService\n  ) {}\n\n  public ngOnInit() {\n    this.loaderService.loadChartPackages('controls').subscribe(() => {\n      this.dataTable = this.dataTableService.create(this.data, this.columns, this.formatters);\n      this.createDashboard();\n      this.initialized = true;\n    });\n  }\n\n  public ngOnChanges(changes: SimpleChanges): void {\n    if (!this.initialized) {\n      return;\n    }\n\n    if (changes.data || changes.columns || changes.formatters) {\n      this.dataTable = this.dataTableService.create(this.data, this.columns, this.formatters);\n      this.dashboard!.draw(this.dataTable!);\n    }\n  }\n\n  private createDashboard(): void {\n    // TODO: This should happen in the control wrapper\n    // However, I don't yet know how to do this because then `bind()` would get called multiple times\n    // for the same control if something changes. This is not supported by google charts as far as I can tell\n    // from their source code.\n    const controlWrappersReady$ = this.controlWrappers.map(control => control.wrapperReady$);\n    const chartsReady$ = this.controlWrappers\n      .map(control => control.for)\n      .map(charts => {\n        if (Array.isArray(charts)) {\n          // CombineLatest waits for all observables\n          return combineLatest(charts.map(chart => chart.wrapperReady$));\n        } else {\n          return charts.wrapperReady$;\n        }\n      });\n\n    // We have to wait for all chart wrappers and control wrappers to be initialized\n    // before we can compose them together to create the dashboard\n    combineLatest([...controlWrappersReady$, ...chartsReady$]).subscribe(() => {\n      this.dashboard = new google.visualization.Dashboard(this.element.nativeElement);\n      this.initializeBindings();\n      this.registerEvents();\n      this.dashboard.draw(this.dataTable!);\n    });\n  }\n\n  private registerEvents(): void {\n    google.visualization.events.removeAllListeners(this.dashboard);\n\n    const registerDashEvent = (object: any, eventName: string, callback: Function) => {\n      google.visualization.events.addListener(object, eventName, callback);\n    };\n\n    registerDashEvent(this.dashboard, 'ready', () => this.ready.emit());\n    registerDashEvent(this.dashboard, 'error', (error: ChartErrorEvent) => this.error.emit(error));\n  }\n\n  private initializeBindings(): void {\n    this.controlWrappers.forEach(control => {\n      if (Array.isArray(control.for)) {\n        const chartWrappers = control.for.map(chart => chart.chartWrapper);\n        this.dashboard!.bind(control.controlWrapper, chartWrappers);\n      } else {\n        this.dashboard!.bind(control.controlWrapper, control.for.chartWrapper);\n      }\n    });\n  }\n}\n"]}