@mathstack/viz 1.1.4 → 2.0.3

package/src/lib/stacked-bars/config/stacked-bars-builder.ts

@@ -0,0 +1,109 @@
+import { Injectable } from '@angular/core';
+import { safeAssign } from '@mathstack/app-kit';
+import { Series, stackOffsetDiverging, stackOrderNone } from 'd3';
+import { VicBarsConfigBuilder } from '../../bars/config/bars-builder';
+import { DataValue } from '../../core/types/values';
+import { StackedBarsConfig } from './stacked-bars-config';
+
+const DEFAULT = {
+  _stackOrder: stackOrderNone,
+  _stackOffset: stackOffsetDiverging,
+};
+
+/**
+ * Builds a configuration object for a StackedBarsComponent.
+ *
+ * Must be added to a providers array in or above the component that consumes it if it is injected via the constructor. (e.g. `providers: [VicStackedBarsBuilder]` in the component decorator)
+ *
+ * The first generic parameter, Datum, is the type of the data that will be used to create the stacked bars.
+ *
+ * The second generic parameter, TOrdinalValue, is the type of the ordinal data that will be used to position the bars.
+ */
+@Injectable()
+export class VicStackedBarsConfigBuilder<
+  Datum,
+  TOrdinalValue extends DataValue,
+> extends VicBarsConfigBuilder<Datum, TOrdinalValue> {
+  private _stackOffset: (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    series: Series<any, any>[],
+    order: Iterable<number>
+  ) => void;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private _stackOrder: (x: any) => any;
+
+  constructor() {
+    super();
+    safeAssign(this, DEFAULT);
+  }
+
+  stackOffset(stackOffset: null): this;
+  stackOffset(
+    stackOffset: (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      series: Series<any, any>[],
+      order: Iterable<number>
+    ) => void
+  ): this;
+  stackOffset(
+    stackOffset:
+      | ((
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          series: Series<any, any>[],
+          order: Iterable<number>
+        ) => void)
+      | null
+  ): this {
+    if (stackOffset === null) {
+      this._stackOffset = DEFAULT._stackOffset;
+      return this;
+    }
+    this._stackOffset = stackOffset;
+    return this;
+  }
+
+  stackOrder(stackOrder: null): this;
+  stackOrder(
+    stackOrder:
+      | ((series: Series<Datum, TOrdinalValue>) => Iterable<number>)
+      | null
+  ): this;
+  stackOrder(
+    stackOrder:
+      | ((
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          series: Series<any, any>
+        ) => Iterable<number>)
+      | null
+  ): this {
+    if (stackOrder === null) {
+      this._stackOrder = DEFAULT._stackOrder;
+      return this;
+    }
+    this._stackOrder = stackOrder;
+    return this;
+  }
+
+  override getConfig(): StackedBarsConfig<Datum, TOrdinalValue> {
+    this.validateBuilder('Stacked Bars');
+    return new StackedBarsConfig(this.dimensions, {
+      marksClass: 'vic-stacked-bars',
+      backgrounds: this.backgroundsBuilder?._build(),
+      color: this.colorDimensionBuilder._build('Color'),
+      customFills: this._customFills,
+      data: this._data,
+      datumClass: this._datumClass,
+      mixBlendMode: this._mixBlendMode,
+      ordinal: this.ordinalDimensionBuilder._build(
+        'band',
+        this.getOrdinalDimensionName()
+      ),
+      quantitative: this.quantitativeDimensionBuilder._build(
+        this.getQuantitativeDimensionName()
+      ),
+      labels: this.labelsBuilder?._build(),
+      stackOffset: this._stackOffset,
+      stackOrder: this._stackOrder,
+    });
+  }
+}

package/src/lib/stacked-bars/config/stacked-bars-config.spec.ts

