@cdc/core 4.26.1 → 4.26.2

package/helpers/tests/DataTransform.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect } from 'vitest'
+import DataTransform from '../DataTransform'
+
+describe('DataTransform', () => {
+  let transformer: DataTransform
+
+  beforeEach(() => {
+    transformer = new DataTransform()
+  })
+
+  describe('autoStandardize', () => {
+    it('returns undefined for empty data', () => {
+      expect(transformer.autoStandardize([])).toBeUndefined()
+      expect(transformer.autoStandardize(null)).toBeUndefined()
+      expect(transformer.autoStandardize(undefined)).toBeUndefined()
+    })
+
+    it('returns undefined for invalid data format', () => {
+      expect(transformer.autoStandardize(['string', 'array'])).toBeUndefined()
+      expect(transformer.autoStandardize([1, 2, 3])).toBeUndefined()
+    })
+
+    it('returns data unchanged when already in object format', () => {
+      const data = [
+        { name: 'Alice', value: 10 },
+        { name: 'Bob', value: 20 }
+      ]
+      const result = transformer.autoStandardize(data)
+      expect(result).toEqual(data)
+    })
+
+    it('converts array of arrays to array of objects', () => {
+      const data = [
+        ['name', 'value'],
+        ['Alice', 10],
+        ['Bob', 20]
+      ]
+      const result = transformer.autoStandardize(data)
+      expect(result).toEqual([
+        { name: 'Alice', value: 10 },
+        { name: 'Bob', value: 20 }
+      ])
+    })
+
+    it('handles array of arrays with multiple columns', () => {
+      const data = [
+        ['state', 'year', 'population'],
+        ['CA', 2020, 39538223],
+        ['TX', 2020, 29145505]
+      ]
+      const result = transformer.autoStandardize(data)
+      expect(result).toEqual([
+        { state: 'CA', year: 2020, population: 39538223 },
+        { state: 'TX', year: 2020, population: 29145505 }
+      ])
+    })
+  })
+
+  describe('cleanDataPoint', () => {
+    it('removes commas from numbers', () => {
+      expect(transformer.cleanDataPoint('1,234')).toBe('1234')
+      expect(transformer.cleanDataPoint('1,234,567')).toBe('1234567')
+    })
+
+    it('removes dollar signs', () => {
+      expect(transformer.cleanDataPoint('$100')).toBe('100')
+      expect(transformer.cleanDataPoint('$1,234')).toBe('1234')
+    })
+
+    it('removes percent signs', () => {
+      expect(transformer.cleanDataPoint('50%')).toBe('50')
+      expect(transformer.cleanDataPoint('99.9%')).toBe('99.9')
+    })
+
+    it('handles combined formatting', () => {
+      expect(transformer.cleanDataPoint('$1,234,567')).toBe('1234567')
+    })
+
+    it('handles null and empty values', () => {
+      expect(transformer.cleanDataPoint(null)).toBe('')
+      expect(transformer.cleanDataPoint('')).toBe('')
+    })
+
+    it('handles non-string values', () => {
+      expect(transformer.cleanDataPoint(123)).toBe(123)
+      expect(transformer.cleanDataPoint(0)).toBe(0)
+    })
+
+    it('returns plain numbers unchanged', () => {
+      expect(transformer.cleanDataPoint('123')).toBe('123')
+      expect(transformer.cleanDataPoint('45.67')).toBe('45.67')
+    })
+  })
+
+  describe('developerStandardize', () => {
+    it('returns empty array when data is falsy', () => {
+      expect(transformer.developerStandardize(null, {})).toEqual([])
+      expect(transformer.developerStandardize(undefined, {})).toEqual([])
+    })
+
+    it('returns undefined when description is missing', () => {
+      const data = [{ a: 1 }]
+      expect(transformer.developerStandardize(data, null)).toBeUndefined()
+      expect(transformer.developerStandardize(data, undefined)).toBeUndefined()
+    })
+
+    it('returns undefined when description is incomplete', () => {
+      const data = [{ a: 1 }]
+      expect(transformer.developerStandardize(data, {})).toBeUndefined()
+      expect(transformer.developerStandardize(data, { horizontal: true })).toBeUndefined()
+      expect(transformer.developerStandardize(data, { series: true })).toBeUndefined()
+    })
+
+    it('handles horizontal data without series', () => {
+      const data = [
+        { category: 'A', val1: 10, val2: 20 },
+        { category: 'B', val1: 30, val2: 40 }
+      ]
+      const description = { horizontal: true, series: false }
+      const result = transformer.developerStandardize(data, description)
+      expect(result).toBeDefined()
+      expect(Array.isArray(result)).toBe(true)
+    })
+  })
+})

