Class QuantitativeScale

src/scales/quantitativeScale.ts:16–363

import * as TickGenerators from "./tickGenerators";

export class QuantitativeScale<D> extends Scale<D, number> implements ITransformableScale {
  protected static _DEFAULT_NUM_TICKS = 10;
  private _tickGenerator: TickGenerators.ITickGenerator<D> = (scale: QuantitativeScale<D>) => scale.defaultTicks();
  private _padProportion = 0.05;
  private _paddingExceptionsProviders: Utils.Set<Scales.IPaddingExceptionsProvider<D>>;
  private _domainMin: D;
  private _domainMax: D;
  private _snappingDomainEnabled = true;

  /**
   * A QuantitativeScale is a Scale that maps number-like values to numbers.
   * It is invertible and continuous.
   *
   * @constructor
   */
  constructor() {
    super();
    this._paddingExceptionsProviders = new Utils.Set<Scales.IPaddingExceptionsProvider<D>>();
  }

  public autoDomain() {
    this._domainMin = null;
    this._domainMax = null;
    super.autoDomain();
    return this;
  }

  public autoDomainIfAutomaticMode() {
    if (this._domainMin != null && this._domainMax != null) {
      this._setDomain([this._domainMin, this._domainMax]);
      return;
    }

    const computedExtent = this._getExtent();

    if (this._domainMin != null) {
      let maxValue = computedExtent[1];
      if (this._domainMin >= maxValue) {
        maxValue = this._expandSingleValueDomain([this._domainMin, this._domainMin])[1];
      }
      this._setDomain([this._domainMin, maxValue]);
      return;
    }

    if (this._domainMax != null) {
      let minValue = computedExtent[0];
      if (this._domainMax <= minValue) {
        minValue = this._expandSingleValueDomain([this._domainMax, this._domainMax])[0];
      }
      this._setDomain([minValue, this._domainMax]);
      return;
    }

    super.autoDomainIfAutomaticMode();
  }

  protected _getUnboundedExtent(ignoreAttachState = false): D[] {
    const includedValues = this._getAllIncludedValues(ignoreAttachState);