@cdc/chart 4.26.4 → 4.26.6

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

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

@@ -0,0 +1,211 @@
+import { describe, expect, it } from 'vitest'
+import getMinMax from '../getMinMax'
+import { createMockConfig } from '../../components/LinearChart/tests/mockConfigContext'
+import { ChartConfig } from '../../types/ChartConfig'
+
+const leftSeries = { dataKey: 'Cases', type: 'Line', axis: 'Left', tooltip: true }
+const rightSeries = { dataKey: 'Rate', type: 'Line', axis: 'Right', tooltip: true }
+
+const createConfig = (overrides: Partial<ChartConfig> = {}) =>
+  createMockConfig({
+    visualizationType: 'Line',
+    visualizationSubType: 'regular',
+    yAxis: {
+      ...createMockConfig().yAxis,
+      type: 'linear',
+      enablePadding: false,
+      scalePadding: 0,
+      min: '',
+      max: '',
+      autoMaxStrategy: 'clean-top-tick'
+    },
+    runtime: {
+      ...createMockConfig().runtime,
+      yAxis: {
+        ...createMockConfig().runtime.yAxis,
+        min: '',
+        max: ''
+      },
+      series: [leftSeries],
+      seriesKeys: ['Cases']
+    } as any,
+    series: [leftSeries],
+    ...overrides
+  })
+
+const getResult = (config: ChartConfig, maxValue = 25) =>
+  getMinMax({
+    config,
+    minValue: 0,
+    maxValue,
+    existPositiveValue: maxValue > 0,
+    data: [{ Cases: maxValue }],
+    tableData: [{ Cases: maxValue }],
+    isAllLine: true
+  })
+
+describe('getMinMax automatic max strategy', () => {
+  it('uses clean-top-tick for automatic left-axis max when enabled', () => {
+    expect(getResult(createConfig(), 25).max).toBe(25)
+    expect(getResult(createConfig(), 101).max).toBe(120)
+    expect(getResult(createConfig(), 1434).max).toBe(1500)
+  })
+
+  it('uses the raw automatic max when strategy is omitted or default', () => {
+    expect(getResult(createConfig({ yAxis: { ...createConfig().yAxis, autoMaxStrategy: undefined } }), 101).max).toBe(
+      101
+    )
+    expect(getResult(createConfig({ yAxis: { ...createConfig().yAxis, autoMaxStrategy: 'default' } }), 101).max).toBe(
+      101
+    )
+  })
+
+  it('bypasses clean-top-tick when the left-axis max is explicit', () => {
+    const config = createConfig({
+      yAxis: {
+        ...createConfig().yAxis,
+        max: '100'
+      },
+      runtime: {
+        ...createConfig().runtime,
+        yAxis: {
+          ...createConfig().runtime.yAxis,
+          min: '',
+          max: '100'
+        }
+      } as any
+    })
+
+    expect(getResult(config, 25).max).toBe(100)
+  })
+
+  it('uses clean-top-tick when the entered left-axis max is invalid', () => {
+    const createConfigWithRuntimeMax = (max: string) =>
+      createConfig({
+        yAxis: {
+          ...createConfig().yAxis,
+          max
+        },
+        runtime: {
+          ...createConfig().runtime,
+          yAxis: {
+            ...createConfig().runtime.yAxis,
+            min: '',
+            max
+          }
+        } as any
+      })
+
+    expect(getResult(createConfigWithRuntimeMax('50'), 101).max).toBe(120)
+    expect(getResult(createConfigWithRuntimeMax('not-a-number'), 101).max).toBe(120)
+  })
+
+  it('applies smallestLeftAxisMax as a final author-provided floor without cleaning it', () => {
+    const config = createConfig({
+      yAxis: {
+        ...createConfig().yAxis,
+        autoMaxStrategy: 'clean-top-tick',
+        smallestLeftAxisMax: 12
+      }
+    })
+
+    expect(getResult(config, 3).max).toBe(12)
+  })
+
+  it('allows axis padding to increase the domain after the automatic max strategy', () => {
+    const config = createConfig({
+      yAxis: {
+        ...createConfig().yAxis,
+        autoMaxStrategy: 'clean-top-tick',
+        enablePadding: true,
+        scalePadding: 10
+      }
+    })
+
+    expect(getResult(config, 25).max).toBeCloseTo(27.5)
+  })
+
+  it('uses clean-top-tick for combo left-axis max while leaving right-axis strategy to useRightAxis', () => {
+    const config = createConfig({
+      visualizationType: 'Combo',
+      series: [leftSeries, rightSeries],
+      runtime: {
+        ...createConfig().runtime,
+        yAxis: {
+          ...createConfig().runtime.yAxis,
+          min: '',
+          max: ''
+        },
+        series: [leftSeries, rightSeries],
+        seriesKeys: ['Cases', 'Rate']
+      } as any
+    })
+
+    const result = getMinMax({
+      config,
+      minValue: 0,
+      maxValue: 101,
+      existPositiveValue: true,
+      data: [{ Cases: 101, Rate: 89 }],
+      tableData: [{ Cases: 101, Rate: 89 }],
+      isAllLine: false
+    })
+
+    expect(result.leftMax).toBe(120)
+    expect(result.rightMax).toBe(89)
+  })
+
+  it('forces a zero min for line charts when boundary suppression is present', () => {
+    const config = createConfig({
+      visualizationType: 'Line',
+      runtime: {
+        ...createConfig().runtime,
+        yAxis: {
+          ...createConfig().runtime.yAxis,
+          min: '',
+          max: ''
+        }
+      } as any
+    })
+
+    const result = getMinMax({
+      config,
+      minValue: 70,
+      maxValue: 120,
+      existPositiveValue: true,
+      data: [{ Cases: 70 }, { Cases: 120 }],
+      tableData: [{ Cases: 70 }, { Cases: 120 }],
+      isAllLine: true,
+      hasBoundarySuppression: true
+    })
+
+    expect(result.min).toBe(0)
+  })
+
+  it('keeps data min for line charts when boundary suppression is not present', () => {
+    const config = createConfig({
+      visualizationType: 'Line',
+      runtime: {
+        ...createConfig().runtime,
+        yAxis: {
+          ...createConfig().runtime.yAxis,
+          min: '',
+          max: ''
+        }
+      } as any
+    })
+
+    const result = getMinMax({
+      config,
+      minValue: 70,
+      maxValue: 120,
+      existPositiveValue: true,
+      data: [{ Cases: 70 }, { Cases: 120 }],
+      tableData: [{ Cases: 70 }, { Cases: 120 }],
+      isAllLine: true,
+      hasBoundarySuppression: false
+    })
+
+    expect(result.min).toBe(70)
+  })
+})

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

