@mathstack/viz 1.1.4 → 2.0.3

package/{lib/data-dimensions/continuous-quantitative/number-chart-position/domain-padding/round-to-interval/round-to-interval-options.d.ts → src/lib/data-dimensions/continuous-quantitative/number-chart-position/domain-padding/round-to-interval/round-to-interval-options.ts}

@@ -1,3 +1,3 @@
-export interface RoundUpToIntervalDomainPaddingOptions {
-    interval: (maxValue: number) => number;
-}
+export interface RoundUpToIntervalDomainPaddingOptions {
+  interval: (maxValue: number) => number;
+}

package/src/lib/data-dimensions/continuous-quantitative/number-chart-position/domain-padding/round-to-interval/round-to-interval.ts

@@ -0,0 +1,27 @@
+import { safeAssign } from '@mathstack/app-kit';
+import { ValueUtilities } from '../../../../../core/utilities/values';
+import {
+  DomainPadding,
+  DomainPaddingType,
+  PaddedDomainArguments,
+} from '../domain-padding';
+import { RoundUpToIntervalDomainPaddingOptions } from './round-to-interval-options';
+
+export class RoundUpToIntervalDomainPadding extends DomainPadding {
+  readonly type: DomainPaddingType.roundInterval;
+  readonly interval: (maxValue: number) => number;
+
+  constructor(options: RoundUpToIntervalDomainPaddingOptions) {
+    super();
+    safeAssign(this, options);
+    this.type = DomainPaddingType.roundInterval;
+  }
+
+  getPaddedValue(args: PaddedDomainArguments): number {
+    return ValueUtilities.getValueRoundedToInterval(
+      args.value,
+      this.interval(args.value),
+      args.valueType
+    );
+  }
+}

package/{lib/data-dimensions/continuous-quantitative/number-chart-position/domain-padding/round-to-sig-fig/round-to-sig-fig-options.d.ts → src/lib/data-dimensions/continuous-quantitative/number-chart-position/domain-padding/round-to-sig-fig/round-to-sig-fig-options.ts}

@@ -1,3 +1,3 @@
-export interface RoundUpToSigFigDomainPaddingOptions {
-    sigFigures: (d: number) => number;
-}
+export interface RoundUpToSigFigDomainPaddingOptions {
+  sigFigures: (d: number) => number;
+}

package/src/lib/data-dimensions/continuous-quantitative/number-chart-position/domain-padding/round-to-sig-fig/round-to-sig-fig.ts

@@ -0,0 +1,30 @@
+import { safeAssign } from '@mathstack/app-kit';
+import { ValueUtilities } from '../../../../../core/utilities/values';
+import {
+  DomainPadding,
+  DomainPaddingType,
+  PaddedDomainArguments,
+} from '../domain-padding';
+import { RoundUpToSigFigDomainPaddingOptions } from './round-to-sig-fig-options';
+
+export class RoundUpToSigFigDomainPadding
+  extends DomainPadding
+  implements RoundUpToSigFigDomainPaddingOptions
+{
+  readonly sigFigures: (d: number) => number;
+  readonly type: DomainPaddingType.roundUp;
+
+  constructor(options: RoundUpToSigFigDomainPaddingOptions) {
+    super();
+    safeAssign(this, options);
+    this.type = DomainPaddingType.roundUp;
+  }
+
+  getPaddedValue(args: PaddedDomainArguments): number {
+    return ValueUtilities.getValueRoundedToNSignificantFigures(
+      args.value,
+      this.sigFigures(args.value),
+      args.valueType
+    );
+  }
+}

package/src/lib/data-dimensions/continuous-quantitative/number-chart-position/number-chart-position-builder.ts

