@cdc/chart 4.26.5 → 4.26.6

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

package/src/helpers/tests/{getYAxisAutoPaddingMode.test.ts → hasSpacedInlineLabel.test.ts}

@@ -1,11 +1,11 @@
 import { describe, expect, it } from 'vitest'
-import { getYAxisAutoPaddingMode } from '../getYAxisAutoPaddingMode'
+import { hasSpacedInlineLabel } from '../hasSpacedInlineLabel'
 import { createMockConfig } from '../../components/LinearChart/tests/mockConfigContext'
 
-describe('getYAxisAutoPaddingMode', () => {
-  it('returns inline-label for multi-word inline labels', () => {
+describe('hasSpacedInlineLabel', () => {
+  it('returns true for multi-word inline labels', () => {
     expect(
-      getYAxisAutoPaddingMode(
+      hasSpacedInlineLabel(
         createMockConfig({
           yAxis: {
             ...createMockConfig().yAxis,
@@ -14,12 +14,12 @@ describe('getYAxisAutoPaddingMode', () => {
           }
         })
       )
-    ).toBe('inline-label')
+    ).toBe(true)
   })
 
-  it('returns inline-label for inline labels with leading space', () => {
+  it('returns true for inline labels with leading space', () => {
     expect(
-      getYAxisAutoPaddingMode(
+      hasSpacedInlineLabel(
         createMockConfig({
           yAxis: {
             ...createMockConfig().yAxis,
@@ -28,12 +28,12 @@ describe('getYAxisAutoPaddingMode', () => {
           }
         })
       )
-    ).toBe('inline-label')
+    ).toBe(true)
   })
 
-  it('returns top-title for top y-axis titles with label content', () => {
+  it('returns false for top y-axis titles with empty inline labels', () => {
     expect(
-      getYAxisAutoPaddingMode(
+      hasSpacedInlineLabel(
         createMockConfig({
           yAxis: {
             ...createMockConfig().yAxis,
@@ -42,27 +42,12 @@ describe('getYAxisAutoPaddingMode', () => {
           }
         })
       )
-    ).toBe('top-title')
+    ).toBe(false)
   })
 
-  it('returns none for hidden top y-axis titles', () => {
+  it('returns false when the inline label has no spaces', () => {
     expect(
-      getYAxisAutoPaddingMode(
-        createMockConfig({
-          hideYAxisLabel: true,
-          yAxis: {
-            ...createMockConfig().yAxis,
-            titlePlacement: 'top',
-            inlineLabel: ''
-          }
-        })
-      )
-    ).toBe('none')
-  })
-
-  it('returns none when neither trigger applies', () => {
-    expect(
-      getYAxisAutoPaddingMode(
+      hasSpacedInlineLabel(
         createMockConfig({
           yAxis: {
             ...createMockConfig().yAxis,
@@ -71,12 +56,12 @@ describe('getYAxisAutoPaddingMode', () => {
           }
         })
       )
-    ).toBe('none')
+    ).toBe(false)
   })
 
-  it('returns inline-label when both triggers are present', () => {
+  it('returns true for spaced inline labels regardless of title placement', () => {
     expect(
-      getYAxisAutoPaddingMode(
+      hasSpacedInlineLabel(
         createMockConfig({
           yAxis: {
             ...createMockConfig().yAxis,
@@ -85,6 +70,6 @@ describe('getYAxisAutoPaddingMode', () => {
           }
         })
       )
-    ).toBe('inline-label')
+    ).toBe(true)
   })
 })

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

@@ -65,19 +65,33 @@ describe('seriesColumnSettings', () => {
   it('only returns explicit formatting overrides and preserves falsey values', () => {
     expect(
       getSeriesColumnFormattingParams({
-        prefix: '',
+        prefix: '$',
         suffix: ' units',
         roundToPlace: 0,
         commas: false
       })
     ).toEqual({
-      addColPrefix: '',
+      addColPrefix: '$',
       addColSuffix: ' units',
       addColRoundTo: 0,
       addColCommas: false
     })
   })
 
+  it('ignores blank prefix and suffix overrides so global formatting can apply', () => {
+    expect(
+      getSeriesColumnFormattingParams({
+        prefix: '',
+        suffix: '',
+        roundToPlace: 0,
+        commas: false
+      })
+    ).toEqual({
+      addColRoundTo: 0,
+      addColCommas: false
+    })
+  })
+
   it('returns undefined when no formatting overrides were explicitly configured', () => {
     expect(getSeriesColumnFormattingParams({ label: 'Cases' })).toBeUndefined()
   })