@mathstack/viz 2.1.0 → 2.2.0

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

@@ -1,109 +0,0 @@
-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

@@ -1,122 +0,0 @@
-/* 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

@@ -1,79 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,266 +0,0 @@
-/* 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();
-  });
-});