@cdc/chart 4.25.3 → 4.25.6

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

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest'
+import { getNewRuntime } from '../getNewRuntime'
+
+describe('getNewRuntime', () => {
+  it('should return a runtime object with default values when no data is provided', () => {
+    const visualizationConfig = { runtime: {} }
+    const newFilteredData = null
+
+    const result = getNewRuntime(visualizationConfig, newFilteredData)
+
+    expect(result.series).toEqual([])
+    expect(result.seriesLabels).toEqual({})
+    expect(result.seriesLabelsAll).toEqual([])
+    expect(result.seriesKeys).toEqual([])
+  })
+
+  it('should populate runtime.series with valid series from newFilteredData', () => {
+    const visualizationConfig = {
+      runtime: {},
+      filters: [],
+      columns: {},
+      dynamicSeriesType: 'bar',
+      dynamicSeriesLineType: 'solid',
+      xAxis: { dataKey: 'x' }
+    }
+    const newFilteredData = [
+      { x: 1, y: 10, z: 20 },
+      { x: 2, y: 15, z: 25 }
+    ]
+
+    const result = getNewRuntime(visualizationConfig, newFilteredData)
+
+    expect(result.series).toEqual([
+      { dataKey: 'y', type: 'bar', lineType: 'solid', tooltip: true },
+      { dataKey: 'z', type: 'bar', lineType: 'solid', tooltip: true }
+    ])
+    expect(result.seriesKeys).toEqual(['y', 'z'])
+    expect(result.seriesLabels).toEqual({ y: 'y', z: 'z' })
+    expect(result.seriesLabelsAll).toEqual(['y', 'z'])
+  })
+
+  it('should exclude series keys that match filters or columns', () => {
+    const visualizationConfig = {
+      runtime: {},
+      filters: [{ columnName: 'y' }],
+      columns: { z: {} },
+      dynamicSeriesType: 'bar',
+      dynamicSeriesLineType: 'solid',
+      xAxis: { dataKey: 'x' }
+    }
+    const newFilteredData = [
+      { x: 1, y: 10, z: 20, w: 30 },
+      { x: 2, y: 15, z: 25, w: 35 }
+    ]
+
+    const result = getNewRuntime(visualizationConfig, newFilteredData)
+
+    expect(result.series).toEqual([{ dataKey: 'w', type: 'bar', lineType: 'solid', tooltip: true }])
+    expect(result.seriesKeys).toEqual(['w'])
+    expect(result.seriesLabels).toEqual({ w: 'w' })
+    expect(result.seriesLabelsAll).toEqual(['w'])
+  })
+
+  it('should handle empty newFilteredData gracefully', () => {
+    const visualizationConfig = {
+      runtime: {},
+      filters: [],
+      columns: {},
+      dynamicSeriesType: 'bar',
+      dynamicSeriesLineType: 'solid',
+      xAxis: { dataKey: 'x' }
+    }
+    const newFilteredData = []
+
+    const result = getNewRuntime(visualizationConfig, newFilteredData)
+
+    expect(result.series).toEqual([])
+    expect(result.seriesKeys).toEqual([])
+    expect(result.seriesLabels).toEqual({})
+    expect(result.seriesLabelsAll).toEqual([])
+  })
+})

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