@@ -0,0 +1,119 @@
+import { describe, expect, it } from 'vitest'
+import { getYAxisDomainData, getYAxisFilterDomainBehavior } from '../getYAxisDomainData'
+import { createMockConfig } from '../../components/LinearChart/tests/mockConfigContext'
+
+describe('getYAxisDomainData', () => {
+  const filteredRows = [{ value: 3 }]
+  const tableRows = [{ value: 3 }, { value: 9 }]
+  const postExclusionRows = [{ value: 3 }, { value: 12 }]
+
+  const buildConfig = ({
+    brushActive = false,
+    brushDynamicYAxis = false,
+    filterDomainBehavior
+  }: {
+    brushActive?: boolean
+    brushDynamicYAxis?: boolean
+    filterDomainBehavior?: 'dynamic' | 'stable'
+  }) => {
+    const baseConfig = createMockConfig()
+    return createMockConfig({
+      xAxis: {
+        ...baseConfig.xAxis,
+        brushActive,
+        brushDynamicYAxis
+      },
+      yAxis: {
+        ...baseConfig.yAxis,
+        filterDomainBehavior
+      }
+    })
+  }
+
+  it('defaults omitted filterDomainBehavior to dynamic', () => {
+    const config = createMockConfig()
+
+    expect(getYAxisFilterDomainBehavior(config)).toBe('dynamic')
+  })
+
+  it.each([
+    {
+      name: 'brush off with dynamic filter domains',
+      configOptions: { brushActive: false, filterDomainBehavior: 'dynamic' as const },
+      expectedRows: filteredRows
+    },
+    {
+      name: 'brush off with stable filter domains',
+      configOptions: { brushActive: false, filterDomainBehavior: 'stable' as const },
+      expectedRows: postExclusionRows
+    },
+    {
+      name: 'dynamic brush Y-axis with dynamic filter domains',
+      configOptions: { brushActive: true, brushDynamicYAxis: true, filterDomainBehavior: 'dynamic' as const },
+      expectedRows: filteredRows
+    },
+    {
+      name: 'dynamic brush Y-axis with stable filter domains',
+      configOptions: { brushActive: true, brushDynamicYAxis: true, filterDomainBehavior: 'stable' as const },
+      expectedRows: filteredRows
+    },
+    {
+      name: 'non-dynamic brush Y-axis with dynamic filter domains',
+      configOptions: { brushActive: true, brushDynamicYAxis: false, filterDomainBehavior: 'dynamic' as const },
+      expectedRows: tableRows
+    },
+    {
+      name: 'non-dynamic brush Y-axis with stable filter domains',
+      configOptions: { brushActive: true, brushDynamicYAxis: false, filterDomainBehavior: 'stable' as const },
+      expectedRows: postExclusionRows
+    }
+  ])('selects the expected domain data for $name', ({ configOptions, expectedRows }) => {
+    expect(
+      getYAxisDomainData({
+        config: buildConfig(configOptions),
+        data: filteredRows,
+        tableData: tableRows,
+        fullEligibleDomainData: postExclusionRows
+      })
+    ).toBe(expectedRows)
+  })
+
+  it('falls back to rendered data for non-dynamic brush domains when table data is unavailable', () => {
+    expect(
+      getYAxisDomainData({
+        config: buildConfig({
+          brushActive: true,
+          brushDynamicYAxis: false,
+          filterDomainBehavior: 'dynamic'
+        }),
+        data: filteredRows
+      })
+    ).toBe(filteredRows)
+  })
+
+  it('falls back to rendered data for stable filter domains when full eligible data is unavailable', () => {
+    expect(
+      getYAxisDomainData({
+        config: buildConfig({
+          filterDomainBehavior: 'stable'
+        }),
+        data: filteredRows,
+        tableData: tableRows
+      })
+    ).toBe(filteredRows)
+  })
+
+  it('falls back to table data for non-dynamic brush stable domains when full eligible data is unavailable', () => {
+    expect(
+      getYAxisDomainData({
+        config: buildConfig({
+          brushActive: true,
+          brushDynamicYAxis: false,
+          filterDomainBehavior: 'stable'
+        }),
+        data: filteredRows,
+        tableData: tableRows
+      })
+    ).toBe(tableRows)
+  })
+})

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

