core/src/models/series.ts

import { CoreSerie, yAxisOrientation } from '../types';
import { palette } from '../colors';

import lodashDefaultsDeep from 'lodash/defaultsDeep';
import lodashMap from 'lodash/map';
import lodashCloneDeep from 'lodash/cloneDeep';
import lodashUniq from 'lodash/uniq';
import lodashMin from 'lodash/min';
import lodashMinBy from 'lodash/minBy';
import lodashMax from 'lodash/max';
import lodashMaxBy from 'lodash/maxBy';


const SERIE_DEFAULTS = {
  alias: '',
  target: '',
  visible: true,
  yOrientation: yAxisOrientation.LEFT,
  datapoints: [],
  // fields below will be set in "fillDefaults" method
  idx: undefined,
  color: undefined,
};

export class CoreSeries<T extends CoreSerie> {
  _series: Array<T> = [];
  _defaults: CoreSerie = SERIE_DEFAULTS;

  constructor(series: T[]) {
    this.setSeries(series);
  }

  public updateSeries(series: T[]): void {
    this.setSeries(series);
  }

  protected setSeries(series: T[]): void {
    this._series = lodashMap(series, (serie, serieIdx) => this.fillDefaults(lodashCloneDeep(serie), serieIdx));
    this.ensureSeriesValid(this._series);
  }

  ensureSeriesValid(series: T[]): void {
    const targets = lodashMap(series, serie => serie.target);
    const uniqTargets = lodashUniq(targets);
    if(uniqTargets.length !== series.length) {
      throw new Error(`All serie.target should be uniq`);
    }
  }

  protected fillDefaults(serie: T, idx: number): T {
    let defaults = lodashCloneDeep(this._defaults);
    defaults.color = palette[idx % palette.length];
    defaults.idx = idx;
    lodashDefaultsDeep(serie, defaults);
    return serie;
  }

  get isSeriesAvailable(): boolean {
    return this.visibleSeries.length > 0;
  }

  get visibleSeries(): Array<T> {
    return this._series.filter(serie => serie.visible);
  }

  get allSeries(): Array<T> {
    return this._series;
  }

  get leftYRelatedSeries(): Array<T> {
    return this.visibleSeries.filter(serie => serie.yOrientation = yAxisOrientation.LEFT);
  }

  get rightYRelatedSeries(): Array<T> {
    return this.visibleSeries.filter(serie => serie.yOrientation = yAxisOrientation.RIGHT);
  }

  get minValueY(): number {
    return lodashMin(
      this.leftYRelatedSeries.map(
        serie => lodashMinBy<number[]>(serie.datapoints, dp => dp[1])[1]
      )
    );
  }

  get maxValueY(): number {
    return lodashMax(
      this.leftYRelatedSeries.map(
        serie => lodashMaxBy<number[]>(serie.datapoints, dp => dp[1])[1]
      )
    );
  }

  get minValueX(): number {
    return lodashMin(
      this.visibleSeries.map(
        serie => lodashMinBy<number[]>(serie.datapoints, dp => dp[0])[0]
      )
    );
  }

  get maxValueX(): number {
    return lodashMax(
      this.visibleSeries.map(
        serie => lodashMaxBy<number[]>(serie.datapoints, dp => dp[0])[0]
      )
    );
  }

  get minValueY1(): number {
    return lodashMin(
      this.rightYRelatedSeries.map(
        serie => lodashMinBy<number[]>(serie.datapoints, dp => dp[1])[1]
      )
    );
  }

  get maxValueY1(): number {
    return lodashMax(
      this.rightYRelatedSeries.map(
        serie => lodashMaxBy<number[]>(serie.datapoints, dp => dp[1])[1]
      )
    );
  }
}