@@ -0,0 +1,183 @@
+import { safeAssign } from '@mathstack/app-kit';
+import { ScaleContinuousNumeric, scaleLinear } from 'd3';
+import { DataDimensionBuilder } from '../../dimension-builder';
+import { ConcreteDomainPadding } from './domain-padding/concrete-domain-padding';
+import { PercentOverDomainPadding } from './domain-padding/percent-over/percent-over';
+import { PixelDomainPadding } from './domain-padding/pixel/pixel';
+import { RoundUpToIntervalDomainPadding } from './domain-padding/round-to-interval/round-to-interval';
+import { RoundUpToSigFigDomainPadding } from './domain-padding/round-to-sig-fig/round-to-sig-fig';
+import { NumberChartPositionDimension } from './number-chart-position';
+
+const DEFAULT = {
+  _includeZeroInDomain: true,
+  _scaleFn: scaleLinear,
+};
+
+const DEFAULT_PADDING = {
+  pixels: 40,
+  percentOver: 0.1,
+  roundInterval: () => 1,
+  roundUp: () => 1,
+};
+
+export class NumberChartPositionDimensionBuilder<
+  Datum,
+> extends DataDimensionBuilder<Datum, number> {
+  private _domain: [number, number];
+  private _formatSpecifier: string;
+  private _includeZeroInDomain: boolean;
+  private _domainPadding: ConcreteDomainPadding;
+  private _scaleFn: (
+    domain?: Iterable<number>,
+    range?: Iterable<number>
+  ) => ScaleContinuousNumeric<number, number>;
+
+  constructor() {
+    super();
+    safeAssign(this, DEFAULT);
+  }
+
+  /**
+   * OPTIONAL. Sets the domain of the scale.
+   *
+   * Should be in the form of [min, max].
+   *
+   * If not provided, the domain will be determined by the data.
+   */
+  domain(domain: [number, number]): this;
+  domain(domain: null): this;
+  domain(domain: [number, number] | null): this {
+    if (domain === null) {
+      this._domain = undefined;
+      return this;
+    }
+    this._domain = domain;
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Sets a format specifier that will be applied to the value of this dimension for display purposes.
+   */
+  formatSpecifier(formatSpecifier: string): this;
+  formatSpecifier(formatSpecifier: null): this;
+  formatSpecifier(formatSpecifier: string | null): this {
+    if (formatSpecifier === null) {
+      this._formatSpecifier = undefined;
+      return this;
+    }
+    this._formatSpecifier = formatSpecifier;
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Sets a boolean that indicates whether the domain of the dimension's scale should include zero.
+   *
+   * @default true
+   */
+  includeZeroInDomain(includeZeroInDomain: boolean): this {
+    this._includeZeroInDomain = includeZeroInDomain;
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Adds additional space between data values and the edge of a chart by increasing the max value of the quantitative domain.
+   *
+   * For example, if the domain is [0, 100] and the percent is 0.1, the new domain will be [0, 110].
+   *
+   * @default 0.1
+   */
+  domainPaddingPercentOver(
+    percentOver: number = DEFAULT_PADDING.percentOver
+  ): this {
+    this._domainPadding = new PercentOverDomainPadding({
+      percentOver,
+    });
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Adds additional space between data values and the edge of a chart by increasing the max value of the quantitative domain so that it exceeds its original value by the specified number of pixels.
+   *
+   * @default 40
+   */
+  domainPaddingPixels(numPixels: number = DEFAULT_PADDING.pixels): this {
+    this._domainPadding = new PixelDomainPadding({ numPixels });
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Adds additional space between data values and the edge of a chart by increasing the max value to a number that is rounded up to the specified interval.
+   *
+   * @default () => 1
+   */
+  domainPaddingRoundUpToInterval(
+    interval: (d: number) => number = DEFAULT_PADDING.roundInterval
+  ): this {
+    this._domainPadding = new RoundUpToIntervalDomainPadding({
+      interval,
+    });
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Adds additional space between data values and the edge of a chart by increasing the max value to a number that is rounded up to the specified number of significant figures.
+   *
+   * @default () => 1
+   */
+  domainPaddingRoundUpToSigFig(
+    sigFigures: (d: number) => number = DEFAULT_PADDING.roundUp
+  ): this {
+    this._domainPadding = new RoundUpToSigFigDomainPadding({
+      sigFigures,
+    });
+    return this;
+  }
+
+  /**
+   * OPTIONAL. This is a D3 scale function that maps values from the dimension's domain to the dimension's range.
+   *
+   * @default d3.scaleLinear
+   */
+  scaleFn(scaleFn: null): this;
+  scaleFn(
+    scaleFn: (
+      domain?: Iterable<number>,
+      range?: Iterable<number>
+    ) => ScaleContinuousNumeric<number, number>
+  ): this;
+  scaleFn(
+    scaleFn: (
+      domain?: Iterable<number>,
+      range?: Iterable<number>
+    ) => ScaleContinuousNumeric<number, number>
+  ): this {
+    if (scaleFn === null) {
+      this._scaleFn = undefined;
+      return this;
+    }
+    this._scaleFn = scaleFn;
+    return this;
+  }
+
+  /**
+   * @internal This method is not intended to be used by consumers of this library.
+   *
+   * @param dimensionName A user-intelligible name for the dimension being built. Used for error messages. Should be title cased.
+   */
+  _build(dimensionName: string): NumberChartPositionDimension<Datum> {
+    this.validateBuilder(dimensionName);
+    return new NumberChartPositionDimension({
+      domain: this._domain,
+      formatFunction: this._formatFunction,
+      formatSpecifier: this._formatSpecifier,
+      includeZeroInDomain: this._includeZeroInDomain,
+      domainPadding: this._domainPadding,
+      scaleFn: this._scaleFn,
+      valueAccessor: this._valueAccessor,
+    });
+  }
+
+  private validateBuilder(dimensionName: string): void {
+    this.validateValueAccessor(dimensionName);
+  }
+}

package/{lib/data-dimensions/continuous-quantitative/number-chart-position/number-chart-position-options.d.ts → src/lib/data-dimensions/continuous-quantitative/number-chart-position/number-chart-position-options.ts}

@@ -1,5 +1,8 @@
-import { NumberDimensionOptions } from '../number-dimension/number-dimension-options';
-import { ConcreteDomainPadding } from './domain-padding/concrete-domain-padding';
-export interface NumberChartPositionDimensionOptions<Datum> extends NumberDimensionOptions<Datum, number> {
-    domainPadding?: ConcreteDomainPadding;
-}
+import { NumberDimensionOptions } from '../number-dimension/number-dimension-options';
+import { ConcreteDomainPadding } from './domain-padding/concrete-domain-padding';
+
+export interface NumberChartPositionDimensionOptions<
+  Datum,
+> extends NumberDimensionOptions<Datum, number> {
+  domainPadding?: ConcreteDomainPadding;
+}

package/src/lib/data-dimensions/continuous-quantitative/number-chart-position/number-chart-position.spec.ts

@@ -0,0 +1,28 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { NumberChartPositionDimension } from './number-chart-position';
+import { NumberChartPositionDimensionBuilder } from './number-chart-position-builder';
+
+describe('NumberChartPositionDimension', () => {
+  let dimension: NumberChartPositionDimension<number>;
+  beforeEach(() => {
+    dimension = new NumberChartPositionDimensionBuilder<number>()
+      .valueAccessor((d) => d)
+      ._build('Test');
+  });
+  describe('setPropertiesFromData', () => {
+    beforeEach(() => {
+      spyOn(dimension as any, 'setValues');
+      spyOn(dimension as any, 'setDomain');
+    });
+    it('calls setValues once', () => {
+      dimension.setPropertiesFromData([1, 2, 3, 4, 5]);
+      expect((dimension as any).setValues).toHaveBeenCalledOnceWith([
+        1, 2, 3, 4, 5,
+      ]);
+    });
+    it('calls setDomain once', () => {
+      dimension.setPropertiesFromData([1, 2, 3, 4, 5]);
+      expect((dimension as any).setDomain).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/{lib/data-dimensions/continuous-quantitative/number-chart-position/number-chart-position.d.ts → src/lib/data-dimensions/continuous-quantitative/number-chart-position/number-chart-position.ts}

@@ -1,30 +1,62 @@
-import { ScaleContinuousNumeric } from 'd3';
-import { NumberDimension } from '../number-dimension/number-dimension';
-import { ConcreteDomainPadding } from './domain-padding/concrete-domain-padding';
-import { NumberChartPositionDimensionOptions } from './number-chart-position-options';
-/**
- * A dimension that transforms number values into a position on a chart.
- *
- * This dimension is used for the positional dimensions of a chart, such as x and y. The resultant scale will confirm to the ScaleContinuousNumeric interface from @types/d3. The range of the scale will be a dimension from the chart.
- *
- * The generic is the type of the data that will be passed to the dimension.
- *
- * TESTABLE FUNCTIONALITY
- *
- * - It extracts values for the dimension from data.
- *   - tested in: bars.cy.ts, dots.cy.ts, lines.cy.ts, stacked-bars.cy.ts
- * - It sets the domain of the dimension.
- *   - tested in: bars.cy.ts, dots.cy.ts, lines.cy.ts, stacked-bars.cy.ts
- * - It creates and returns a scale from a range and the a padded domain if domain padding is provided.
- *   - tested in: quantitative-domain-padding.cy.ts
- * - It creates and returns a scale from a range and the regular domain if domain padding is not provided.
- *   - tested in: bars.cy.ts, dots.cy.ts, lines.cy.ts, stacked-bars.cy.ts
- */
-export declare class NumberChartPositionDimension<Datum> extends NumberDimension<Datum> implements NumberChartPositionDimensionOptions<Datum> {
-    readonly domainPadding?: ConcreteDomainPadding;
-    readonly scaleFn: (domain?: Iterable<number>, range?: Iterable<number>) => ScaleContinuousNumeric<number, number>;
-    constructor(options: NumberChartPositionDimensionOptions<Datum>);
-    setPropertiesFromData(data: Datum[]): void;
-    getScaleFromRange(range: [number, number]): ScaleContinuousNumeric<number, number, never>;
-    private getPaddedQuantitativeDomain;
-}
+import { safeAssign } from '@mathstack/app-kit';
+import { ScaleContinuousNumeric } from 'd3';
+import { NumberDimension } from '../number-dimension/number-dimension';
+import { ConcreteDomainPadding } from './domain-padding/concrete-domain-padding';
+import { NumberChartPositionDimensionOptions } from './number-chart-position-options';
+
+/**
+ * A dimension that transforms number values into a position on a chart.
+ *
+ * This dimension is used for the positional dimensions of a chart, such as x and y. The resultant scale will confirm to the ScaleContinuousNumeric interface from @types/d3. The range of the scale will be a dimension from the chart.
+ *
+ * The generic is the type of the data that will be passed to the dimension.
+ *
+ * TESTABLE FUNCTIONALITY
+ *
+ * - It extracts values for the dimension from data.
+ *   - tested in: bars.cy.ts, dots.cy.ts, lines.cy.ts, stacked-bars.cy.ts
+ * - It sets the domain of the dimension.
+ *   - tested in: bars.cy.ts, dots.cy.ts, lines.cy.ts, stacked-bars.cy.ts
+ * - It creates and returns a scale from a range and the a padded domain if domain padding is provided.
+ *   - tested in: quantitative-domain-padding.cy.ts
+ * - It creates and returns a scale from a range and the regular domain if domain padding is not provided.
+ *   - tested in: bars.cy.ts, dots.cy.ts, lines.cy.ts, stacked-bars.cy.ts
+ */
+
+export class NumberChartPositionDimension<Datum>
+  extends NumberDimension<Datum>
+  implements NumberChartPositionDimensionOptions<Datum>
+{
+  readonly domainPadding?: ConcreteDomainPadding;
+  readonly scaleFn: (
+    domain?: Iterable<number>,
+    range?: Iterable<number>
+  ) => ScaleContinuousNumeric<number, number>;
+
+  constructor(options: NumberChartPositionDimensionOptions<Datum>) {
+    super('number');
+    safeAssign(this, options);
+  }
+
+  setPropertiesFromData(data: Datum[]): void {
+    this.setValues(data);
+    this.setDomain();
+  }
+
+  getScaleFromRange(range: [number, number]) {
+    const domain = this.domainPadding
+      ? this.getPaddedQuantitativeDomain(range)
+      : this.calculatedDomain;
+    return this.scaleFn().domain(domain).range(range);
+  }
+
+  private getPaddedQuantitativeDomain(
+    range: [number, number]
+  ): [number, number] {
+    return this.domainPadding.getPaddedDomain(
+      this.calculatedDomain,
+      this.scaleFn,
+      range
+    );
+  }
+}

package/src/lib/data-dimensions/continuous-quantitative/number-dimension/number-dimension-options.ts

@@ -0,0 +1,15 @@
+import { ScaleContinuousNumeric } from 'd3';
+import { DataDimensionOptions } from '../../dimension-options';
+
+export interface NumberDimensionOptions<
+  Datum,
+  Range,
+> extends DataDimensionOptions<Datum, number> {
+  domain: [number, number];
+  formatSpecifier: string;
+  includeZeroInDomain: boolean;
+  scaleFn: (
+    domain?: Iterable<number>,
+    range?: Iterable<Range>
+  ) => ScaleContinuousNumeric<Range, Range>;
+}

package/src/lib/data-dimensions/continuous-quantitative/number-dimension/number-dimension.spec.ts

@@ -0,0 +1,155 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { NumberDimension } from './number-dimension';
+
+class ConcreteNumberDimension<Datum> extends NumberDimension<Datum> {
+  setPropertiesFromData(data: Datum[], ...args: any): void {
+    return;
+  }
+}
+
+describe('NumberDimension', () => {
+  let dimension: ConcreteNumberDimension<number>;
+  beforeEach(() => {
+    dimension = new ConcreteNumberDimension<number>('number');
+  });
+
+  describe('setDomain', () => {
+    let calcSpy: jasmine.Spy;
+    beforeEach(() => {
+      calcSpy = spyOn(dimension as any, 'getCalculatedDomain').and.returnValue([
+        10, 50,
+      ]);
+      spyOn(dimension as any, 'setDomainIncludesZero');
+    });
+    describe('user did not specify domain', () => {
+      beforeEach(() => {
+        dimension.values = [1, 2, 3, 4, 5];
+      });
+      describe('valuesOverride is defined', () => {
+        beforeEach(() => {
+          dimension.setDomain([20, 80]);
+        });
+        it('calls getCalculatedDomain once with correct value', () => {
+          expect(
+            (dimension as any).getCalculatedDomain
+          ).toHaveBeenCalledOnceWith([20, 80]);
+        });
+        it('sets calculatedDomain to the return value of getCalculatedDomain', () => {
+          expect((dimension as any).calculatedDomain).toEqual([10, 50]);
+        });
+        it('calls setDomainIncludesZero once', () => {
+          expect(
+            (dimension as any).setDomainIncludesZero
+          ).toHaveBeenCalledTimes(1);
+        });
+      });
+      describe('valuesOverride is not defined', () => {
+        beforeEach(() => {
+          dimension.setDomain();
+        });
+        it('calls getCalculatedDomain once with correct value', () => {
+          expect(
+            (dimension as any).getCalculatedDomain
+          ).toHaveBeenCalledOnceWith([1, 5]);
+        });
+        it('sets calculatedDomain to the return value of getCalculatedDomain', () => {
+          expect((dimension as any).calculatedDomain).toEqual([10, 50]);
+        });
+        it('calls setDomainIncludesZero once', () => {
+          expect(
+            (dimension as any).setDomainIncludesZero
+          ).toHaveBeenCalledTimes(1);
+        });
+      });
+    });
+    describe('user specified domain', () => {
+      describe('valuesOverride is defined', () => {
+        beforeEach(() => {
+          (dimension as any).domain = [5, 1];
+          dimension.setDomain([20, 80]);
+        });
+        it('calls getCalculatedDomain once with correct value', () => {
+          expect(
+            (dimension as any).getCalculatedDomain
+          ).toHaveBeenCalledOnceWith([5, 1]);
+        });
+        it('sets calculatedDomain to the return value of getCalculatedDomain', () => {
+          expect((dimension as any).calculatedDomain).toEqual([10, 50]);
+        });
+        it('calls setDomainIncludesZero once', () => {
+          expect(
+            (dimension as any).setDomainIncludesZero
+          ).toHaveBeenCalledTimes(1);
+        });
+      });
+      describe('valuesOverride is not defined', () => {
+        beforeEach(() => {
+          (dimension as any).domain = [5, 1];
+          dimension.setDomain();
+        });
+        it('calls getCalculatedDomain once with correct value', () => {
+          expect(
+            (dimension as any).getCalculatedDomain
+          ).toHaveBeenCalledOnceWith([5, 1]);
+        });
+        it('sets calculatedDomain to the return value of getCalculatedDomain', () => {
+          expect((dimension as any).calculatedDomain).toEqual([10, 50]);
+        });
+        it('calls setDomainIncludesZero once', () => {
+          expect(
+            (dimension as any).setDomainIncludesZero
+          ).toHaveBeenCalledTimes(1);
+        });
+      });
+    });
+  });
+
+  describe('getCalculatedDomain', () => {
+    describe('includeZeroInDomain is true', () => {
+      beforeEach(() => {
+        (dimension as any).includeZeroInDomain = true;
+      });
+      it('returns a domain that includes zero, case: both values are positive', () => {
+        const result = (dimension as any).getCalculatedDomain([1, 5]);
+        expect(result).toEqual([0, 5]);
+      });
+      it('returns a domain that includes zero, case: both values are negative', () => {
+        const result = (dimension as any).getCalculatedDomain([-5, -1]);
+        expect(result).toEqual([-5, 0]);
+      });
+      it('returns a domain that includes zero, case: one value is negative and one is positive', () => {
+        const result = (dimension as any).getCalculatedDomain([-5, 5]);
+        expect(result).toEqual([-5, 5]);
+      });
+    });
+    it('returns the input domain if includeZeroInDomain is false', () => {
+      (dimension as any).includeZeroInDomain = false;
+      const result = (dimension as any).getCalculatedDomain([20, 80]);
+      expect(result).toEqual([20, 80]);
+    });
+  });
+
+  describe('setDomainIncludesZero', () => {
+    it('sets domainIncludesZero to true if zero is in the domain', () => {
+      (dimension as any).calculatedDomain = [0, 5];
+      (dimension as any).setDomainIncludesZero();
+      expect((dimension as any).domainIncludesZero).toBeTrue();
+    });
+    it('sets domainIncludesZero to true if zero is in the domain', () => {
+      (dimension as any).calculatedDomain = [-5, 5];
+      (dimension as any).setDomainIncludesZero();
+      expect((dimension as any).domainIncludesZero).toBeTrue();
+    });
+    it('sets domainIncludesZero to true if zero is in the domain', () => {
+      (dimension as any).calculatedDomain = [-5, 0];
+      (dimension as any).setDomainIncludesZero();
+      expect((dimension as any).domainIncludesZero).toBeTrue();
+    });
+    it('sets domainIncludesZero to false if zero is not in the domain', () => {
+      (dimension as any).calculatedDomain = [-5, -1];
+      (dimension as any).setDomainIncludesZero();
+      expect((dimension as any).domainIncludesZero).toBeFalse();
+    });
+  });
+});

package/src/lib/data-dimensions/continuous-quantitative/number-dimension/number-dimension.ts

@@ -0,0 +1,57 @@
+import { max, min } from 'd3';
+import { isNumber } from '../../../core/utilities/type-guards';
+import { DataDimension } from '../../dimension';
+
+/**
+ * An abstract dimension that for dimensions whose input values are numbers. It assumes that the domain is two numbers.
+ *
+ * The generic is the type of the data that will be passed to the dimension.
+ *
+ * TESTABLE FUNCTIONALITY
+ *
+ * - The domain will be the user=provided domain if the user provides a domain.
+ *    - tested in: number-dimension.spec.ts
+ * - The domain will be [min, max] of values if the user does not provide a domain.
+ *    - tested in: number-dimension.spec.ts
+ * - The domain will include 0 if includeZeroInDomain is true.
+ *    - tested in: number-dimension.spec.ts
+ * - domainIncludesZero will be true if 0 is in the domain.
+ *   - tested in: number-dimension.spec.ts
+ */
+export abstract class NumberDimension<Datum> extends DataDimension<
+  Datum,
+  number
+> {
+  protected calculatedDomain: [number, number];
+  readonly domain: [number, number];
+  domainIncludesZero: boolean;
+  readonly formatSpecifier: string;
+  readonly includeZeroInDomain: boolean;
+
+  setDomain(valuesOverride?: [number, number]) {
+    const extents: [number, number] =
+      this.domain === undefined
+        ? valuesOverride || [min(this.values), max(this.values)]
+        : this.domain;
+    this.calculatedDomain = this.getCalculatedDomain(extents);
+    this.setDomainIncludesZero();
+  }
+
+  protected getCalculatedDomain(domain: [number, number]): [number, number] {
+    return this.includeZeroInDomain
+      ? [min([domain[0], 0]), max([domain[1], 0])]
+      : domain;
+  }
+
+  protected setDomainIncludesZero() {
+    this.domainIncludesZero =
+      this.calculatedDomain[0] <= 0 && 0 <= this.calculatedDomain[1];
+  }
+
+  // returns false if data is undefined or null or not a number
+  // for some charts this may be fine
+  // original intended use case: d3Line can only handle defined values
+  isValidValue(x: unknown): boolean {
+    return isNumber(x);
+  }
+}