@cdc/chart 4.26.5 → 4.26.6

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

@@ -0,0 +1,135 @@
+import { describe, expect, it } from 'vitest'
+import { getSeriesWithData } from '../dataHelpers'
+import { ChartConfig } from '../../types/ChartConfig'
+
+type SeriesInput = {
+  dataKey: string
+  name?: string
+  type?: string
+  dynamicCategory?: string
+  originalDataKey?: string
+}
+
+const buildConfig = (
+  data: Record<string, unknown>[],
+  series: SeriesInput[],
+  overrides: Partial<ChartConfig> = {}
+): ChartConfig =>
+  ({
+    data,
+    filters: [],
+    legend: { colorCode: '' },
+    runtime: { series },
+    ...overrides
+  } as unknown as ChartConfig)
+
+describe('getSeriesWithData', () => {
+  it('includes a series that has at least one numeric non-zero value', () => {
+    const config = buildConfig(
+      [{ percent_mild: '3.8' }, { percent_mild: '0.0' }],
+      [{ dataKey: 'percent_mild', name: 'Mild', type: 'Bar' }]
+    )
+    expect(getSeriesWithData(config)).toEqual(['Mild'])
+  })
+
+  it('excludes a series whose values are all zero (0 and "0.0")', () => {
+    const config = buildConfig(
+      [{ percent_fever_notemp: '0.0' }, { percent_fever_notemp: 0 }],
+      [{ dataKey: 'percent_fever_notemp', name: 'Reported fever', type: 'Bar' }]
+    )
+    expect(getSeriesWithData(config)).toEqual([])
+  })
+
+  it('keeps a series that has a single non-zero value among zeros', () => {
+    const config = buildConfig(
+      [{ percent_mild: '0.0' }, { percent_mild: '0.0' }, { percent_mild: '1.2' }],
+      [{ dataKey: 'percent_mild', name: 'Mild', type: 'Bar' }]
+    )
+    expect(getSeriesWithData(config)).toEqual(['Mild'])
+  })
+
+  it('treats non-numeric placeholder strings as no data', () => {
+    const config = buildConfig(
+      [{ percent_fever_notemp: 'Not applicable' }, { percent_fever_notemp: '<1.0' }, { percent_fever_notemp: '' }],
+      [{ dataKey: 'percent_fever_notemp', name: 'Reported fever', type: 'Bar' }]
+    )
+    expect(getSeriesWithData(config)).toEqual([])
+  })
+
+  it('treats null and undefined values as no data', () => {
+    const config = buildConfig(
+      [{ percent_fever_notemp: null }, { percent_fever_notemp: undefined }],
+      [{ dataKey: 'percent_fever_notemp', name: 'Reported fever', type: 'Bar' }]
+    )
+    expect(getSeriesWithData(config)).toEqual([])
+  })
+
+  it('counts comma- and dollar-formatted numeric strings as data', () => {
+    const config = buildConfig(
+      [{ revenue: '$1,000' }, { revenue: '0.0' }],
+      [{ dataKey: 'revenue', name: 'Revenue', type: 'Bar' }]
+    )
+    expect(getSeriesWithData(config)).toEqual(['Revenue'])
+  })
+
+  it('counts negative non-zero values as data', () => {
+    const config = buildConfig([{ delta: '-5' }, { delta: '0' }], [{ dataKey: 'delta', name: 'Delta', type: 'Bar' }])
+    expect(getSeriesWithData(config)).toEqual(['Delta'])
+  })
+
+  it('applies active filters before evaluating series data', () => {
+    const config = buildConfig(
+      [
+        { reaction: 'Headache', percent_fever_notemp: '0.0', percent_mild: '3.8' },
+        { reaction: 'Fever or feverish', percent_fever_notemp: '0.9', percent_mild: '0.0' }
+      ],
+      [
+        { dataKey: 'percent_mild', name: 'Mild', type: 'Bar' },
+        { dataKey: 'percent_fever_notemp', name: 'Reported fever', type: 'Bar' }
+      ],
+      { filters: [{ columnName: 'reaction', active: 'Headache' }] as ChartConfig['filters'] }
+    )
+    // Under "Headache" the fever column is all zeros, so it drops out of the legend.
+    expect(getSeriesWithData(config)).toEqual(['Mild'])
+  })
+
+  it('uses originalDataKey for dynamicCategory series', () => {
+    const config = buildConfig(
+      [
+        { category: 'a', value: '4.2', label: 'a-value' },
+        { category: 'b', value: '0.0', label: 'b-value' }
+      ],
+      [
+        {
+          dataKey: 'a',
+          name: 'A',
+          type: 'Bar',
+          dynamicCategory: 'category',
+          originalDataKey: 'value'
+        },
+        {
+          dataKey: 'b',
+          name: 'B',
+          type: 'Bar',
+          dynamicCategory: 'category',
+          originalDataKey: 'value'
+        }
+      ]
+    )
+    // Series "a" has a non-zero value; series "b" is zero only.
+    expect(getSeriesWithData(config)).toEqual(['A'])
+  })
+
+  it('splits color-coded Bar series by colorCode values', () => {
+    const config = buildConfig(
+      [
+        { group: 'North', amount: '5' },
+        { group: 'South', amount: '0.0' }
+      ],
+      [{ dataKey: 'amount', name: 'Amount', type: 'Bar' }],
+      { legend: { colorCode: 'group' } as ChartConfig['legend'] }
+    )
+    // Only the "North" rows carry a non-zero amount.
+    expect(getSeriesWithData(config)).toEqual(['North'])
+  })
+})

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

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest'
+import { getAxisMaxOverride } from '../getAxisMaxOverride'
+
+describe('getAxisMaxOverride', () => {
+  it('accepts finite entered values that meet the required max', () => {
+    expect(getAxisMaxOverride({ value: '25', minimumValidMax: 20 })).toEqual({
+      hasEnteredMax: true,
+      hasValidMax: true,
+      maxNumber: 25
+    })
+  })
+
+  it('rejects missing or empty entered values', () => {
+    expect(getAxisMaxOverride({ value: undefined, minimumValidMax: 0 }).hasValidMax).toBe(false)
+    expect(getAxisMaxOverride({ value: null, minimumValidMax: 0 }).hasValidMax).toBe(false)
+    expect(getAxisMaxOverride({ value: '', minimumValidMax: 0 }).hasValidMax).toBe(false)
+  })
+
+  it('rejects non-finite entered values', () => {
+    expect(getAxisMaxOverride({ value: 'not-a-number', minimumValidMax: 0 }).hasValidMax).toBe(false)
+    expect(getAxisMaxOverride({ value: Infinity, minimumValidMax: 0 }).hasValidMax).toBe(false)
+  })
+
+  it('rejects entered values below the required max', () => {
+    expect(getAxisMaxOverride({ value: '19', minimumValidMax: 20 })).toMatchObject({
+      hasEnteredMax: true,
+      hasValidMax: false,
+      maxNumber: 19
+    })
+  })
+
+  it('supports the non-positive primary-axis rule by passing zero as the required max', () => {
+    expect(getAxisMaxOverride({ value: '0', minimumValidMax: 0 }).hasValidMax).toBe(true)
+    expect(getAxisMaxOverride({ value: '-1', minimumValidMax: 0 }).hasValidMax).toBe(false)
+  })
+})

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