package/helpers/tests/date.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest'
+import { getDateRenderFormat, formatDate } from '../cove/date'
+
+const NBSP = '\u00A0'
+
+describe('getDateRenderFormat', () => {
+  it('replaces space between %b. and %-d with NBSP', () => {
+    expect(getDateRenderFormat('%b. %-d %Y')).toBe(`%b.${NBSP}%-d %Y`)
+  })
+
+  it('replaces space between %b and %-d with NBSP', () => {
+    expect(getDateRenderFormat('%b %-d %Y')).toBe(`%b${NBSP}%-d %Y`)
+  })
+
+  it('replaces space between %B and %-d (full month name)', () => {
+    expect(getDateRenderFormat('%B %-d, %Y')).toBe(`%B${NBSP}%-d, %Y`)
+  })
+
+  it('leaves format unchanged when no month-day space pattern', () => {
+    expect(getDateRenderFormat('%Y-%m-%d')).toBe('%Y-%m-%d')
+  })
+
+  it('does not replace existing NBSP (idempotent)', () => {
+    const alreadyNbsp = `%b.${NBSP}%-d %Y`
+    expect(getDateRenderFormat(alreadyNbsp)).toBe(alreadyNbsp)
+  })
+
+  it('returns undefined for undefined input', () => {
+    expect(getDateRenderFormat(undefined)).toBeUndefined()
+  })
+
+  it('returns empty string for empty string input', () => {
+    expect(getDateRenderFormat('')).toBe('')
+  })
+})
+
+describe('formatDate', () => {
+  it('renders date with NBSP when format has space between month and day', () => {
+    const date = new Date(2025, 0, 15) // Jan 15, 2025
+    const result = formatDate('%b. %-d %Y', date)
+    expect(result).toContain(NBSP)
+    expect(result).toBe(`Jan.${NBSP}15 2025`)
+  })
+
+  it('strips trailing period from "May." when using %b. format', () => {
+    const date = new Date(2025, 4, 15) // May 15, 2025
+    const result = formatDate('%b. %-d, %Y', date)
+    expect(result).not.toContain('May.')
+    expect(result).toContain('May')
+  })
+
+  it('leaves "May" alone when format does not use %b.', () => {
+    const date = new Date(2025, 4, 15) // May 15, 2025
+    const result = formatDate('%b %-d, %Y', date)
+    expect(result).toContain('May')
+    expect(result).not.toContain('May.')
+  })
+
+  it('does not strip period from other months when using %b. format', () => {
+    const date = new Date(2025, 0, 15) // Jan 15, 2025
+    const result = formatDate('%b. %-d, %Y', date)
+    expect(result).toContain('Jan.')
+  })
+})

package/helpers/vegaConfig.ts

@@ -1,6 +1,6 @@
 import { DataTransform } from '@cdc/core/helpers/DataTransform'
 import { formatDate } from '@cdc/core/helpers/cove/date.js'
-import { _ } from 'lodash'
+import _ from 'lodash'
 import { compile as vegaLiteCompile } from 'vega-lite'
 import { parse as vegaParse, View as vegaView } from 'vega'
 

package/helpers/vegaConfigImport.ts

