@cdc/chart 4.26.5 → 4.26.7

package/src/helpers/colorAssignmentHelpers.ts

@@ -0,0 +1,102 @@
+import { type ChartConfig, type VisualizationType } from '../types/ChartConfig'
+
+export type SeriesColorAssignment = {
+  key: string
+  color: string
+}
+
+export type SeriesColorAssignmentItem = {
+  key: string
+  label: string
+}
+
+export const SERIES_COLOR_ASSIGNMENT_TYPES: VisualizationType[] = ['Line', 'Bar', 'Combo', 'Area Chart', 'Scatter Plot']
+
+export const hasDynamicCategorySeries = (config: ChartConfig): boolean =>
+  Array.isArray(config.series) && config.series.some(series => Boolean(series?.dynamicCategory))
+
+export const isColorByCategoryBarChart = (config: ChartConfig): boolean =>
+  config.visualizationType === 'Bar' &&
+  config.visualizationSubType === 'regular' &&
+  Boolean(config.legend?.colorCode) &&
+  (config.series?.length || 0) === 1
+
+export const supportsSeriesColorAssignments = (config: ChartConfig): boolean =>
+  SERIES_COLOR_ASSIGNMENT_TYPES.includes(config.visualizationType) &&
+  !hasDynamicCategorySeries(config) &&
+  !isColorByCategoryBarChart(config)
+
+export const isSeriesColorAssignmentModeByValue = (config: ChartConfig): boolean =>
+  config.general?.palette?.colorAssignmentMode === 'by-value'
+
+export const getSeriesColorAssignments = (config: ChartConfig): SeriesColorAssignment[] =>
+  Array.isArray(config.general?.palette?.colorAssignments) ? config.general.palette.colorAssignments : []
+
+export const hasSeriesColorAssignmentOverrides = (config: ChartConfig): boolean => {
+  if (!supportsSeriesColorAssignments(config) || !isSeriesColorAssignmentModeByValue(config)) return false
+
+  const currentSeriesKeys = new Set(getSeriesColorAssignmentItems(config).map(({ key }) => key))
+
+  return getSeriesColorAssignments(config).some(assignment => {
+    if (!assignment?.key || !assignment?.color) return false
+
+    return currentSeriesKeys.has(assignment.key)
+  })
+}
+
+export const getSeriesDisplayLabel = (config: ChartConfig, key: string): string => {
+  const series = config.series?.find(item => item?.dataKey === key)
+  return String(config.runtime?.seriesLabels?.[key] || series?.name || (series as any)?.label || key)
+}
+
+export const getSeriesColorAssignmentItems = (config: ChartConfig): SeriesColorAssignmentItem[] => {
+  if (!supportsSeriesColorAssignments(config) || !Array.isArray(config.series)) return []
+
+  return config.series
+    .filter(series => series?.dataKey && !series.dynamicCategory)
+    .map(series => ({
+      key: series.dataKey,
+      label: getSeriesDisplayLabel(config, series.dataKey)
+    }))
+}
+
+export const getSeriesKeyByColorScaleLabel = (config: ChartConfig): Map<string, string> => {
+  const labelToKey = new Map<string, string>()
+  const runtimeKeys = Array.isArray(config.runtime?.seriesKeys) ? config.runtime.seriesKeys : []
+
+  runtimeKeys.forEach(key => {
+    labelToKey.set(String(key), key)
+    labelToKey.set(getSeriesDisplayLabel(config, key), key)
+  })
+
+  getSeriesColorAssignmentItems(config).forEach(({ key, label }) => {
+    labelToKey.set(String(key), key)
+    labelToKey.set(label, key)
+  })
+
+  return labelToKey
+}
+
+export const applySeriesColorAssignmentsToRange = (
+  config: ChartConfig,
+  domain: string[] = [],
+  range: string[] = []
+): string[] => {
+  if (!supportsSeriesColorAssignments(config) || !isSeriesColorAssignmentModeByValue(config)) return range
+
+  const assignmentMap = new Map(
+    getSeriesColorAssignments(config)
+      .filter(assignment => assignment?.key && assignment?.color)
+      .map(assignment => [assignment.key, assignment.color])
+  )
+
+  if (!assignmentMap.size || !range.length) return range
+
+  const labelToKey = getSeriesKeyByColorScaleLabel(config)
+
+  return domain.map((label, index) => {
+    const key = labelToKey.get(String(label))
+    const assignedColor = key ? assignmentMap.get(key) : undefined
+    return assignedColor || range[index % range.length]
+  })
+}

