@cdc/chart 4.26.6 → 4.26.10

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

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest'
+
+import { getBoxPlotConfig } from '../getBoxPlotConfig'
+import { ChartConfig } from '../../types/ChartConfig'
+
+const createBoxPlotConfig = (): ChartConfig =>
+  ({
+    xAxis: {
+      dataKey: 'Group'
+    },
+    series: [
+      {
+        dataKey: 'Score'
+      }
+    ],
+    dataFormat: {
+      roundTo: 0
+    }
+  } as ChartConfig)
+
+describe('getBoxPlotConfig', () => {
+  it('sorts generated value arrays numerically for numeric strings', () => {
+    const data = [
+      { Group: 'Group A', Score: '1' },
+      { Group: 'Group A', Score: '2' },
+      { Group: 'Group A', Score: '3' },
+      { Group: 'Group A', Score: '10' },
+      { Group: 'Group A', Score: '20' },
+      { Group: 'Group A', Score: '100' }
+    ]
+
+    const [plots] = getBoxPlotConfig(createBoxPlotConfig(), data)
+
+    expect(plots[0].values).toEqual([1, 2, 3, 10, 20, 100])
+    expect(plots[0].columnNonOutliers).toEqual([1, 2, 3, 10, 20])
+    expect(plots[0].columnOutliers).toEqual([100])
+  })
+
+  it('parses formatted numeric strings before sorting', () => {
+    const data = [
+      { Group: 'Group A', Score: '1,234.5' },
+      { Group: 'Group A', Score: '20' },
+      { Group: 'Group A', Score: '3' }
+    ]
+
+    const [plots] = getBoxPlotConfig(createBoxPlotConfig(), data)
+
+    expect(plots[0].values).toEqual([3, 20, 1234.5])
+    expect(plots[0].columnCount).toBe(3)
+  })
+
+  it('ignores blank, null, and nonnumeric values when generating box plot stats', () => {
+    const data = [
+      { Group: 'Group A', Score: '1' },
+      { Group: 'Group A', Score: '' },
+      { Group: 'Group A', Score: null },
+      { Group: 'Group A', Score: undefined },
+      { Group: 'Group A', Score: 'n/a' },
+      { Group: 'Group A', Score: '2' },
+      { Group: 'Group A', Score: '3' }
+    ]
+
+    const [plots] = getBoxPlotConfig(createBoxPlotConfig(), data)
+
+    expect(plots[0].values).toEqual([1, 2, 3])
+    expect(plots[0].columnCount).toBe(3)
+    expect(plots[0].columnNonOutliers).toEqual([1, 2, 3])
+    expect(plots[0].columnOutliers).toEqual([])
+  })
+})

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

@@ -0,0 +1,113 @@
+import { describe, expect, it } from 'vitest'
+import { ChartConfig } from '../../types/ChartConfig'
+import { getColorCodeCategoryColorMap } from '../getColorCodeCategoryColorMap'
+
+const buildConfig = (
+  colorCode = 'Group',
+  paletteOverrides: Partial<ChartConfig['general']['palette']> = {}
+): ChartConfig =>
+  ({
+    visualizationType: 'Bar',
+    general: {
+      palette: {
+        name: 'sequential_blue',
+        version: '2.0',
+        ...paletteOverrides
+      }
+    },
+    legend: { colorCode }
+  } as ChartConfig)
+
+const colorPalettes = {
+  sequential_blue: Array.from({ length: 9 }, (_, index) => `#00000${index}`),
+  sequential_bluereverse: Array.from({ length: 9 }, (_, index) => `#00000${8 - index}`),
+  qualitative_standard: Array.from({ length: 9 }, (_, index) => `qualitative-${index}`)
+}
+
+describe('getColorCodeCategoryColorMap', () => {
+  it('assigns colors to unique categories in encounter order', () => {
+    const result = getColorCodeCategoryColorMap(
+      buildConfig(),
+      [{ Group: 'Group A' }, { Group: 'Group B' }, { Group: 'Group A' }],
+      colorPalettes
+    )
+
+    expect(Array.from(result.entries())).toEqual([
+      ['Group A', '#000000'],
+      ['Group B', '#000001']
+    ])
+  })
+
+  it('uses the 2.1 chart distribution for two categories in a sequential palette', () => {
+    const result = getColorCodeCategoryColorMap(
+      buildConfig('Group', { version: '2.1' }),
+      [{ Group: 'Group A' }, { Group: 'Group B' }, { Group: 'Group A' }],
+      colorPalettes
+    )
+
+    expect(Array.from(result.entries())).toEqual([
+      ['Group A', '#000004'],
+      ['Group B', '#000008']
+    ])
+  })
+
+  it('uses the full V2 chart distribution for three categories in a sequential palette', () => {
+    const result = getColorCodeCategoryColorMap(
+      buildConfig('Group', { version: '2.1' }),
+      [{ Group: 'Group A' }, { Group: 'Group B' }, { Group: 'Group C' }],
+      colorPalettes
+    )
+
+    expect(Array.from(result.values())).toEqual(['#000000', '#000004', '#000008'])
+  })
+
+  it('uses the V2 qualitative distribution for color-coded categories', () => {
+    const result = getColorCodeCategoryColorMap(
+      buildConfig('Group', { name: 'qualitative_standard', version: '2.1' }),
+      [{ Group: 'Group A' }, { Group: 'Group B' }, { Group: 'Group C' }],
+      colorPalettes
+    )
+
+    expect(Array.from(result.values())).toEqual(['qualitative-0', 'qualitative-4', 'qualitative-6'])
+  })
+
+  it('uses the V2 sequential colors in reverse order for a reversed palette', () => {
+    const rows = [{ Group: 'Group A' }, { Group: 'Group B' }]
+    const reversed = getColorCodeCategoryColorMap(
+      buildConfig('Group', {
+        name: 'sequential_bluereverse',
+        version: '2.1',
+        isReversed: true
+      }),
+      rows,
+      colorPalettes
+    )
+
+    expect(Array.from(reversed.values())).toEqual(['#000008', '#000004'])
+  })
+
+  it('preserves raw palette order for custom palettes', () => {
+    const rows = [{ Group: 'Group A' }, { Group: 'Group B' }]
+    const custom = getColorCodeCategoryColorMap(
+      buildConfig('Group', { version: '2.1', customColors: ['#111111', '#222222'] }),
+      rows,
+      colorPalettes
+    )
+
+    expect(Array.from(custom.values())).toEqual(['#111111', '#222222'])
+  })
+
+  it('repeats the palette when there are more categories than colors', () => {
+    const result = getColorCodeCategoryColorMap(
+      buildConfig(),
+      [{ Group: 'Group A' }, { Group: 'Group B' }, { Group: 'Group C' }],
+      colorPalettes
+    )
+
+    expect(Array.from(result.values())).toEqual(['#000000', '#000001', '#000002'])
+  })
+
+  it('returns an empty map without a color-code column', () => {
+    expect(getColorCodeCategoryColorMap(buildConfig(''), [{ Group: 'Group A' }], colorPalettes).size).toBe(0)
+  })
+})

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 }])
+  })
+})