@@ -0,0 +1,122 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { VicStackedBarsConfigBuilder } from './stacked-bars-builder';
+import { StackedBarsConfig } from './stacked-bars-config';
+
+type Datum = { country: string; value: number; category: string };
+const data = [
+  { country: 'Sweden', value: 1, category: 'a' },
+  { country: 'Finland', value: 2, category: 'a' },
+  { country: 'Norway', value: 3, category: 'a' },
+  { country: 'Iceland', value: 4, category: 'b' },
+  { country: 'Denmark', value: 5, category: 'b' },
+  { country: 'Russia', value: 6, category: 'b' },
+];
+
+function getNewConfig(): StackedBarsConfig<Datum, string> {
+  return new VicStackedBarsConfigBuilder<Datum, string>()
+    .data(data)
+    .horizontal((bars) =>
+      bars
+        .x((dimension) => dimension.valueAccessor((d) => d.value))
+        .y((dimension) => dimension.valueAccessor((d) => d.country))
+    )
+    .color((dimension) => dimension.valueAccessor((d) => d.category))
+    .getConfig();
+}
+describe('StackedBarsConfig', () => {
+  let config: StackedBarsConfig<Datum, string>;
+  beforeEach(() => {
+    config = undefined;
+  });
+
+  describe('initPropertiesFromData()', () => {
+    beforeEach(() => {
+      spyOn(
+        StackedBarsConfig.prototype as any,
+        'setDimensionPropertiesFromData'
+      );
+      spyOn(StackedBarsConfig.prototype as any, 'setValueIndices');
+      spyOn(StackedBarsConfig.prototype as any, 'setHasNegativeValues');
+      spyOn(StackedBarsConfig.prototype as any, 'constructStackedData');
+      spyOn(
+        StackedBarsConfig.prototype as any,
+        'initQuantitativeDomainFromStack'
+      );
+      config = getNewConfig();
+    });
+    it('calls setDimensionPropertiesFromData once', () => {
+      expect(
+        (config as any).setDimensionPropertiesFromData
+      ).toHaveBeenCalledTimes(1);
+    });
+    it('calls setValueIndices once', () => {
+      expect((config as any).setValueIndices).toHaveBeenCalledTimes(1);
+    });
+    it('calls setHasNegativeValues once', () => {
+      expect((config as any).setHasNegativeValues).toHaveBeenCalledTimes(1);
+    });
+    it('calls constructStackedData once', () => {
+      expect((config as any).constructStackedData).toHaveBeenCalledTimes(1);
+    });
+    it('calls initQuantitativeDomainFromStack once', () => {
+      expect(
+        (config as any).initQuantitativeDomainFromStack
+      ).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('setValueIndices()', () => {
+    it('returns an array of indices when ordinal and categorical domains are not specified by user', () => {
+      config = getNewConfig();
+      expect(config.valueIndices).toEqual([0, 1, 2, 3, 4, 5]);
+    });
+    it('returns an array of indices when ordinal domain is limited by user', () => {
+      config = new VicStackedBarsConfigBuilder<Datum, string>()
+        .data(data)
+        .horizontal((bars) =>
+          bars
+            .x((dimension) => dimension.valueAccessor((d) => d.value))
+            .y((dimension) =>
+              dimension
+                .valueAccessor((d) => d.country)
+                .domain(['Sweden', 'Norway', 'Iceland'])
+            )
+        )
+        .color((dimension) => dimension.valueAccessor((d) => d.category))
+        .getConfig();
+      expect(config.valueIndices).toEqual([0, 2, 3]);
+    });
+    it('returns an array of indices when categorical domain is limited by user', () => {
+      config = new VicStackedBarsConfigBuilder<Datum, string>()
+        .data(data)
+        .horizontal((bars) =>
+          bars
+            .x((dimension) => dimension.valueAccessor((d) => d.value))
+            .y((dimension) => dimension.valueAccessor((d) => d.country))
+        )
+        .color((dimension) =>
+          dimension.valueAccessor((d) => d.category).domain(['a'])
+        )
+        .getConfig();
+      expect(config.valueIndices).toEqual([0, 1, 2]);
+    });
+    it('returns an array of indices when both ordinal and categorical domains are limited by user', () => {
+      config = new VicStackedBarsConfigBuilder<Datum, string>()
+        .data(data)
+        .horizontal((bars) =>
+          bars
+            .x((dimension) => dimension.valueAccessor((d) => d.value))
+            .y((dimension) =>
+              dimension
+                .valueAccessor((d) => d.country)
+                .domain(['Sweden', 'Norway', 'Iceland'])
+            )
+        )
+        .color((dimension) =>
+          dimension.valueAccessor((d) => d.category).domain(['a'])
+        )
+        .getConfig();
+      expect(config.valueIndices).toEqual([0, 2]);
+    });
+  });
+});

package/src/lib/stacked-bars/config/stacked-bars-config.ts

@@ -0,0 +1,79 @@
+import { InternMap, Series, extent, range, rollup, stack } from 'd3';
+import { BarsConfig } from '../../bars/config/bars-config';
+import { BarsDimensions } from '../../bars/config/bars-dimensions';
+import { DataValue } from '../../core/types/values';
+import { StackDatum } from '../stacked-bars.component';
+import { StackedBarsOptions } from './stacked-bars-options';
+
+export class StackedBarsConfig<Datum, TOrdinalValue extends DataValue>
+  extends BarsConfig<Datum, TOrdinalValue>
+  implements StackedBarsOptions<Datum, TOrdinalValue>
+{
+  stackOffset: (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    series: Series<any, any>[],
+    order: Iterable<number>
+  ) => void;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  stackOrder: (x: any) => any;
+  stackedData: StackDatum[][];
+
+  constructor(
+    dimensions: BarsDimensions,
+    options: StackedBarsOptions<Datum, TOrdinalValue>
+  ) {
+    super(dimensions, options);
+  }
+
+  override initPropertiesFromData(): void {
+    // parent class will call this method during this class's super call
+    // if statement ensures that code in this method is only called at the end of this class's constructor
+    if (this.stackOffset !== undefined && this.stackOrder !== undefined) {
+      this.setDimensionPropertiesFromData();
+      this.setValueIndices();
+      this.setHasNegativeValues();
+      this.constructStackedData();
+      this.initQuantitativeDomainFromStack();
+    }
+  }
+
+  override setValueIndices(): void {
+    this.valueIndices = range(this.ordinal.values.length).filter((i) => {
+      return (
+        this.ordinal.domainIncludes(this.ordinal.values[i]) &&
+        this.color.domainIncludes(this.color.values[i])
+      );
+    });
+  }
+
+  constructStackedData(): void {
+    const stackedData = stack<[unknown, InternMap<string, number>]>()
+      .keys(this.color.calculatedDomain)
+      .value((d, key) => {
+        return this.quantitative.values[d[1].get(key)];
+      })
+      .order(this.stackOrder)
+      .offset(this.stackOffset)(
+      rollup(
+        this.valueIndices,
+        ([i]) => i,
+        (i) => this.ordinal.values[i],
+        (i) => this.color.values[i]
+      )
+    );
+
+    this.stackedData = stackedData.map((series) =>
+      series.map((d) => {
+        Object.assign(d, {
+          i: d.data[1].get(series.key),
+        });
+        return d as unknown as StackDatum;
+      })
+    );
+  }
+
+  initQuantitativeDomainFromStack(): void {
+    const extents = extent(this.stackedData.flat(2));
+    this.quantitative.setDomain(extents);
+  }
+}

package/src/lib/stacked-bars/config/stacked-bars-options.ts

@@ -0,0 +1,16 @@
+import { Series } from 'd3';
+import { BarsOptions } from '../../bars/config/bars-options';
+import { DataValue } from '../../core/types/values';
+
+export interface StackedBarsOptions<
+  Datum,
+  TOrdinalValue extends DataValue,
+> extends BarsOptions<Datum, TOrdinalValue> {
+  stackOffset: (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    series: Series<any, any>[],
+    order: Iterable<number>
+  ) => void;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  stackOrder: (x: any) => any;
+}

package/src/lib/stacked-bars/events/actions/stacked-bars-click-actions.ts

@@ -0,0 +1,23 @@
+import { BarsInteractionOutput } from '../../../bars';
+import { DataValue } from '../../../core/types/values';
+import { EventAction, EventType } from '../../../events';
+import { StackedBarsHost } from '../stacked-bars-events.directive';
+
+export class StackedBarsClickEmitTooltipDataPauseOtherActions<
+  Datum,
+  TOrdinalValue extends DataValue,
+> implements EventAction<
+  StackedBarsHost<Datum, TOrdinalValue>,
+  BarsInteractionOutput<Datum>
+> {
+  onStart(host: StackedBarsHost<Datum, TOrdinalValue>) {
+    const outputData = host.getInteractionOutput(EventType.Click);
+    host.disableOtherActions(EventType.Click);
+    host.emitInteractionOutput(outputData);
+  }
+
+  onEnd(host: StackedBarsHost<Datum, TOrdinalValue>) {
+    host.resumeOtherActions(EventType.Click);
+    host.emitInteractionOutput(null);
+  }
+}

package/src/lib/stacked-bars/events/actions/stacked-bars-hover-actions.ts

@@ -0,0 +1,22 @@
+import { BarsInteractionOutput } from '../../../bars';
+import { DataValue } from '../../../core/types/values';
+import { EventAction, EventType } from '../../../events';
+
+import { StackedBarsHost } from '../stacked-bars-events.directive';
+
+export class StackedBarsHoverEmitTooltipData<
+  Datum,
+  TOrdinalValue extends DataValue,
+> implements EventAction<
+  StackedBarsHost<Datum, TOrdinalValue>,
+  BarsInteractionOutput<Datum>
+> {
+  onStart(host: StackedBarsHost<Datum, TOrdinalValue>): void {
+    const tooltipData = host.getInteractionOutput(EventType.Hover);
+    host.emitInteractionOutput(tooltipData);
+  }
+
+  onEnd(host: StackedBarsHost<Datum, TOrdinalValue>): void {
+    host.emitInteractionOutput(null);
+  }
+}

package/src/lib/stacked-bars/events/actions/stacked-bars-hover-move-actions.ts

@@ -0,0 +1,21 @@
+import { BarsInteractionOutput } from '../../../bars';
+import { DataValue } from '../../../core/types/values';
+import { EventType, HoverMoveAction } from '../../../events';
+import { StackedBarsHost } from '../stacked-bars-events.directive';
+
+export class StackedBarsHoverMoveEmitTooltipData<
+  Datum,
+  TOrdinalValue extends DataValue,
+> implements HoverMoveAction<
+  StackedBarsHost<Datum, TOrdinalValue>,
+  BarsInteractionOutput<Datum>
+> {
+  onStart(host: StackedBarsHost<Datum, TOrdinalValue>): void {
+    const tooltipData = host.getInteractionOutput(EventType.HoverMove);
+    host.emitInteractionOutput(tooltipData);
+  }
+
+  onEnd(host: StackedBarsHost<Datum, TOrdinalValue>): void {
+    host.emitInteractionOutput(null);
+  }
+}

package/src/lib/stacked-bars/events/stacked-bars-events.directive.spec.ts

@@ -0,0 +1,266 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { EventEmitter, Renderer2 } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { selectAll } from 'd3';
+import { of } from 'rxjs';
+import { EventType } from '../../events/events.types';
+import { STACKED_BARS } from '../stacked-bars.component';
+import { StackedBarsEventsDirective } from './stacked-bars-events.directive';
+
+describe('StackedBarsEventsDirective', () => {
+  let directive: StackedBarsEventsDirective<any, any, any>;
+  let stackedBarsStub: any;
+  let barElement: any;
+  let stackDatum: any;
+
+  beforeEach(() => {
+    stackDatum = { foo: 'bar' };
+    barElement = {
+      getBoundingClientRect: () => ({ width: 100, height: 50 }),
+      getAttribute: (attr: string) =>
+        attr === 'x' ? '10' : attr === 'y' ? '20' : '0',
+      __data__: stackDatum,
+    };
+    stackedBarsStub = {
+      bars$: of(selectAll([barElement])),
+      getSourceDatumFromStackedBarDatum: jasmine
+        .createSpy('getSourceDatumFromStackedBarDatum')
+        .and.returnValue({ d: 1 }),
+      getTooltipData: jasmine
+        .createSpy('getTooltipData')
+        .and.returnValue({ tooltip: 'data' }),
+    };
+    TestBed.configureTestingModule({
+      providers: [
+        { provide: STACKED_BARS, useValue: stackedBarsStub },
+        Renderer2,
+        StackedBarsEventsDirective,
+      ],
+    });
+    directive = TestBed.inject(StackedBarsEventsDirective);
+    directive.interactionOutput = new EventEmitter();
+    directive.hoverActions = [
+      {
+        onStart: jasmine.createSpy('hoverOnStart'),
+        onEnd: jasmine.createSpy('hoverOnEnd'),
+      },
+    ];
+    directive.hoverMoveActions = [
+      {
+        onStart: jasmine.createSpy('hoverMoveOnStart'),
+        onEnd: jasmine.createSpy('hoverMoveOnEnd'),
+        initialize: jasmine.createSpy('hoverMoveInit'),
+      },
+    ];
+    directive.clickActions = [
+      {
+        onStart: jasmine.createSpy('clickOnStart'),
+        onEnd: jasmine.createSpy('clickOnEnd'),
+      },
+    ];
+    directive.inputEventActions = [
+      {
+        onStart: jasmine.createSpy('inputOnStart'),
+        onEnd: jasmine.createSpy('inputOnEnd'),
+      },
+    ];
+    directive.preventAction = {
+      hover: false,
+      hoverMove: false,
+      click: false,
+      input: false,
+    };
+    (directive as any).events = [];
+    (directive as any).inputEvent$ = of(true);
+  });
+
+  it('should get elements as observable', (done) => {
+    directive.getElements().subscribe((els: any[]) => {
+      expect(els[0]).toBe(barElement);
+      done();
+    });
+  });
+
+  it('should initialize from element', () => {
+    directive.initFromElement(barElement);
+    expect(directive.origin).toBe(barElement);
+    expect(directive.stackDatum).toBe(stackDatum);
+  });
+
+  it('should set positions from element', () => {
+    directive.origin = barElement;
+    directive.setPositionsFromElement();
+    expect(directive.positionX).toBe(50);
+    expect(directive.positionY).toBe(25);
+  });
+
+  it('should set positions from pointer', () => {
+    directive.origin = barElement;
+    (directive as any).setPositionsFromPointer({
+      clientX: 15,
+      clientY: 25,
+      target: barElement,
+      pageX: 15,
+      pageY: 25,
+    });
+    expect(directive.positionX).toBe(5);
+    expect(directive.positionY).toBe(5);
+  });
+
+  it('should emit interaction output', (done) => {
+    const output = {
+      origin: barElement,
+      positionX: 1,
+      positionY: 2,
+      type: EventType.Hover,
+      stackDatum,
+      sourceDatum: { d: 1 },
+      tooltip: 'data',
+      datum: { foo: 'datum' },
+      color: 'red',
+      values: { x: 1, y: 2, category: 'foo' },
+    };
+    directive.interactionOutput.subscribe((val: any) => {
+      expect(val).toEqual(output);
+      done();
+    });
+    directive.emitInteractionOutput(output as any);
+  });
+
+  it('should handle onEnter for hover', () => {
+    spyOn(directive as any, 'isEventAllowed').and.callFake(
+      (type) => type === EventType.Hover
+    );
+    spyOn(directive as any, 'setPositionsFromElement');
+    spyOn(directive as any, 'runActions');
+    directive.onEnter({} as any, barElement);
+    expect((directive as any).setPositionsFromElement).toHaveBeenCalled();
+    expect((directive as any).runActions).toHaveBeenCalledWith(
+      directive.hoverActions,
+      jasmine.any(Function)
+    );
+  });
+
+  it('should handle onEnter for hoverMove', () => {
+    spyOn(directive as any, 'isEventAllowed').and.callFake(
+      (type) => type === EventType.HoverMove
+    );
+    spyOn(directive as any, 'runActions');
+    directive.onEnter({} as any, barElement);
+    expect((directive as any).runActions).toHaveBeenCalledWith(
+      directive.hoverMoveActions,
+      jasmine.any(Function)
+    );
+  });
+
+  it('should handle onMove', () => {
+    spyOn(directive as any, 'isEventAllowed').and.returnValue(true);
+    spyOn(directive as any, 'setPositionsFromPointer');
+    directive.onMove({} as any, barElement);
+    expect((directive as any).setPositionsFromPointer).toHaveBeenCalled();
+    expect(directive.hoverMoveActions[0].onStart).toHaveBeenCalled();
+  });
+
+  it('should handle onLeave for hover', () => {
+    spyOn(directive as any, 'isEventAllowed').and.callFake(
+      (type) => type === EventType.Hover
+    );
+    spyOn(directive as any, 'resetDirective');
+    directive.onLeave({} as any, barElement);
+    expect(directive.hoverActions[0].onEnd).toHaveBeenCalled();
+    expect((directive as any).resetDirective).toHaveBeenCalled();
+  });
+
+  it('should handle onLeave for hoverMove', () => {
+    spyOn(directive as any, 'isEventAllowed').and.callFake(
+      (type) => type === EventType.HoverMove
+    );
+    spyOn(directive as any, 'resetDirective');
+    directive.onLeave({} as any, barElement);
+    expect(directive.hoverMoveActions[0].onEnd).toHaveBeenCalled();
+    expect((directive as any).resetDirective).toHaveBeenCalled();
+  });
+
+  it('should handle onClick when click is allowed and hover event exists', () => {
+    spyOn(directive as any, 'hasEvent').and.returnValue(true);
+    spyOn(directive as any, 'setPositionsFromElement');
+    spyOn(directive as any, 'runActions');
+    directive.onClick({} as any, barElement);
+    expect((directive as any).setPositionsFromElement).toHaveBeenCalled();
+    expect((directive as any).runActions).toHaveBeenCalledWith(
+      directive.clickActions,
+      jasmine.any(Function)
+    );
+  });
+
+  it('should handle onClick when click is allowed and hover event does not exist', () => {
+    spyOn(directive as any, 'hasEvent').and.returnValue(false);
+    spyOn(directive as any, 'setPositionsFromPointer');
+    spyOn(directive as any, 'runActions');
+    directive.onClick({} as any, barElement);
+    expect((directive as any).setPositionsFromPointer).toHaveBeenCalled();
+    expect((directive as any).runActions).toHaveBeenCalledWith(
+      directive.clickActions,
+      jasmine.any(Function)
+    );
+  });
+
+  it('should handle onClickRemove', () => {
+    spyOn(directive as any, 'runActions');
+    spyOn(directive as any, 'resetDirective');
+    directive.onClickRemove();
+    expect((directive as any).runActions).toHaveBeenCalledWith(
+      directive.clickActions,
+      jasmine.any(Function)
+    );
+    expect((directive as any).resetDirective).toHaveBeenCalled();
+  });
+
+  it('should handle onInputEvent with value', () => {
+    spyOn(directive as any, 'isEventAllowed').and.returnValue(true);
+    directive.onInputEvent('foo');
+    expect(directive.inputEventActions[0].onStart).toHaveBeenCalledWith(
+      directive,
+      'foo'
+    );
+  });
+
+  it('should handle onInputEvent with null', () => {
+    spyOn(directive as any, 'isEventAllowed').and.returnValue(true);
+    directive.onInputEvent(null);
+    expect(directive.inputEventActions[0].onEnd).toHaveBeenCalledWith(
+      directive,
+      null
+    );
+  });
+
+  it('should getStackDatum', () => {
+    directive.stackDatum = stackDatum;
+    expect(directive.getStackDatum()).toBe(stackDatum);
+    directive.stackDatum = null;
+    expect(directive.getStackDatum()).toBeNull();
+  });
+
+  it('should getInteractionOutput', () => {
+    directive.origin = barElement;
+    directive.positionX = 1;
+    directive.positionY = 2;
+    directive.stackDatum = stackDatum;
+    const output = directive.getInteractionOutput(EventType.Hover);
+    expect(output).toEqual(
+      jasmine.objectContaining({
+        tooltip: 'data',
+        origin: barElement,
+        anchor: {
+          x: 1,
+          y: 2,
+        },
+        type: EventType.Hover,
+      })
+    );
+    expect(
+      stackedBarsStub.getSourceDatumFromStackedBarDatum
+    ).toHaveBeenCalledWith(stackDatum);
+    expect(stackedBarsStub.getTooltipData).toHaveBeenCalled();
+  });
+});