package/src/helpers/dataHelpers.ts

@@ -1,6 +1,16 @@
 import { Series } from '@cdc/core/types/Series'
+import isNumber from '@cdc/core/helpers/isNumber'
 import { ChartConfig } from '../types/ChartConfig'
 
+// For legend suppression (when `legend.unified` is false), treat a series as having
+// data only if the active (filtered) dataset contains at least one numeric, non-zero
+// value for that series. Placeholder strings (e.g. "Not applicable", "<1.0", ""),
+// nullish values, and zeros are treated as "no visible data" for legend purposes.
+const hasGraphableValue = (raw: unknown): boolean => {
+  const sanitized = typeof raw === 'string' ? raw.replace(/[,$]/g, '').trim() : raw
+  return isNumber(sanitized) && Number(sanitized) !== 0
+}
+
 export const getSeriesWithData = (config: ChartConfig) => {
   const { filters, data, runtime, legend } = config
   const { colorCode } = legend
@@ -21,7 +31,7 @@ export const getSeriesWithData = (config: ChartConfig) => {
         .filter(d => !s.colorCodeSeries || d[colorCode] === s.colorCodeSeries)
         .filter(d => {
           const key = s.dynamicCategory ? s.originalDataKey : s.dataKey
-          return d[key] || d[key] === 0
+          return hasGraphableValue(d[key])
         })
     }))
     .filter(s => s.data.length)

package/src/helpers/getAxisMaxOverride.ts

@@ -0,0 +1,16 @@
+type AxisMaxOverrideProps = {
+  minimumValidMax: number
+  value: unknown
+}
+
+export const getAxisMaxOverride = ({ minimumValidMax, value }: AxisMaxOverrideProps) => {
+  const maxNumber = Number(value)
+  const hasEnteredMax = value !== undefined && value !== null && value !== ''
+  const hasValidMax = hasEnteredMax && Number.isFinite(maxNumber) && maxNumber >= minimumValidMax
+
+  return {
+    hasEnteredMax,
+    hasValidMax,
+    maxNumber
+  }
+}

package/src/helpers/getBoxPlotConfig.ts