@@ -0,0 +1,38 @@
+// getPiePercent.test.ts
+import { getPiePercent } from '../getPiePercent'
+
+describe('getPiePercent', () => {
+  it('cgets percentages for purely numeric strings', () => {
+    const data = [{ A: '1' }, { A: '3' }, { A: '6' }]
+    const result = getPiePercent(data, 'A')
+
+    // sum = 1 + 3 + 6 = 10
+    expect(result[0].A).toBeCloseTo((1 / 10) * 100) // 10%
+    expect(result[1].A).toBeCloseTo((3 / 10) * 100) // 30%
+    expect(result[2].A).toBeCloseTo((6 / 10) * 100) // 60%
+  })
+
+  it('shandle non numbers like "ABC', () => {
+    const data = [{ A: '1' }, { A: 'ABC' }, { A: '2' }]
+    const result = getPiePercent(data, 'A')
+
+    expect(result[0].A).toBeCloseTo((1 / 3) * 100)
+    expect(result[1].A).toBe('ABC')
+    expect(result[2].A).toBeCloseTo((2 / 3) * 100)
+  })
+
+  it('handles all-zero total by producing 0%', () => {
+    const data = [{ A: '0' }, { A: '0' }]
+    const result = getPiePercent(data, 'A')
+    expect(result[0].A).toBe(0)
+    expect(result[1].A).toBe(0)
+  })
+
+  it('leaves rows missing the key entirely unchanged', () => {
+    const data = [{ A: '2' }, { B: 'foo' }]
+    const result = getPiePercent(data, 'A')
+
+    expect(result[0].A).toBeCloseTo(100)
+    expect(result[1]).toEqual({ B: 'foo' })
+  })
+})

package/src/hooks/useMinMax.ts