@@ -0,0 +1,185 @@
+import { describe, expect, it } from 'vitest'
+import { createMockConfig } from '../../components/LinearChart/tests/mockConfigContext'
+import { getYAxisFinalizationEligibility } from '../getYAxisFinalizationEligibility'
+
+const getEligibility = (overrides = {}) =>
+  getYAxisFinalizationEligibility({
+    config: createMockConfig(overrides),
+    hasSpacedInlineLabel: false,
+    hasValidExplicitLeftMax: false,
+    isHorizontal: false
+  })
+
+describe('getYAxisFinalizationEligibility', () => {
+  it('finalizes automatic clean-top-tick linear Y axes', () => {
+    const result = getEligibility({
+      yAxis: {
+        ...createMockConfig().yAxis,
+        type: 'linear',
+        autoMaxStrategy: 'clean-top-tick'
+      }
+    })
+
+    expect(result.shouldUseCleanTopTick).toBe(true)
+    expect(result.shouldFinalizePrimaryYAxis).toBe(true)
+    expect(result.shouldUseInlineLabelHeadroom).toBe(false)
+  })
+
+  it('uses spaced inline labels as headroom for standard non-Combo Y axes', () => {
+    const result = getYAxisFinalizationEligibility({
+      config: createMockConfig({
+        yAxis: {
+          ...createMockConfig().yAxis,
+          type: 'linear',
+          autoMaxStrategy: 'default',
+          inlineLabel: ' percent'
+        }
+      }),
+      hasSpacedInlineLabel: true,
+      hasValidExplicitLeftMax: false,
+      isHorizontal: false
+    })
+
+    expect(result.shouldUseInlineLabelHeadroom).toBe(true)
+    expect(result.shouldUseCleanTopTick).toBe(true)
+    expect(result.shouldFinalizePrimaryYAxis).toBe(true)
+  })
+
+  it('does not use spaced inline labels as headroom for Combo charts', () => {
+    const result = getYAxisFinalizationEligibility({
+      config: createMockConfig({
+        visualizationType: 'Combo',
+        yAxis: {
+          ...createMockConfig().yAxis,
+          type: 'linear',
+          autoMaxStrategy: 'default',
+          inlineLabel: ' percent'
+        }
+      }),
+      hasSpacedInlineLabel: true,
+      hasValidExplicitLeftMax: false,
+      isHorizontal: false
+    })
+
+    expect(result.supportsInlineLabelHeadroom).toBe(false)
+    expect(result.shouldUseInlineLabelHeadroom).toBe(false)
+    expect(result.shouldFinalizePrimaryYAxis).toBe(false)
+  })
+
+  it('still finalizes Combo charts when clean-top-tick is explicitly enabled', () => {
+    const result = getEligibility({
+      visualizationType: 'Combo',
+      yAxis: {
+        ...createMockConfig().yAxis,
+        type: 'linear',
+        autoMaxStrategy: 'clean-top-tick'
+      }
+    })
+
+    expect(result.shouldUseCleanTopTick).toBe(true)
+    expect(result.shouldFinalizePrimaryYAxis).toBe(true)
+    expect(result.shouldUseInlineLabelHeadroom).toBe(false)
+  })
+
+  it('treats a valid explicit left max as a full finalization bypass', () => {
+    const result = getYAxisFinalizationEligibility({
+      config: createMockConfig({
+        yAxis: {
+          ...createMockConfig().yAxis,
+          type: 'linear',
+          autoMaxStrategy: 'clean-top-tick',
+          inlineLabel: ' percent'
+        }
+      }),
+      hasSpacedInlineLabel: true,
+      hasValidExplicitLeftMax: true,
+      isHorizontal: false
+    })
+
+    expect(result.shouldUseCleanTopTick).toBe(false)
+    expect(result.shouldFinalizePrimaryYAxis).toBe(false)
+  })
+
+  it('does not finalize horizontal, categorical, logarithmic, or special chart Y axes', () => {
+    expect(
+      getYAxisFinalizationEligibility({
+        config: createMockConfig({
+          yAxis: {
+            ...createMockConfig().yAxis,
+            type: 'linear',
+            autoMaxStrategy: 'clean-top-tick'
+          }
+        }),
+        hasSpacedInlineLabel: false,
+        hasValidExplicitLeftMax: false,
+        isHorizontal: true
+      }).shouldFinalizePrimaryYAxis
+    ).toBe(false)
+
+    expect(
+      getEligibility({
+        yAxis: {
+          ...createMockConfig().yAxis,
+          type: 'categorical',
+          autoMaxStrategy: 'clean-top-tick'
+        }
+      }).shouldFinalizePrimaryYAxis
+    ).toBe(false)
+
+    expect(
+      getEligibility({
+        yAxis: {
+          ...createMockConfig().yAxis,
+          type: 'logarithmic',
+          autoMaxStrategy: 'clean-top-tick'
+        }
+      }).shouldFinalizePrimaryYAxis
+    ).toBe(false)
+
+    expect(
+      getEligibility({
+        visualizationType: 'Box Plot',
+        yAxis: {
+          ...createMockConfig().yAxis,
+          type: 'linear',
+          autoMaxStrategy: 'clean-top-tick'
+        }
+      }).shouldFinalizePrimaryYAxis
+    ).toBe(false)
+
+    expect(
+      getEligibility({
+        visualizationType: 'Bump Chart',
+        yAxis: {
+          ...createMockConfig().yAxis,
+          type: 'linear',
+          autoMaxStrategy: 'clean-top-tick'
+        }
+      }).shouldFinalizePrimaryYAxis
+    ).toBe(false)
+
+    expect(
+      getEligibility({
+        visualizationType: 'Forest Plot',
+        yAxis: {
+          ...createMockConfig().yAxis,
+          type: 'linear',
+          autoMaxStrategy: 'clean-top-tick'
+        }
+      }).shouldFinalizePrimaryYAxis
+    ).toBe(false)
+  })
+
+  it('treats omitted legacy Y-axis type as linear', () => {
+    const result = getEligibility({
+      yAxis: {
+        ...createMockConfig().yAxis,
+        type: undefined,
+        autoMaxStrategy: 'clean-top-tick'
+      }
+    })
+
+    expect(result.hasStandardLinearPrimaryYAxis).toBe(true)
+    expect(result.shouldFinalizePrimaryYAxis).toBe(true)
+  })
+})