@@ -1,11 +1,18 @@
-import _ from 'lodash'
+import capitalize from 'lodash/capitalize'
+import chain from 'lodash/chain'
+import filter from 'lodash/filter'
+import flatMap from 'lodash/flatMap'
+import map from 'lodash/map'
+import min from 'lodash/min'
+import round from 'lodash/round'
+import uniq from 'lodash/uniq'
 import { ChartConfig } from '../types/ChartConfig'
 import * as d3 from 'd3-array'
 
 export const getBoxPlotConfig = (newConfig: ChartConfig, data: object[]) => {
   const combinedData = data
-  const groups = _.uniq(_.map(combinedData, newConfig.xAxis.dataKey))
-  const seriesKeys = _.map(newConfig.series, 'dataKey')
+  const groups = uniq(map(combinedData, newConfig.xAxis.dataKey))
+  const seriesKeys = map(newConfig.series, 'dataKey')
   const plots: any[] = []
 
   groups.forEach(g => {
@@ -14,13 +21,13 @@ export const getBoxPlotConfig = (newConfig: ChartConfig, data: object[]) => {
         if (!g) throw new Error('No groups resolved in box plots')
 
         // Start handle operations on combinedData
-        const { count, sortedData } = _.chain(combinedData)
+        const { count, sortedData } = chain(combinedData)
           // Filter by xAxis data key
           .filter(item => item[newConfig.xAxis.dataKey] === g)
           // perform multiple operations on the filtered data
           .thru(filteredData => ({
             count: filteredData.length,
-            sortedData: _.map(filteredData, item => Number(item[seriesKey])).sort()
+            sortedData: map(filteredData, item => Number(item[seriesKey])).sort()
           }))
           // get the results from the chain
           .value()
@@ -38,19 +45,19 @@ export const getBoxPlotConfig = (newConfig: ChartConfig, data: object[]) => {
         plots.push({
           columnCategory: g,
           columnMax: d3.max(nonOutliers),
-          columnThirdQuartile: _.round(q3, newConfig.dataFormat.roundTo),
+          columnThirdQuartile: round(q3, newConfig.dataFormat.roundTo),
           columnMedian: Number(d3.median(sortedData)).toFixed(newConfig.dataFormat.roundTo),
-          columnFirstQuartile: _.round(q1, newConfig.dataFormat.roundTo),
-          columnMin: _.min(nonOutliers),
+          columnFirstQuartile: round(q1, newConfig.dataFormat.roundTo),
+          columnMin: min(nonOutliers),
           columnCount: count,
           columnSd: Number(d3.deviation(sortedData)).toFixed(newConfig.dataFormat.roundTo),
           columnMean: Number(d3.mean(sortedData)).toFixed(newConfig.dataFormat.roundTo),
-          columnIqr: _.round(iqr, newConfig.dataFormat.roundTo),
+          columnIqr: round(iqr, newConfig.dataFormat.roundTo),
           values: sortedData,
           columnLowerBounds: lowerBounds,
           columnUpperBounds: upperBounds,
-          columnOutliers: _.filter(sortedData, value => value < lowerBounds || value > upperBounds),
-          columnNonOutliers: _.filter(sortedData, value => value >= lowerBounds && value <= upperBounds)
+          columnOutliers: filter(sortedData, value => value < lowerBounds || value > upperBounds),
+          columnNonOutliers: filter(sortedData, value => value >= lowerBounds && value <= upperBounds)
         })
       } catch (e) {
         console.error('COVE: ', e.message) // eslint-disable-line
@@ -61,7 +68,7 @@ export const getBoxPlotConfig = (newConfig: ChartConfig, data: object[]) => {
   // Generate a flat list of categories based on seriesKeys and groups
   const categories =
     seriesKeys.length > 1
-      ? _.flatMap(groups, value => _.map(seriesKeys, key => `${_.capitalize(key)} - ${_.capitalize(value)}`))
+      ? flatMap(groups, value => map(seriesKeys, key => `${capitalize(key)} - ${capitalize(value)}`))
       : groups
 
   return [plots, categories]

package/src/helpers/getCleanTopTickMax.ts

@@ -0,0 +1,64 @@
+const NICE_MANTISSAS = [1, 1.2, 1.5, 2, 2.5, 3, 4, 5, 6, 8, 10] as const
+
+type FinalizeTopTickMaxProps = {
+  currentMax: number
+  rawMax: number
+  ticks: number[]
+  shouldUseCleanTopTick: boolean
+  headroomMode?: 'none' | 'inline-label'
+}
+
+const getTickComparisonEpsilon = (tickGap: number) => Math.abs(tickGap) * 1e-10
+
+export const getCleanTopTickMax = (value: number) => {
+  if (!Number.isFinite(value) || value <= 0) return value
+
+  const powerOfTenStep = Math.pow(10, Math.floor(Math.log10(value)))
+  const normalizedValue = value / powerOfTenStep
+  const mantissa = NICE_MANTISSAS.find(candidate => normalizedValue <= candidate)
+
+  return (mantissa ?? 10) * powerOfTenStep
+}
+
+export const getCleanTopTickMaxCandidates = () => [...NICE_MANTISSAS]
+
+export const getFinalTopTickMax = ({
+  currentMax,
+  rawMax,
+  ticks,
+  shouldUseCleanTopTick,
+  headroomMode = 'none'
+}: FinalizeTopTickMaxProps) => {
+  if (!shouldUseCleanTopTick || !Number.isFinite(currentMax)) return { max: currentMax }
+  if (!Array.isArray(ticks) || ticks.length === 0) return { max: currentMax }
+
+  const sortedTicks = Array.from(new Set(ticks.filter(Number.isFinite))).sort((a, b) => a - b)
+  if (sortedTicks.length === 0) return { max: currentMax }
+
+  const tickGap = sortedTicks.slice(1).reduce((smallestGap, tick, index) => {
+    const gap = tick - sortedTicks[index]
+    return gap > 0 ? Math.min(smallestGap, gap) : smallestGap
+  }, Infinity)
+
+  if (!Number.isFinite(tickGap) || tickGap <= 0) return { max: currentMax }
+
+  const targetMax = Math.max(currentMax, Number.isFinite(rawMax) ? rawMax : currentMax)
+  const tickComparisonEpsilon = getTickComparisonEpsilon(tickGap)
+  let finalMax = sortedTicks[sortedTicks.length - 1]
+
+  while (finalMax + tickComparisonEpsilon < targetMax) {
+    finalMax = Number((finalMax + tickGap).toPrecision(15))
+    sortedTicks.push(finalMax)
+  }
+
+  if (
+    headroomMode === 'inline-label' &&
+    Number.isFinite(rawMax) &&
+    finalMax - rawMax <= tickGap * 0.25 + tickComparisonEpsilon
+  ) {
+    finalMax = Number((finalMax + tickGap).toPrecision(15))
+    sortedTicks.push(finalMax)
+  }
+
+  return { max: finalMax, tickValues: sortedTicks }
+}

package/src/helpers/getColorScale.ts

@@ -10,6 +10,7 @@ import {
   divergentColorDistribution,
   colorblindColorDistribution
 } from '@cdc/core/helpers/palettes/colorDistributions'
+import { applySeriesColorAssignmentsToRange } from './colorAssignmentHelpers'
 
 export const getColorScale = (config: ChartConfig): ((value: string) => string) => {
   const configPalette = ['Paired Bar', 'Deviation Bar'].includes(config.visualizationType)
@@ -32,18 +33,24 @@ export const getColorScale = (config: ChartConfig): ((value: string) => string)
   // Migrate old palette name if needed
   const migratedPaletteName = configPalette ? configPalette : getFallbackColorPalette(config)
 
+  const domain = config.runtime.seriesLabelsAll
+
+  const customColorsOrdered = config.general?.palette?.customColorsOrdered
+
   // Check for customColorsOrdered first (direct 1-to-1 mapping, no distribution needed)
-  if (config.general?.palette?.customColorsOrdered && Array.isArray(config.general.palette.customColorsOrdered)) {
-    const customColorsOrdered = config.general.palette.customColorsOrdered
+  if (Array.isArray(customColorsOrdered) && customColorsOrdered.length > 0) {
+    const range = applySeriesColorAssignmentsToRange(config, domain, customColorsOrdered)
     return scaleOrdinal({
-      domain: config.runtime.seriesLabelsAll,
-      range: customColorsOrdered,
+      domain,
+      range,
       unknown: null
     })
   }
 
+  const customColors = config.general?.palette?.customColors
+  const isUsingCustomColors = Array.isArray(customColors) && customColors.length > 0
   let palette =
-    config.general?.palette?.customColors ||
+    (isUsingCustomColors ? customColors : undefined) ||
     palettesSource[migratePaletteWithMap(migratedPaletteName, paletteMigrationMap, false)] ||
     palettesSource[configPalette]
 
@@ -58,8 +65,8 @@ export const getColorScale = (config: ChartConfig): ((value: string) => string)
   // Apply enhanced color distribution (same logic as pie charts)
   const paletteVersion = getColorPaletteVersion(config)
 
-  // Skip enhanced distribution if not v2, too many keys, or wrong palette length
-  if (paletteVersion !== 2 || numberOfKeys > 9 || palette.length !== 9) {
+  // Skip enhanced distribution if using custom colors, not v2, too many keys, or wrong palette length
+  if (isUsingCustomColors || paletteVersion !== 2 || numberOfKeys > 9 || palette.length !== 9) {
     // Use existing logic for v1 palettes and other cases
     while (numberOfKeys > palette.length) {
       palette = palette.concat(palette)
@@ -90,9 +97,11 @@ export const getColorScale = (config: ChartConfig): ((value: string) => string)
     }
   }
 
+  const range = applySeriesColorAssignmentsToRange(config, domain, palette)
+
   return scaleOrdinal({
-    domain: config.runtime.seriesLabelsAll,
-    range: palette,
+    domain,
+    range,
     unknown: null
   })
 }

package/src/helpers/getComboChartConfig.ts

@@ -1,4 +1,3 @@
-import _ from 'lodash'
 import { ChartConfig } from '../types/ChartConfig'
 import * as d3 from 'd3-array'
 

package/src/helpers/getExcludedData.ts

@@ -1,5 +1,4 @@
 import { isDateScale } from '@cdc/core/helpers/cove/date'
-import _ from 'lodash'
 import { ChartConfig } from '../types/ChartConfig'
 export const getExcludedData = (newConfig: ChartConfig, data: object[]) => {
   if (!Array.isArray(data)) {

package/src/helpers/getHasBoundarySuppression.ts

@@ -0,0 +1,27 @@
+import pick from 'lodash/pick'
+import values from 'lodash/values'
+import { ChartConfig } from '../types/ChartConfig'
+
+type GetHasBoundarySuppressionProps = {
+  rows?: Object[]
+  config: ChartConfig
+}
+
+export const getHasBoundarySuppression = ({ rows, config }: GetHasBoundarySuppressionProps) => {
+  if (!Array.isArray(rows) || rows.length === 0) return false
+  const suppressionRules = config.preliminaryData?.filter(({ type, style }) => type === 'suppression' && style) || []
+  if (!suppressionRules.length) return false
+
+  const boundaryRows = [rows[0], rows[rows.length - 1]].filter(Boolean)
+
+  return boundaryRows.some(item =>
+    suppressionRules.some(({ column, value }) => {
+      const seriesValues = values(pick(item, config.runtime?.seriesKeys))
+      const dynamicCategory = config.series[0]?.dynamicCategory
+      const match = column ? item[column] === value : seriesValues.includes(value)
+      const dynamic = dynamicCategory && (item[dynamicCategory] === column || !column)
+
+      return Boolean(match || dynamic)
+    })
+  )
+}

package/src/helpers/getMinMax.ts

@@ -1,5 +1,6 @@
 import { ChartConfig } from '../types/ChartConfig'
-import _ from 'lodash'
+import { getCleanTopTickMax } from './getCleanTopTickMax'
+import { getAxisMaxOverride } from './getAxisMaxOverride'
 
 type GetMinMaxProps = {
   /** config - standard chart config */
@@ -18,6 +19,8 @@ type GetMinMaxProps = {
   isAllLine: boolean
   /** convertLineToBarGraph - whether line charts should be rendered as bar graphs */
   convertLineToBarGraph?: boolean
+  /** whether selected-domain boundary rows include suppression tokens */
+  hasBoundarySuppression?: boolean
 }
 
 const getMinMax = ({
@@ -28,7 +31,8 @@ const getMinMax = ({
   data,
   isAllLine,
   tableData,
-  convertLineToBarGraph
+  convertLineToBarGraph,
+  hasBoundarySuppression = false
 }: GetMinMaxProps) => {
   let min = 0
   let max = 0
@@ -45,14 +49,18 @@ const getMinMax = ({
   const { max: enteredMaxValue, min: enteredMinValue } = config.runtime.yAxis
   const paddingAddedToAxis = config.yAxis.enablePadding ? 1 + config.yAxis.scalePadding / 100 : 1
   const isLogarithmicAxis = config.yAxis.type === 'logarithmic'
-  // do validation bafore applying t0 charts
-  const isMaxValid = existPositiveValue ? Number(enteredMaxValue) >= maxValue : Number(enteredMaxValue) >= 0
+  // Validate before applying chart-specific domain rules.
+  const { hasValidMax: hasValidExplicitLeftMax, maxNumber: enteredMaxNumber } = getAxisMaxOverride({
+    value: enteredMaxValue,
+    minimumValidMax: existPositiveValue ? maxValue : 0
+  })
+  const shouldCleanAutoLeftMax = config.yAxis.autoMaxStrategy === 'clean-top-tick' && !hasValidExplicitLeftMax
   const isMinValid = isLogarithmicAxis
     ? Number(enteredMinValue) >= 0
     : (Number(enteredMinValue) <= 0 && minValue >= 0) || (Number(enteredMinValue) <= minValue && minValue < 0)
 
   min = enteredMinValue && isMinValid ? Number(enteredMinValue) : minValue
-  max = enteredMaxValue && isMaxValid ? Number(enteredMaxValue) : Number.MIN_VALUE
+  max = hasValidExplicitLeftMax ? enteredMaxNumber : Number.MIN_VALUE
   const { lower, upper } = config?.confidenceKeys || {}
 
   const useBrushFullRange = config.xAxis.brushActive && !config.xAxis.brushDynamicYAxis
@@ -135,8 +143,8 @@ const getMinMax = ({
       leftMax = findMaxFromSeriesKeys(dataForMinMax, leftAxisSeriesItems, leftMax, 'left')
       rightMax = findMaxFromSeriesKeys(dataForMinMax, rightAxisSeriesItems, rightMax, 'right')
 
-      if (leftMax < Number(enteredMaxValue)) {
-        leftMax = Number(enteredMaxValue)
+      if (hasValidExplicitLeftMax && leftMax < enteredMaxNumber) {
+        leftMax = enteredMaxNumber
       }
     } catch (e) {
       console.error(e.message)
@@ -180,23 +188,10 @@ const getMinMax = ({
     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)
-      })
-    )
-
     const isCategorical = config.yAxis.type === 'categorical'
 
-    min = enteredMinValue !== '' && isMinValid ? numEnteredMin : suppressedMinValue ? 0 : isCategorical ? 0 : minValue
+    min =
+      enteredMinValue !== '' && isMinValid ? numEnteredMin : hasBoundarySuppression ? 0 : isCategorical ? 0 : minValue
   }
 
   //If data value max wasn't provided, calculate it
@@ -205,6 +200,14 @@ const getMinMax = ({
     max = existPositiveValue ? maxValue : 0
   }
 
+  if (shouldCleanAutoLeftMax) {
+    if (config.visualizationType === 'Combo') {
+      leftMax = getCleanTopTickMax(leftMax)
+    } else {
+      max = getCleanTopTickMax(max)
+    }
+  }
+
   //Adds Y Axis data padding if applicable
   if (config.runtime.yAxis.paddingPercent) {
     let paddingValue = (max - min) * config.runtime.yAxis.paddingPercent

package/src/helpers/getNewRuntime.ts

@@ -1,5 +1,3 @@
-import _ from 'lodash'
-
 export const getNewRuntime = (visualizationConfig, newFilteredData) => {
   const runtime = visualizationConfig.runtime ? { ...visualizationConfig.runtime } : {}
   runtime.series = []

package/src/helpers/getPiePercent.ts

@@ -1,13 +1,13 @@
-import _ from 'lodash'
+import toNumber from 'lodash/toNumber'
 
 export const getPiePercent = (data: Record<string, any>[], seriesKey: string): Record<string, any>[] => {
   // getonly the numeric values for each seriesKey
-  const numericValues = data.map(row => _.toNumber(row[seriesKey])).filter(v => !Number.isNaN(v))
+  const numericValues = data.map(row => toNumber(row[seriesKey])).filter(v => !Number.isNaN(v))
 
   const total = numericValues.reduce((sum, v) => sum + v, 0)
 
   return data.map(row => {
-    const raw = _.toNumber(row[seriesKey])
+    const raw = toNumber(row[seriesKey])
     if (Number.isNaN(raw)) {
       // skip non-numeric / undefined
       return row

package/src/helpers/getYAxisDomainData.ts

@@ -0,0 +1,38 @@
+import { ChartConfig } from '../types/ChartConfig'
+import { AxisFilterDomainBehavior } from '@cdc/core/types/Axis'
+
+const hasRows = (data?: Object[]) => Array.isArray(data) && data.length > 0
+
+export const getYAxisFilterDomainBehavior = (config: ChartConfig): AxisFilterDomainBehavior => {
+  return config.yAxis?.filterDomainBehavior === 'stable' ? 'stable' : 'dynamic'
+}
+
+export const getYAxisDomainData = ({
+  config,
+  data,
+  tableData,
+  fullEligibleDomainData
+}: {
+  config: ChartConfig
+  data: Object[]
+  tableData?: Object[]
+  fullEligibleDomainData?: Object[]
+}): Object[] => {
+  const brushActive = Boolean(config.xAxis?.brushActive)
+  const brushDynamicYAxis = Boolean(config.xAxis?.brushDynamicYAxis)
+
+  if (brushActive && brushDynamicYAxis) {
+    return data
+  }
+
+  const behavior = getYAxisFilterDomainBehavior(config)
+  if (behavior === 'stable' && hasRows(fullEligibleDomainData)) {
+    return fullEligibleDomainData
+  }
+
+  if (brushActive && !brushDynamicYAxis && hasRows(tableData)) {
+    return tableData
+  }
+
+  return data
+}

package/src/helpers/getYAxisFinalizationEligibility.ts

@@ -0,0 +1,40 @@
+import { type ChartConfig } from '../types/ChartConfig'
+
+type YAxisFinalizationEligibilityProps = {
+  config: ChartConfig
+  hasSpacedInlineLabel: boolean
+  hasValidExplicitLeftMax: boolean
+  isHorizontal: boolean
+}
+
+const chartUsesStandardPrimaryYScale = (config: ChartConfig) => {
+  return !['Box Plot', 'Bump Chart', 'Forest Plot'].includes(config.visualizationType)
+}
+
+const isLinearOrLegacyYAxis = (config: ChartConfig) => {
+  const yAxisType = config.yAxis.type
+
+  return yAxisType === undefined || yAxisType === '' || yAxisType === 'linear'
+}
+
+export const getYAxisFinalizationEligibility = ({
+  config,
+  hasSpacedInlineLabel,
+  hasValidExplicitLeftMax,
+  isHorizontal
+}: YAxisFinalizationEligibilityProps) => {
+  const hasStandardLinearPrimaryYAxis =
+    !isHorizontal && isLinearOrLegacyYAxis(config) && chartUsesStandardPrimaryYScale(config)
+  const supportsInlineLabelHeadroom = hasStandardLinearPrimaryYAxis && config.visualizationType !== 'Combo'
+  const shouldUseInlineLabelHeadroom = hasSpacedInlineLabel && supportsInlineLabelHeadroom
+  const shouldUseCleanTopTick =
+    !hasValidExplicitLeftMax && (config.yAxis.autoMaxStrategy === 'clean-top-tick' || shouldUseInlineLabelHeadroom)
+
+  return {
+    hasStandardLinearPrimaryYAxis,
+    supportsInlineLabelHeadroom,
+    shouldUseCleanTopTick,
+    shouldUseInlineLabelHeadroom,
+    shouldFinalizePrimaryYAxis: shouldUseCleanTopTick && hasStandardLinearPrimaryYAxis
+  }
+}

package/src/helpers/hasSpacedInlineLabel.ts

@@ -0,0 +1,10 @@
+import { ChartConfig } from '../types/ChartConfig'
+
+export const hasSpacedInlineLabel = (config: ChartConfig): boolean => {
+  const inlineLabel = config.yAxis?.inlineLabel
+  if (inlineLabel && inlineLabel.includes(' ')) {
+    return true
+  }
+
+  return false
+}

package/src/helpers/isConvertLineToBarGraph.ts

@@ -1,4 +1,4 @@
-import _ from 'lodash'
+import uniq from 'lodash/uniq'
 
 export const isConvertLineToBarGraph = (configObj, filteredData) => {
   const { allowLineToBarGraph, series, visualizationType, xAxis } = configObj
@@ -6,6 +6,6 @@ export const isConvertLineToBarGraph = (configObj, filteredData) => {
   const lineWithLessThanThreePoints = visualizationType === 'Line' && filteredData?.length < 3
   const isDynamicSeries = series?.some(series => series.dynamicCategory)
   const isDynamicWithLessThanThreePoints =
-    isDynamicSeries && _.uniq(filteredData?.map(data => data[xAxis.dataKey])).length <= 2
+    isDynamicSeries && uniq(filteredData?.map(data => data[xAxis.dataKey])).length <= 2
   return lineWithLessThanThreePoints || isDynamicWithLessThanThreePoints
 }