@@ -46,7 +46,6 @@ const useMinMax = ({ config, minValue, maxValue, existPositiveValue, data, isAll
 
   min = enteredMinValue && isMinValid ? Number(enteredMinValue) : minValue
   max = enteredMaxValue && isMaxValid ? Number(enteredMaxValue) : Number.MIN_VALUE
-
   const { lower, upper } = config?.confidenceKeys || {}
 
   if (lower && upper && config.visualizationType === 'Bar') {
@@ -167,35 +166,28 @@ const useMinMax = ({ config, minValue, maxValue, existPositiveValue, data, isAll
   }
 
   if (config.visualizationType === 'Line' && !convertLineToBarGraph) {
-    const isMinValid = isLogarithmicAxis
-      ? Number(enteredMinValue) >= 0 && Number(enteredMinValue) < minValue
-      : Number(enteredMinValue) < minValue
-    // update minValue for (0) Suppression points
-    const suppressedMinValue = tableData?.some((dataItem, index) => {
-      return config.preliminaryData?.some(pd => {
-        if (pd.type !== 'suppression' || !pd.style) return false
-
-        // Filter data item based on current series keys and check if pd.value is present
-        const relevantData = _.pick(dataItem, config.runtime?.seriesKeys)
-        const isValuePresent = _.values(relevantData).includes(pd.value)
-
-        // Check for value match condition
-        const valueMatch = pd.column ? dataItem[pd.column] === pd.value : isValuePresent
-
-        // Return true if the value matches and it's either the first or the last item
-        return valueMatch && (index === 0 || index === tableData.length - 1)
+    const numEnteredMin = Number(enteredMinValue)
+    const isMinValid = isLogarithmicAxis ? numEnteredMin >= 0 && numEnteredMin < minValue : numEnteredMin < minValue
+
+    const suppressedMinValue = tableData?.some((item, i, arr) =>
+      config.preliminaryData?.some(({ type, style, column, value }) => {
+        if (type !== 'suppression' || !style) return false
+
+        const values = _.values(_.pick(item, config.runtime?.seriesKeys))
+        const dynamicCategory = config.series[0].dynamicCategory
+
+        const match = column ? item[column] === value : values.includes(value)
+        const dynamic = dynamicCategory && (item[dynamicCategory] === column || !column)
+
+        return (match || dynamic) && (i === 0 || i === arr.length - 1)
       })
-    })
-    let isCategoricalAxis = config.yAxis.type === 'categorical'
-    min =
-      enteredMinValue !== '' && isMinValid
-        ? Number(enteredMinValue)
-        : suppressedMinValue
-        ? 0
-        : isCategoricalAxis
-        ? 0
-        : minValue
+    )
+
+    const isCategorical = config.yAxis.type === 'categorical'
+
+    min = enteredMinValue !== '' && isMinValid ? numEnteredMin : suppressedMinValue ? 0 : isCategorical ? 0 : minValue
   }
+
   //If data value max wasn't provided, calculate it
   if (max === Number.MIN_VALUE) {
     // if all values in data are negative set max = 0
@@ -241,6 +233,7 @@ const useMinMax = ({ config, minValue, maxValue, existPositiveValue, data, isAll
 
   if (config.visualizationType === 'Scatter Plot') {
     max = max * 1.1
+    min = min / 1.1
   }
 
   return { min, max, leftMax, rightMax }

package/src/hooks/useRightAxis.ts

@@ -1,9 +1,11 @@
 import { scaleLinear } from '@visx/scale'
 import useReduceData from './useReduceData'
+import { TOP_PADDING } from './useScales'
 
-export default function useRightAxis({ config, yMax = 0, data = [], updateConfig }) {
+export default function useRightAxis({ config, yMax = 0, data = [] }) {
   const hasRightAxis = config.visualizationType === 'Combo' && config.orientation === 'vertical'
-  const rightSeriesKeys = config.series && config.series.filter(series => series.axis === 'Right').map(key => key.dataKey)
+  const rightSeriesKeys =
+    config.series && config.series.filter(series => series.axis === 'Right').map(key => key.dataKey)
   let { minValue } = useReduceData(config, data)
 
   const allRightAxisData = rightSeriesKeys => {
@@ -35,7 +37,7 @@ export default function useRightAxis({ config, yMax = 0, data = [], updateConfig
 
   const yScaleRight = scaleLinear({
     domain: [minValue, max],
-    range: [yMax, 0]
+    range: [yMax, TOP_PADDING]
   })
 
   return { yScaleRight, hasRightAxis }

package/src/hooks/useScales.ts

@@ -22,6 +22,8 @@ const scaleTypes = {
   BAND: 'band'
 }
 
+export const TOP_PADDING = 10
+
 type useScaleProps = {
   config: ChartConfig // standard chart config
   data: Object[] // standard data array
@@ -77,14 +79,21 @@ const useScales = (properties: useScaleProps) => {
     xScale = composeScaleBand(xAxisDataMappedSorted, [0, xMax], 1 - config.barThickness)
   }
 
+  // handle Linear scaled viz
+  if (config.xAxis.type === 'date' && !isHorizontal) {
+    const sorted = sortXAxisData(xAxisDataMapped, config.xAxis.sortByRecentDate)
+
+    xScale = composeScaleBand(sorted, [0, xMax], 1 - config.barThickness)
+    xScale.type = scaleTypes.BAND
+  }
+
   if (xAxis.type === 'date-time' || xAxis.type === 'continuous') {
     let xAxisMin = Math.min(...xAxisDataMapped.map(Number))
     let xAxisMax = Math.max(...xAxisDataMapped.map(Number))
-    xAxisMin -= (config.xAxis.padding ? config.xAxis.padding * 0.01 : 0) * (xAxisMax - xAxisMin)
-    xAxisMax +=
-      visualizationType === 'Line'
-        ? 0
-        : (config.xAxis.padding ? config.xAxis.padding * 0.01 : 0) * (xAxisMax - xAxisMin)
+    let paddingRatio = config.xAxis.padding ? config.xAxis.padding * 0.01 : 0
+
+    xAxisMin -= paddingRatio * (xAxisMax - xAxisMin)
+    xAxisMax += visualizationType === 'Line' ? 0 : paddingRatio * (xAxisMax - xAxisMin)
     const range = config.xAxis.sortByRecentDate ? [xMax, 0] : [0, xMax]
     xScale = scaleTime({
       domain: [xAxisMin, xAxisMax],
@@ -392,7 +401,7 @@ const composeYScale = ({ min, max, yMax, config, leftMax }) => {
 
   // If the visualization type is a bump chart then the domain and range need different values
   const domainSet = config.visualizationType === 'Bump Chart' ? [1, max] : [min, max]
-  const yRange = config.visualizationType === 'Bump Chart' ? [30, yMax] : [yMax, 0]
+  const yRange = config.visualizationType === 'Bump Chart' ? [30, yMax] : [yMax, TOP_PADDING]
   // Return the configured scale function
   return scaleFunc({
     domain: domainSet,