@@ -0,0 +1,160 @@
+/**
+ * Shared Vega-to-COVE conversion helper for stories.
+ */
+import {
+  convertVegaConfig,
+  getVegaConfigType,
+  getVegaErrors,
+  getVegaWarnings,
+  isVegaConfig,
+  parseVegaConfig
+} from './vegaConfig'
+
+/** Chart-type "button" definitions used to seed new COVE configs. */
+const buttons = [
+  {
+    id: 1,
+    category: 'Charts',
+    label: 'Bar',
+    type: 'chart',
+    subType: 'Bar',
+    orientation: 'vertical',
+    barThickness: '0.37',
+    visualizationSubType: 'regular',
+    xAxis: { type: 'categorical', size: 75, maxTickRotation: 45, labelOffset: 0 },
+    content: 'Use bars to show comparisons between data categories.'
+  },
+  {
+    id: 3,
+    category: 'Charts',
+    label: 'Combo Chart',
+    type: 'chart',
+    subType: 'Combo',
+    orientation: 'vertical',
+    content: 'Use bars to show comparisons between data categories.'
+  },
+  {
+    id: 4,
+    category: 'Charts',
+    label: 'Line',
+    type: 'chart',
+    subType: 'Line',
+    orientation: 'vertical',
+    content: 'Present one or more data trends over time.'
+  },
+  {
+    id: 6,
+    category: 'Charts',
+    label: 'Area Chart',
+    type: 'chart',
+    subType: 'Area Chart',
+    orientation: 'vertical',
+    content: 'Display an area chart to visualize quantities over time.'
+  },
+  {
+    id: 8,
+    category: 'Charts',
+    label: 'Scatter Plot',
+    type: 'chart',
+    subType: 'Scatter Plot',
+    orientation: 'vertical',
+    content: 'Display a scatter plot to explore relationships between numeric variables.'
+  },
+  {
+    id: 12,
+    category: 'Charts',
+    label: 'Horizontal Bar (Stacked)',
+    type: 'chart',
+    subType: 'Bar',
+    visualizationSubType: 'stacked',
+    orientation: 'horizontal',
+    content: 'Use bars to show comparisons between data categories.'
+  },
+  {
+    id: 19,
+    category: 'Maps',
+    label: 'United States (State- or County-Level)',
+    type: 'map',
+    subType: 'us',
+    content: 'Present a U.S. choropleth map at state or county level.',
+    position: 'right'
+  }
+]
+
+/** Build a seed COVE config from a button definition. */
+const generateNewConfig = (props: any) => {
+  let newConfig: any = {}
+  switch (props.category) {
+    case 'Charts': {
+      const visualizationType = props.subType
+      const visualizationSubType = !props.visualizationSubType ? 'regular' : props.visualizationSubType
+      newConfig = {
+        ...props,
+        visualizationType,
+        visualizationSubType,
+        newViz: true,
+        datasets: {}
+      }
+      break
+    }
+    case 'Maps': {
+      newConfig = { ...props, newViz: true, datasets: {}, type: 'map' }
+      newConfig['general'] = { geoType: props.subType, type: props?.generalType }
+      break
+    }
+  }
+  return newConfig
+}
+
+/**
+ * Convert a raw Vega/Vega-Lite config into a COVE config.
+ * Returns `null` if the config has errors.
+ */
+export const importVegaConfig = async (rawConfig: any): Promise<any | null> => {
+  const vegaConfig = await parseVegaConfig(rawConfig)
+  const vegaErrors = getVegaErrors(rawConfig, vegaConfig)
+  if (vegaErrors.length > 0) {
+    console.warn('Vega import errors:', vegaErrors)
+    return null
+  }
+
+  const configType = getVegaConfigType(vegaConfig)
+  const configSubType = configType === 'Map' ? 'United States (State- or County-Level)' : configType
+  const button = buttons.find(b => b.label === configSubType)
+  if (!button) {
+    console.warn(`No button found for config type "${configSubType}"`)
+    return null
+  }
+
+  const coveConfig = generateNewConfig(JSON.parse(JSON.stringify(button)))
+  try {
+    const warnings = getVegaWarnings(rawConfig, vegaConfig)
+    if (warnings.length) {
+      console.warn('Vega import warnings:', warnings)
+    }
+    const result = convertVegaConfig(configType, vegaConfig, coveConfig)
+
+    // Ensure imported Vega configs use the v1 qualitative palette so CdcChart
+    // doesn't apply v2 sequential-blue defaults (which would change the colors).
+    if (result && result.type !== 'map') {
+      result.general = result.general || {}
+      result.general.palette = {
+        name: 'qualitative-bold',
+        version: '1.0'
+      }
+    }
+
+    return result
+  } catch (err) {
+    console.error('Vega conversion error:', err)
+    return null
+  }
+}
+
+/** Check if a config is a Vega config and convert it; otherwise pass through. */
+export const maybeConvertVega = async (config: any): Promise<any | null> => {
+  if (isVegaConfig(config)) {
+    return importVegaConfig(config)
+  }
+  return config
+}

package/helpers/ver/4.26.1.ts

@@ -20,7 +20,7 @@ const removeOldBrushKeys = config => {
     delete config.brush
   }
 