@@ -0,0 +1,165 @@
+import { describe, expect, it } from 'vitest'
+import { getCleanTopTickMax, getCleanTopTickMaxCandidates, getFinalTopTickMax } from '../getCleanTopTickMax'
+
+describe('getCleanTopTickMax', () => {
+  it('rounds automatic max values with the clean-top-tick mantissa ladder', () => {
+    expect(getCleanTopTickMaxCandidates()).toEqual([1, 1.2, 1.5, 2, 2.5, 3, 4, 5, 6, 8, 10])
+
+    expect([
+      [0.0049, getCleanTopTickMax(0.0049)],
+      [0.011, getCleanTopTickMax(0.011)],
+      [0.012, getCleanTopTickMax(0.012)],
+      [1.1, getCleanTopTickMax(1.1)],
+      [1.2, getCleanTopTickMax(1.2)],
+      [3, getCleanTopTickMax(3)],
+      [5, getCleanTopTickMax(5)],
+      [5.1, getCleanTopTickMax(5.1)],
+      [7, getCleanTopTickMax(7)],
+      [7.2, getCleanTopTickMax(7.2)],
+      [8, getCleanTopTickMax(8)],
+      [9, getCleanTopTickMax(9)],
+      [25, getCleanTopTickMax(25)],
+      [89, getCleanTopTickMax(89)],
+      [101, getCleanTopTickMax(101)],
+      [1434, getCleanTopTickMax(1434)],
+      [1470, getCleanTopTickMax(1470)],
+      [1490, getCleanTopTickMax(1490)],
+      [1675, getCleanTopTickMax(1675)],
+      [2340, getCleanTopTickMax(2340)],
+      [5678, getCleanTopTickMax(5678)],
+      [8999, getCleanTopTickMax(8999)]
+    ]).toEqual([
+      [0.0049, 0.005],
+      [0.011, 0.012],
+      [0.012, 0.012],
+      [1.1, 1.2],
+      [1.2, 1.2],
+      [3, 3],
+      [5, 5],
+      [5.1, 6],
+      [7, 8],
+      [7.2, 8],
+      [8, 8],
+      [9, 10],
+      [25, 25],
+      [89, 100],
+      [101, 120],
+      [1434, 1500],
+      [1470, 1500],
+      [1490, 1500],
+      [1675, 2000],
+      [2340, 2500],
+      [5678, 6000],
+      [8999, 10000]
+    ])
+  })
+
+  it('leaves non-finite values unchanged', () => {
+    expect(getCleanTopTickMax(Infinity)).toBe(Infinity)
+    expect(Number.isNaN(getCleanTopTickMax(NaN))).toBe(true)
+  })
+
+  it('leaves non-positive values unchanged', () => {
+    expect(getCleanTopTickMax(0)).toBe(0)
+    expect(getCleanTopTickMax(-1)).toBe(-1)
+  })
+})
+
+describe('getFinalTopTickMax', () => {
+  it('advances clean max values to the next generated tick interval when the top tick is below the max', () => {
+    expect(
+      getFinalTopTickMax({
+        currentMax: 12,
+        rawMax: 12,
+        ticks: [0, 5, 10],
+        shouldUseCleanTopTick: true
+      })
+    ).toEqual({ max: 15, tickValues: [0, 5, 10, 15] })
+
+    expect(
+      getFinalTopTickMax({
+        currentMax: 25,
+        rawMax: 25,
+        ticks: [0, 10, 20],
+        shouldUseCleanTopTick: true
+      })
+    ).toEqual({ max: 30, tickValues: [0, 10, 20, 30] })
+  })
+
+  it('keeps a clean max when the generated top tick already reaches it', () => {
+    expect(
+      getFinalTopTickMax({
+        currentMax: 12,
+        rawMax: 12,
+        ticks: [0, 2, 4, 6, 8, 10, 12],
+        shouldUseCleanTopTick: true
+      })
+    ).toEqual({ max: 12, tickValues: [0, 2, 4, 6, 8, 10, 12] })
+  })
+
+  it('does not advance for floating-point dust above the generated top tick', () => {
+    expect(
+      getFinalTopTickMax({
+        currentMax: 0.6000000000000001,
+        rawMax: 0.6,
+        ticks: [0, 0.2, 0.4, 0.6],
+        shouldUseCleanTopTick: true
+      })
+    ).toEqual({ max: 0.6, tickValues: [0, 0.2, 0.4, 0.6] })
+  })
+
+  it('adds one more interval for spaced inline labels when the raw max is too close to the top tick', () => {
+    expect(
+      getFinalTopTickMax({
+        currentMax: 14.4,
+        rawMax: 14.4,
+        ticks: [0, 5, 10, 15],
+        shouldUseCleanTopTick: true,
+        headroomMode: 'inline-label'
+      })
+    ).toEqual({ max: 20, tickValues: [0, 5, 10, 15, 20] })
+
+    expect(
+      getFinalTopTickMax({
+        currentMax: 11.25,
+        rawMax: 11.25,
+        ticks: [0, 5, 10, 15],
+        shouldUseCleanTopTick: true,
+        headroomMode: 'inline-label'
+      })
+    ).toEqual({ max: 15, tickValues: [0, 5, 10, 15] })
+  })
+
+  it('finalizes tiny spaced inline-label domains and includes the top tick', () => {
+    expect(
+      getFinalTopTickMax({
+        currentMax: 0.015,
+        rawMax: 0.015,
+        ticks: [0, 0.005, 0.01, 0.015],
+        shouldUseCleanTopTick: true,
+        headroomMode: 'inline-label'
+      })
+    ).toEqual({ max: 0.02, tickValues: [0, 0.005, 0.01, 0.015, 0.02] })
+
+    expect(
+      getFinalTopTickMax({
+        currentMax: 0.019,
+        rawMax: 0.019,
+        ticks: [0, 0.005, 0.01, 0.015],
+        shouldUseCleanTopTick: true,
+        headroomMode: 'inline-label'
+      })
+    ).toEqual({ max: 0.025, tickValues: [0, 0.005, 0.01, 0.015, 0.02, 0.025] })
+  })
+
+  it('does not change the max when effective clean-top-tick is disabled', () => {
+    expect(
+      getFinalTopTickMax({
+        currentMax: 12,
+        rawMax: 12,
+        ticks: [0, 5, 10],
+        shouldUseCleanTopTick: false
+      })
+    ).toEqual({ max: 12 })
+  })
+})

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

