@cdc/chart 4.26.7 → 4.26.10

package/src/helpers/tests/getColorScale.test.ts

@@ -1,6 +1,14 @@
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import { getColorScale } from '../getColorScale'
 import { ChartConfig } from '../../types/ChartConfig'
+import { colorPalettesChartV2 } from '@cdc/core/data/colorPalettes'
+import {
+  colorblindColorDistribution,
+  chartV21ColorDistribution,
+  divergentColorDistribution,
+  qualitativeStandardColorDistribution,
+  v2ColorDistribution
+} from '@cdc/core/helpers/palettes/colorDistributions'
 
 const buildConfig = (overrides: Partial<ChartConfig> = {}): ChartConfig =>
   ({
@@ -177,6 +185,63 @@ describe('getColorScale series color assignments', () => {
     expect(colorScale('Series C')).toBe('#303030')
   })
 
+  it('fills invalid customColorsOrdered entries with black', () => {
+    const colorScale = getColorScale(
+      buildConfig({
+        general: {
+          palette: {
+            name: 'qualitative_standard',
+            version: '2.0',
+            customColorsOrdered: ['', '#222222', 'whyte']
+          }
+        } as any
+      })
+    )
+
+    expect(colorScale('Series A')).toBe('#000000')
+    expect(colorScale('Series B')).toBe('#222222')
+    expect(colorScale('Series C')).toBe('#000000')
+  })
+
+  it('uses black when saved customColors are all invalid', () => {
+    const colorScale = getColorScale(
+      buildConfig({
+        general: {
+          palette: {
+            name: 'qualitative_standard',
+            version: '2.0',
+            customColors: ['', 'whyte']
+          }
+        } as any
+      })
+    )
+
+    expect(colorScale('Series A')).toBe('#000000')
+    expect(colorScale('Series B')).toBe('#000000')
+    expect(colorScale('Series C')).toBe('#000000')
+  })
+
+  it('uses black when the named palette cannot be resolved', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const colorScale = getColorScale(
+      buildConfig({
+        general: {
+          palette: {
+            name: 'unknown_palette',
+            version: '2.0'
+          }
+        } as any
+      })
+    )
+
+    expect(warn).toHaveBeenCalledWith('Palette "unknown_palette" not found, falling back to black')
+    expect(colorScale('Series A')).toBe('#000000')
+    expect(colorScale('Series B')).toBe('#000000')
+    expect(colorScale('Series C')).toBe('#000000')
+
+    warn.mockRestore()
+  })
+
   it('falls back to the named palette when customColors is empty', () => {
     const colorScale = getColorScale(
       buildConfig({
@@ -195,3 +260,163 @@ describe('getColorScale series color assignments', () => {
     expect(colorScale('Series C')).toBe('#5A8E3F')
   })
 })
+
+const buildDistributionConfig = (
+  numberOfSeries: number,
+  paletteName = 'qualitative_standard',
+  paletteVersion: '2.0' | '2.1' = '2.0',
+  overrides: Partial<ChartConfig> = {}
+) => {
+  const seriesKeys = Array.from({ length: numberOfSeries }, (_, index) => `series_${index + 1}`)
+  const seriesLabelsAll = seriesKeys.map((_, index) => `Series ${index + 1}`)
+
+  return buildConfig({
+    general: {
+      palette: {
+        name: paletteName,
+        version: paletteVersion
+      }
+    } as any,
+    series: seriesKeys.map((dataKey, index) => ({ dataKey, name: seriesLabelsAll[index], type: 'Line' })) as any,
+    runtime: {
+      seriesKeys,
+      seriesLabels: Object.fromEntries(seriesKeys.map((key, index) => [key, seriesLabelsAll[index]])),
+      seriesLabelsAll
+    } as any,
+    ...overrides
+  })
+}
+
+const getScaleColors = (config: ChartConfig) => {
+  const scale = getColorScale(config)
+  return config.runtime.seriesLabelsAll.map(label => scale(label))
+}
+
+describe('getColorScale distribution profiles', () => {
+  it.each(Object.keys(qualitativeStandardColorDistribution).map(Number))(
+    'uses released colorblind colors for %i series with palette version 2.0',
+    count => {
+      const expected = colorblindColorDistribution[count].map(index => colorPalettesChartV2.qualitative_standard[index])
+
+      expect(getScaleColors(buildDistributionConfig(count))).toEqual(expected)
+    }
+  )
+
+  it.each(Object.keys(qualitativeStandardColorDistribution).map(Number))(
+    'uses improved colorblind colors for %i series with palette version 2.1',
+    count => {
+      const expected = qualitativeStandardColorDistribution[count].map(
+        index => colorPalettesChartV2.qualitative_standard[index]
+      )
+
+      expect(getScaleColors(buildDistributionConfig(count, 'qualitative_standard', '2.1'))).toEqual(expected)
+    }
+  )
+
+  it('uses the V2 forward colors in reverse order for a reversed palette', () => {
+    const count = 5
+    const expected = qualitativeStandardColorDistribution[count]
+      .map(index => colorPalettesChartV2.qualitative_standard[index])
+      .reverse()
+
+    expect(getScaleColors(buildDistributionConfig(count, 'qualitative_standardreverse', '2.1'))).toEqual(expected)
+  })
+
+  it('uses the chart 2.1 distribution for a two-series sequential palette', () => {
+    const expected = chartV21ColorDistribution[2].map(index => colorPalettesChartV2.sequential_blue[index])
+
+    expect(getScaleColors(buildDistributionConfig(2, 'sequential_blue', '2.1'))).toEqual(expected)
+  })
+
+  it('preserves the released sequential distribution for palette version 2.0', () => {
+    const expected = v2ColorDistribution[2].map(index => colorPalettesChartV2.sequential_blue[index])
+
+    expect(getScaleColors(buildDistributionConfig(2, 'sequential_blue', '2.0'))).toEqual(expected)
+  })
+
+  it('uses the 2.1 sequential colors in reverse order for a reversed palette', () => {
+    const expected = chartV21ColorDistribution[2].map(index => colorPalettesChartV2.sequential_blue[index]).reverse()
+
+    expect(
+      getScaleColors(
+        buildDistributionConfig(2, 'sequential_bluereverse', '2.1', {
+          general: {
+            palette: {
+              name: 'sequential_bluereverse',
+              version: '2.1',
+              isReversed: true
+            }
+          } as any
+        })
+      )
+    ).toEqual(expected)
+  })
+
+  it('does not change divergent colors between palette versions', () => {
+    const count = 5
+    const expected = divergentColorDistribution[count].map(index => colorPalettesChartV2.divergent_blue_orange[index])
+
+    expect(getScaleColors(buildDistributionConfig(count, 'divergent_blue_orange', '2.0'))).toEqual(expected)
+    expect(getScaleColors(buildDistributionConfig(count, 'divergent_blue_orange', '2.1'))).toEqual(expected)
+  })
+
+  it('bypasses distribution profiles for non-empty custom colors', () => {
+    const customColors = Array.from({ length: 9 }, (_, index) => `#00000${index}`)
+    const config = buildDistributionConfig(5, 'qualitative_standard', '2.1', {
+      general: {
+        palette: {
+          name: 'qualitative_standard',
+          version: '2.1',
+          customColors
+        }
+      } as any
+    })
+
+    expect(getScaleColors(config)).toEqual(customColors.slice(0, 5))
+  })
+
+  it('treats empty custom color arrays as inactive', () => {
+    const config = buildDistributionConfig(3, 'qualitative_standard', '2.1', {
+      general: {
+        palette: {
+          name: 'qualitative_standard',
+          version: '2.1',
+          customColors: [],
+          customColorsOrdered: []
+        }
+      } as any
+    })
+    const expected = qualitativeStandardColorDistribution[3].map(
+      index => colorPalettesChartV2.qualitative_standard[index]
+    )
+
+    expect(getScaleColors(config)).toEqual(expected)
+  })
+
+  it('retains slice and repeat behavior outside the supported item range', () => {
+    const expected = [...colorPalettesChartV2.qualitative_standard, colorPalettesChartV2.qualitative_standard[0]]
+
+    expect(getScaleColors(buildDistributionConfig(10, 'qualitative_standard', '2.1'))).toEqual(expected)
+  })
+
+  it('does not apply the 2.1 distribution to an unsupported chart type', () => {
+    const config = buildDistributionConfig(3, 'qualitative_standard', '2.1', {
+      visualizationType: 'Horizon Chart'
+    })
+    const expected = colorblindColorDistribution[3].map(index => colorPalettesChartV2.qualitative_standard[index])
+
+    expect(getScaleColors(config)).toEqual(expected)
+  })
+
+  it('applies the 2.1 distribution to a color-coded bar chart', () => {
+    const config = buildDistributionConfig(3, 'qualitative_standard', '2.1', {
+      visualizationType: 'Bar',
+      legend: { colorCode: 'category' } as any
+    })
+    const expected = qualitativeStandardColorDistribution[3].map(
+      index => colorPalettesChartV2.qualitative_standard[index]
+    )
+
+    expect(getScaleColors(config)).toEqual(expected)
+  })
+})

package/src/helpers/tests/getDynamicYAxisCategories.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest'
+import { getDynamicYAxisCategories } from '../getDynamicYAxisCategories'
+
+const config = {
+  categories: [
+    { label: 'Very Low', upperBoundKey: 'very_low_max' },
+    { label: 'Low', upperBoundKey: 'low_max' },
+    { label: 'Moderate', upperBoundKey: 'moderate_max' },
+    { label: 'High', upperBoundKey: 'high_max' },
+    { label: 'Very High', upperBoundKey: 'very_high_max' }
+  ]
+}
+
+describe('getDynamicYAxisCategories', () => {
+  it('converts cumulative upper bounds into category heights and uses configured colors', () => {
+    config.categories = config.categories.map((category, index) => ({ ...category, color: `color-${index}` }))
+    const result = getDynamicYAxisCategories({
+      config,
+      data: [{ very_low_max: 12.5, low_max: 16, moderate_max: 18, high_max: 21, very_high_max: 35 }]
+    })
+
+    expect(result).toEqual({
+      axisMax: 35,
+      categories: [
+        { label: 'Very Low', height: '12.5', color: 'color-0' },
+        { label: 'Low', height: '3.5', color: 'color-1' },
+        { label: 'Moderate', height: '2', color: 'color-2' },
+        { label: 'High', height: '3', color: 'color-3' },
+        { label: 'Very High', height: '14', color: 'color-4' }
+      ]
+    })
+  })
+
+  it('returns null for missing, invalid, or non-increasing current-row data', () => {
+    expect(getDynamicYAxisCategories({ config, data: [{ very_low_max: 12 }] })).toBeNull()
+    expect(
+      getDynamicYAxisCategories({
+        config,
+        data: [{ very_low_max: 12, low_max: 10, moderate_max: 18, high_max: 21, very_high_max: 35 }]
+      })
+    ).toBeNull()
+  })
+
+  it('returns null while filtered chart data is temporarily empty', () => {
+    expect(getDynamicYAxisCategories({ config, data: [] })).toBeNull()
+  })
+
+  it('leaves the final category open-ended when it has no upper-bound key', () => {
+    const categories = config.categories.map((category, index) =>
+      index === config.categories.length - 1 ? { ...category, upperBoundKey: undefined } : category
+    )
+
+    const result = getDynamicYAxisCategories({
+      config: { categories },
+      data: [{ very_low_max: 12.5, low_max: 16, moderate_max: 18, high_max: 21 }]
+    })
+
+    expect(result?.axisMax).toBeNull()
+    expect(result?.categories.at(-1)).toEqual({ label: 'Very High', height: '', color: 'color-4' })
+  })
+})

package/src/helpers/tests/getMinMax.test.ts

@@ -155,6 +155,47 @@ describe('getMinMax automatic max strategy', () => {
     expect(result.rightMax).toBe(89)
   })
 
+  it('uses stacked row totals for combo left-axis bar series and keeps right-axis line max independent', () => {
+    const barSeriesA = { dataKey: 'DoseOne', type: 'Bar', axis: 'Left', tooltip: true }
+    const barSeriesB = { dataKey: 'DoseTwo', type: 'Bar', axis: 'Left', tooltip: true }
+    const rightLineSeries = { dataKey: 'Rate', type: 'Line', axis: 'Right', tooltip: true }
+    const data = [
+      { DoseOne: 520, DoseTwo: 80, Rate: 900 },
+      { DoseOne: 0, DoseTwo: 600, Rate: 725 }
+    ]
+    const config = createConfig({
+      visualizationType: 'Combo',
+      visualizationSubType: 'stacked',
+      series: [barSeriesA, barSeriesB, rightLineSeries],
+      runtime: {
+        ...createConfig().runtime,
+        yAxis: {
+          ...createConfig().runtime.yAxis,
+          min: '',
+          max: ''
+        },
+        series: [barSeriesA, barSeriesB, rightLineSeries],
+        seriesKeys: ['DoseOne', 'DoseTwo', 'Rate'],
+        barSeriesKeys: ['DoseOne', 'DoseTwo'],
+        lineSeriesKeys: ['Rate']
+      } as any
+    })
+
+    const result = getMinMax({
+      config,
+      minValue: 0,
+      maxValue: 900,
+      existPositiveValue: true,
+      data,
+      tableData: data,
+      isAllLine: false
+    })
+
+    expect(result.leftMax).toBe(600)
+    expect(result.leftMax).not.toBe(1120)
+    expect(result.rightMax).toBe(900)
+  })
+
   it('forces a zero min for line charts when boundary suppression is present', () => {
     const config = createConfig({
       visualizationType: 'Line',

package/src/helpers/tests/getStackedSeriesMax.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest'
+import getStackedSeriesMax from '../getStackedSeriesMax'
+
+describe('getStackedSeriesMax', () => {
+  it('uses the tallest row sum instead of summing independent series maxima', () => {
+    const data = [
+      { apples: 400, oranges: 10 },
+      { apples: 50, oranges: 300 }
+    ]
+
+    expect(getStackedSeriesMax(data, ['apples', 'oranges'])).toBe(410)
+  })
+
+  it('accepts series objects and dynamic category original data keys', () => {
+    const data = [
+      { apples: 125, oranges: 75, dynamicFruit: 999 },
+      { apples: 10, oranges: 50, dynamicFruit: 999 }
+    ]
+    const series = [
+      { dataKey: 'apples' },
+      { dataKey: 'dynamicFruit', originalDataKey: 'oranges', dynamicCategory: true }
+    ]
+
+    expect(getStackedSeriesMax(data, series)).toBe(200)
+  })
+})

package/src/helpers/tests/handleRankByValue.test.ts

@@ -1,37 +1,55 @@
-import { handleRankByValue } from '../handleRankByValue'
-import { ChartConfig } from '../../types/ChartConfig'
-
-describe('handleRankByValue', () => {
-  it('should sort the data in ascending order when rankByValue is "asc"', () => {
-    const data = [{ value: 3 }, { value: 1 }, { value: 2 }]
-    const config: ChartConfig = {
-      rankByValue: 'asc',
-      series: [{ dataKey: 'value' }]
-    }
-
-    const result = handleRankByValue(data, config)
-    expect(result).toEqual([{ value: 1 }, { value: 2 }, { value: 3 }])
-  })
-
-  it('should sort the data in descending order when rankByValue is "desc"', () => {
-    const data = [{ value: 3 }, { value: 1 }, { value: 2 }]
-    const config: ChartConfig = {
-      rankByValue: 'desc',
-      series: [{ dataKey: 'value' }]
-    }
-
-    const result = handleRankByValue(data, config)
-    expect(result).toEqual([{ value: 3 }, { value: 2 }, { value: 1 }])
-  })
-
-  it('should handle numeric strings correctly', () => {
-    const data = [{ value: '3' }, { value: '1' }, { value: '2' }]
-    const config: ChartConfig = {
-      rankByValue: 'asc',
-      series: [{ dataKey: 'value' }]
-    }
-
-    const result = handleRankByValue(data, config)
-    expect(result).toEqual([{ value: '1' }, { value: '2' }, { value: '3' }])
-  })
-})
+import { handleRankByValue } from '../handleRankByValue'
+import { ChartConfig } from '../../types/ChartConfig'
+
+describe('handleRankByValue', () => {
+  it('should sort the data in ascending order when rankByValue is "asc"', () => {
+    const data = [{ value: 3 }, { value: 1 }, { value: 2 }]
+    const originalData = [...data]
+    const config: ChartConfig = {
+      rankByValue: 'asc',
+      series: [{ dataKey: 'value' }]
+    }
+
+    const result = handleRankByValue(data, config)
+    expect(result).toEqual([{ value: 1 }, { value: 2 }, { value: 3 }])
+    expect(result).not.toBe(data)
+    expect(data).toEqual(originalData)
+  })
+
+  it('should sort the data in descending order when rankByValue is "desc"', () => {
+    const data = [{ value: 3 }, { value: 1 }, { value: 2 }]
+    const originalData = [...data]
+    const config: ChartConfig = {
+      rankByValue: 'desc',
+      series: [{ dataKey: 'value' }]
+    }
+
+    const result = handleRankByValue(data, config)
+    expect(result).toEqual([{ value: 3 }, { value: 2 }, { value: 1 }])
+    expect(result).not.toBe(data)
+    expect(data).toEqual(originalData)
+  })
+
+  it('should handle numeric strings correctly', () => {
+    const data = [{ value: '3' }, { value: '1' }, { value: '2' }]
+    const config: ChartConfig = {
+      rankByValue: 'asc',
+      series: [{ dataKey: 'value' }]
+    }
+
+    const result = handleRankByValue(data, config)
+    expect(result).toEqual([{ value: '1' }, { value: '2' }, { value: '3' }])
+  })
+
+  it('should return the original data reference when rankByValue is not set', () => {
+    const data = [{ value: 3 }, { value: 1 }, { value: 2 }]
+    const config: ChartConfig = {
+      rankByValue: undefined,
+      series: [{ dataKey: 'value' }]
+    }
+
+    const result = handleRankByValue(data, config)
+    expect(result).toBe(data)
+    expect(result).toEqual([{ value: 3 }, { value: 1 }, { value: 2 }])
+  })
+})

package/src/helpers/tests/seriesColumnSettings.test.ts

@@ -1,6 +1,7 @@
 import {
   createDefaultSeriesColumnConfig,
   findColumnConfigByName,
+  getAdditionalColumnFormattingParams,
   getSeriesColumnConfig,
   getSeriesColumnFormattingParams,
   getSeriesOwnedColumnNames,
@@ -155,4 +156,26 @@ describe('seriesColumnSettings', () => {
   it('returns undefined when no formatting overrides were explicitly configured', () => {
     expect(getSeriesColumnFormattingParams({ label: 'Cases' })).toBeUndefined()
   })
+
+  it('blocks global prefix and suffix fallback for additional columns', () => {
+    expect(getAdditionalColumnFormattingParams({ label: 'Count' })).toEqual({
+      addColPrefix: '',
+      addColSuffix: ''
+    })
+  })
+
+  it('preserves explicit additional column formatting while blocking missing affixes', () => {
+    expect(
+      getAdditionalColumnFormattingParams({
+        prefix: '$',
+        roundToPlace: 0,
+        commas: false
+      })
+    ).toEqual({
+      addColPrefix: '$',
+      addColSuffix: '',
+      addColRoundTo: 0,
+      addColCommas: false
+    })
+  })
 })

package/src/helpers/tests/smallMultiplesHelpers.test.ts

@@ -1,6 +1,6 @@
 import { scaleOrdinal } from '@visx/scale'
 import { describe, expect, it } from 'vitest'
-import { createTileColorScale } from '../smallMultiplesHelpers'
+import { applyTileOrder, createTileColorScale, getTileKeys } from '../smallMultiplesHelpers'
 import { ChartConfig } from '../../types/ChartConfig'
 
 const buildConfig = (overrides: Partial<ChartConfig> = {}): ChartConfig =>
@@ -97,3 +97,39 @@ describe('smallMultiplesHelpers createTileColorScale', () => {
     expect(tileScale('Series B')).toBe('#aa0000')
   })
 })
+
+describe('smallMultiplesHelpers tile ordering', () => {
+  it('sorts by-column tile keys in numeric-aware order', () => {
+    const config = buildConfig({
+      smallMultiples: {
+        mode: 'by-column',
+        tileColumn: 'Week'
+      }
+    })
+    const data = [{ Week: '10' }, { Week: '2' }, { Week: '1' }, { Week: '20' }, { Week: '3' }, { Week: null }]
+
+    expect(getTileKeys(config, data)).toEqual(['1', '2', '3', '10', '20'])
+  })
+
+  it('uses numeric-aware order when sorting tile display titles', () => {
+    const config = buildConfig({
+      smallMultiples: {
+        mode: 'by-column',
+        tileColumn: 'Week',
+        tileTitles: {
+          '1': 'Week 1',
+          '2': 'Week 2',
+          '10': 'Week 10'
+        }
+      }
+    })
+    const tileItems = [
+      { mode: 'by-column', tileValue: '10', key: '10' },
+      { mode: 'by-column', tileValue: '2', key: '2' },
+      { mode: 'by-column', tileValue: '1', key: '1' }
+    ]
+
+    expect(applyTileOrder(tileItems, 'asc', [], config).map(item => item.tileValue)).toEqual(['1', '2', '10'])
+    expect(applyTileOrder(tileItems, 'desc', [], config).map(item => item.tileValue)).toEqual(['10', '2', '1'])
+  })
+})

package/src/helpers/tests/tooltipHelpers.test.ts

@@ -4,6 +4,7 @@ import {
   getTooltipMarkerColor,
   getTooltipMarkerShape,
   shouldUseTooltipLegendMarkers,
+  shouldShowTooltipSeriesRow,
   tooltipHasMarkerColumn,
   tooltipShouldUseMarkerColumn,
   type TooltipRow
@@ -148,4 +149,83 @@ describe('tooltipHelpers', () => {
     expect(ambiguousMarkers).not.toContain('tooltip-body--marker-layout')
     expect(ambiguousMarkers).not.toContain('tooltip-marker-slot')
   })
+
+  it('shows normal tooltip series rows by default when isolate has no legend selection', () => {
+    expect(
+      shouldShowTooltipSeriesRow({
+        legendBehavior: 'isolate',
+        seriesHighlight: [],
+        seriesKey: 'cases'
+      })
+    ).toBe(true)
+    expect(
+      shouldShowTooltipSeriesRow({
+        seriesKey: 'deaths'
+      })
+    ).toBe(true)
+  })
+
+  it('limits normal tooltip series rows to one isolated legend selection', () => {
+    expect(
+      shouldShowTooltipSeriesRow({
+        legendBehavior: 'isolate',
+        seriesHighlight: ['cases'],
+        seriesKey: 'cases'
+      })
+    ).toBe(true)
+    expect(
+      shouldShowTooltipSeriesRow({
+        legendBehavior: 'isolate',
+        seriesHighlight: ['cases'],
+        seriesKey: 'deaths'
+      })
+    ).toBe(false)
+  })
+
+  it('limits normal tooltip series rows to multiple isolated legend selections', () => {
+    expect(
+      shouldShowTooltipSeriesRow({
+        legendBehavior: 'isolate',
+        seriesHighlight: ['cases', 'hospitalizations'],
+        seriesKey: 'hospitalizations'
+      })
+    ).toBe(true)
+    expect(
+      shouldShowTooltipSeriesRow({
+        legendBehavior: 'isolate',
+        seriesHighlight: ['cases', 'hospitalizations'],
+        seriesKey: 'deaths'
+      })
+    ).toBe(false)
+  })
+
+  it('keeps all normal tooltip series rows visible in highlight mode with selected series', () => {
+    expect(
+      shouldShowTooltipSeriesRow({
+        legendBehavior: 'highlight',
+        seriesHighlight: ['cases'],
+        seriesKey: 'deaths'
+      })
+    ).toBe(true)
+  })
+
+  it('can filter normal tooltip rows while preserving headings and additional columns', () => {
+    const rows: TooltipRow[] = [
+      { key: 'Date', value: '2024-01-01', kind: 'heading' },
+      { key: 'Cases', value: '10', kind: 'series', seriesKey: 'cases' },
+      { key: 'Deaths', value: '2', kind: 'series', seriesKey: 'deaths' },
+      { key: 'Source', value: 'CDC', kind: 'extra' }
+    ]
+    const filteredRows = rows.filter(
+      row =>
+        row.kind !== 'series' ||
+        shouldShowTooltipSeriesRow({
+          legendBehavior: 'isolate',
+          seriesHighlight: ['cases'],
+          seriesKey: row.seriesKey
+        })
+    )
+
+    expect(filteredRows.map(row => row.key)).toEqual(['Date', 'Cases', 'Source'])
+  })
 })

package/src/helpers/tooltipHelpers.ts

@@ -84,6 +84,22 @@ export const getTooltipSeriesMarker = (
 
 export const buildTooltipRow = (row: TooltipRow): TooltipRow => row
 
+export const shouldShowTooltipSeriesRow = ({
+  legendBehavior,
+  seriesHighlight = [],
+  seriesKey
+}: {
+  legendBehavior?: string
+  seriesHighlight?: string[]
+  seriesKey?: string
+}): boolean => {
+  if (legendBehavior === 'isolate' && seriesHighlight.length > 0 && seriesKey) {
+    return seriesHighlight.includes(seriesKey)
+  }
+
+  return true
+}
+
 const getMarkerSignature = ({
   markerColor,
   markerShape = 'circle'