-  if (config.type === 'dashboard') {
+  if (config.type === 'dashboard' && config.visualizations) {
     Object.values((config as DashboardConfig).visualizations).forEach(visualization => {
       removeOldBrushKeys(visualization)
     })

package/helpers/ver/4.26.2.ts

@@ -0,0 +1,84 @@
+import cloneConfig from '../cloneConfig'
+import { DashboardConfig } from '@cdc/dashboard/src/types/DashboardConfig'
+
+const migrateAnnotationDimensions = config => {
+  if (config.annotations && Array.isArray(config.annotations)) {
+    // Calculate chart area height for Y conversion (matches calcInitialHeight)
+    const isHorizontal = config.orientation === 'horizontal'
+    const chartAreaHeight = isHorizontal
+      ? Number(config.heights?.horizontal) || 750 // default horizontal height
+      : Number(config.heights?.vertical) || 300 // default vertical height
+
+    config.annotations = config.annotations.map(annotation => {
+      if (!annotation) return annotation
+      if (annotation.y !== undefined && chartAreaHeight > 0) {
+        // Convert Y from pixels to percentage using the chart area height
+        annotation.y = (annotation.y / chartAreaHeight) * 100
+      } else {
+        annotation.y = 50
+      }
+
+      // Delete savedDimensions to preserve old dx/dy behavior (fixed pixel offsets).
+      // The scaling function falls back to raw dx/dy when savedDimensions is missing.
+      // Once user drags the annotation, savedDimensions will be set with current chart
+      // dimensions, enabling responsive scaling from that point forward.
+      delete annotation.savedDimensions
+
+      return annotation
+    })
+  }
+
+  if (config.type === 'dashboard' && config.visualizations) {
+    Object.values((config as DashboardConfig).visualizations).forEach(visualization => {
+      migrateAnnotationDimensions(visualization)
+    })
+  }
+}
+
+const migrateAnnotationDataModel = config => {
+  if (config.annotations && Array.isArray(config.annotations)) {
+    config.annotations = config.annotations.map(annotation => {
+      if (!annotation) return annotation
+      // Set all existing annotations to fixed mode
+      annotation.anchorMode = 'fixed'
+
+      // Delete xKey entirely - old format stored timestamps for dates,
+      // but new dataX expects raw data values. Format is incompatible.
+      // User can re-enable data mode which will set fresh dataX value.
+      delete annotation.xKey
+
+      // Delete yKey entirely (Y will be calculated dynamically in data mode)
+      delete annotation.yKey
+
+      // Delete empty seriesKey - it would cause yScale(undefined) errors in data mode
+      if (!annotation.seriesKey) {
+        delete annotation.seriesKey
+      }
+
+      // Delete deprecated properties
+      delete annotation.snapToNearestPoint
+      delete annotation.originalX
+      delete annotation.originalDX
+      delete annotation.originalY
+
+      return annotation
+    })
+  }
+
+  if (config.type === 'dashboard' && config.visualizations) {
+    Object.values((config as DashboardConfig).visualizations).forEach(visualization => {
+      migrateAnnotationDataModel(visualization)
+    })
+  }
+}
+
+const update_4_26_2 = config => {
+  const ver = '4.26.2'
+  const newConfig = cloneConfig(config)
+  migrateAnnotationDimensions(newConfig)
+  migrateAnnotationDataModel(newConfig)
+  newConfig.version = ver
+  return newConfig
+}
+
+export default update_4_26_2

package/helpers/ver/tests/4.26.1.test.ts

@@ -0,0 +1,105 @@
+import update_4_26_1 from '../4.26.1'
+import { expect, describe, it } from 'vitest'
+
+describe('update_4_26_1', () => {
+  describe('normalizeFilterParents', () => {
+    it('should convert string parents to array in shared filters', () => {
+      const config: any = {
+        type: 'dashboard',
+        version: '4.26.0',
+        dashboard: {
+          sharedFilters: [
+            {
+              type: 'datafilter',
+              parents: 'parent-filter-id'
+            }
+          ]
+        }
+      }
+
+      const result = update_4_26_1(config)
+
+      expect(result.dashboard.sharedFilters[0].parents).toEqual(['parent-filter-id'])
+      expect(result.version).toBe('4.26.1')
+    })
+
+    it('should leave array parents unchanged', () => {
+      const config: any = {
+        type: 'dashboard',
+        version: '4.26.0',
+        dashboard: {
+          sharedFilters: [
+            {
+              type: 'datafilter',
+              parents: ['parent1', 'parent2']
+            }
+          ]
+        }
+      }
+
+      const result = update_4_26_1(config)
+
+      expect(result.dashboard.sharedFilters[0].parents).toEqual(['parent1', 'parent2'])
+    })
+  })
+
+  describe('removeOldBrushKeys', () => {
+    it('should remove brush config from chart', () => {
+      const config: any = {
+        type: 'chart',
+        version: '4.26.0',
+        brush: { enabled: true }
+      }
+
+      const result = update_4_26_1(config)
+
+      expect(result.brush).toBeUndefined()
+    })
+
+    it('should remove brush config from dashboard visualizations', () => {
+      const config: any = {
+        type: 'dashboard',
+        version: '4.26.0',
+        visualizations: {
+          chart1: {
+            type: 'chart',
+            brush: { enabled: true }
+          }
+        }
+      }
+
+      const result = update_4_26_1(config)
+
+      expect(result.visualizations.chart1.brush).toBeUndefined()
+    })
+  })
+
+  describe('combined migrations', () => {
+    it('should run all migrations together', () => {
+      const config: any = {
+        type: 'dashboard',
+        version: '4.26.0',
+        dashboard: {
+          sharedFilters: [
+            {
+              type: 'datafilter',
+              parents: 'parent-id'
+            }
+          ]
+        },
+        visualizations: {
+          chart1: {
+            type: 'chart',
+            brush: { enabled: true }
+          }
+        }
+      }
+
+      const result = update_4_26_1(config)
+
+      expect(result.dashboard.sharedFilters[0].parents).toEqual(['parent-id'])
+      expect(result.visualizations.chart1.brush).toBeUndefined()
+      expect(result.version).toBe('4.26.1')
+    })
+  })
+})