@@ -0,0 +1,197 @@
+import { describe, expect, it } from 'vitest'
+import { getColorScale } from '../getColorScale'
+import { ChartConfig } from '../../types/ChartConfig'
+
+const buildConfig = (overrides: Partial<ChartConfig> = {}): ChartConfig =>
+  ({
+    visualizationType: 'Line',
+    visualizationSubType: 'regular',
+    general: {
+      palette: {
+        customColors: ['#111111', '#222222', '#333333'],
+        colorAssignmentMode: 'by-value',
+        colorAssignments: [
+          { key: 'series_a', color: '#aa0000' },
+          { key: 'series_c', color: '#00cc00' }
+        ]
+      }
+    },
+    legend: {},
+    series: [
+      { dataKey: 'series_a', name: 'Series A', type: 'Line' },
+      { dataKey: 'series_b', name: 'Series B', type: 'Line' },
+      { dataKey: 'series_c', name: 'Series C', type: 'Line' }
+    ],
+    runtime: {
+      seriesKeys: ['series_a', 'series_b', 'series_c'],
+      seriesLabels: {
+        series_a: 'Series A',
+        series_b: 'Series B',
+        series_c: 'Series C'
+      },
+      seriesLabelsAll: ['Series A', 'Series B', 'Series C']
+    },
+    ...overrides
+  } as ChartConfig)
+
+describe('getColorScale series color assignments', () => {
+  it('keeps assigned series colors stable when runtime series order changes', () => {
+    const colorScale = getColorScale(
+      buildConfig({
+        runtime: {
+          seriesKeys: ['series_c', 'series_a'],
+          seriesLabels: {
+            series_a: 'Series A',
+            series_c: 'Series C'
+          },
+          seriesLabelsAll: ['Series C', 'Series A']
+        } as any
+      })
+    )
+
+    expect(colorScale('Series A')).toBe('#aa0000')
+    expect(colorScale('Series C')).toBe('#00cc00')
+  })
+
+  it('keeps assigned colors when missing series later reappear', () => {
+    const filteredScale = getColorScale(
+      buildConfig({
+        runtime: {
+          seriesKeys: ['series_a'],
+          seriesLabels: { series_a: 'Series A' },
+          seriesLabelsAll: ['Series A']
+        } as any
+      })
+    )
+    const restoredScale = getColorScale(buildConfig())
+
+    expect(filteredScale('Series A')).toBe('#aa0000')
+    expect(restoredScale('Series C')).toBe('#00cc00')
+  })
+
+  it('uses ordered palette/custom fallback for unassigned series', () => {
+    const colorScale = getColorScale(buildConfig())
+
+    expect(colorScale('Series A')).toBe('#aa0000')
+    expect(colorScale('Series B')).toBe('#222222')
+    expect(colorScale('Series C')).toBe('#00cc00')
+  })
+
+  it('resolves assignments by dataKey when display labels differ', () => {
+    const colorScale = getColorScale(
+      buildConfig({
+        series: [{ dataKey: 'raw_value', name: 'Display Value', type: 'Line' }] as any,
+        runtime: {
+          seriesKeys: ['raw_value'],
+          seriesLabels: { raw_value: 'Display Value' },
+          seriesLabelsAll: ['Display Value']
+        } as any,
+        general: {
+          palette: {
+            customColors: ['#111111'],
+            colorAssignmentMode: 'by-value',
+            colorAssignments: [{ key: 'raw_value', color: '#123456' }]
+          }
+        } as any
+      })
+    )
+
+    expect(colorScale('Display Value')).toBe('#123456')
+  })
+
+  it('preserves ordered mode behavior when assignments are present', () => {
+    const colorScale = getColorScale(
+      buildConfig({
+        general: {
+          palette: {
+            customColors: ['#111111', '#222222', '#333333'],
+            colorAssignmentMode: 'ordered',
+            colorAssignments: [{ key: 'series_a', color: '#aa0000' }]
+          }
+        } as any
+      })
+    )
+
+    expect(colorScale('Series A')).toBe('#111111')
+    expect(colorScale('Series B')).toBe('#222222')
+  })
+
+  it('preserves scatter plot customColors through the shared scale', () => {
+    const colorScale = getColorScale(
+      buildConfig({
+        visualizationType: 'Scatter Plot',
+        general: {
+          palette: {
+            customColors: ['#101010', '#202020', '#303030']
+          }
+        } as any
+      })
+    )
+
+    expect(colorScale('Series A')).toBe('#101010')
+    expect(colorScale('Series B')).toBe('#202020')
+  })
+
+  it('uses v2 customColors in authored order when customColorsOrdered is absent', () => {
+    const colorScale = getColorScale(
+      buildConfig({
+        general: {
+          palette: {
+            name: 'qualitative_standard',
+            version: '2.0',
+            customColors: [
+              '#111111',
+              '#222222',
+              '#333333',
+              '#444444',
+              '#555555',
+              '#666666',
+              '#777777',
+              '#888888',
+              '#999999'
+            ]
+          }
+        } as any
+      })
+    )
+
+    expect(colorScale('Series A')).toBe('#111111')
+    expect(colorScale('Series B')).toBe('#222222')
+    expect(colorScale('Series C')).toBe('#333333')
+  })
+
+  it('falls back to customColors when customColorsOrdered is empty', () => {
+    const colorScale = getColorScale(
+      buildConfig({
+        general: {
+          palette: {
+            customColorsOrdered: [],
+            customColors: ['#101010', '#202020', '#303030']
+          }
+        } as any
+      })
+    )
+
+    expect(colorScale('Series A')).toBe('#101010')
+    expect(colorScale('Series B')).toBe('#202020')
+    expect(colorScale('Series C')).toBe('#303030')
+  })
+
+  it('falls back to the named palette when customColors is empty', () => {
+    const colorScale = getColorScale(
+      buildConfig({
+        general: {
+          palette: {
+            name: 'qualitative_standard',
+            version: '2.0',
+            customColors: []
+          }
+        } as any
+      })
+    )
+
+    expect(colorScale('Series A')).toBe('#0057B7')
+    expect(colorScale('Series B')).toBe('#00B1CE')
+    expect(colorScale('Series C')).toBe('#5A8E3F')
+  })
+})