@cdc/core 4.26.1 → 4.26.3

package/helpers/markupProcessor.ts

@@ -26,13 +26,23 @@ export const processMarkupVariables = (
     filters?: VizFilter[]
     datasets?: Datasets
     configDataKey?: string // Add support for widget's assigned dataset
+    locale?: string
+    dataMetadata?: Record<string, string>
   } = {}
 ): {
   processedContent: string
   shouldHideSection: boolean
   shouldShowNoDataMessage: boolean
 } => {
-  const { isEditor = false, showNoDataMessage = false, allowHideSection = false, filters = [], datasets, configDataKey } = options
+  const {
+    isEditor = false,
+    showNoDataMessage = false,
+    allowHideSection = false,
+    filters = [],
+    datasets,
+    configDataKey,
+    locale = 'en-US'
+  } = options
 
   // Helper function to get data for a specific variable
   const getDataForVariable = (variable: MarkupVariable): any[] => {
@@ -65,41 +75,51 @@ export const processMarkupVariables = (
         const workingVariable = markupVariables.find(variable => variable.tag === variableTag)
         if (!workingVariable) return variableTag
 
-        // Validate that columnName exists
-        if (!workingVariable.columnName) {
-          console.warn(`Markup variable ${variableTag} has no columnName specified`)
-          return variableTag
+        // Resolve the data source for this variable. Metadata-sourced variables
+        // (metadataKey) pull a single value from the data file's top-level fields,
+        // while column-sourced variables (columnName) pull from dataset rows.
+        // Both paths produce a `conditionFilteredData` array so the downstream
+        // extraction, formatting (addCommas), dedup, and hide-check logic is shared.
+        let effectiveColumnName: string
+        let conditionFilteredData: any[]
+
+        if (workingVariable.metadataKey) {
+          // Metadata path: synthesize a single-row array from the file-level metadata
+          // so it flows through the same formatting pipeline as column values.
+          effectiveColumnName = workingVariable.metadataKey
+          const metaValue = options.dataMetadata?.[effectiveColumnName] ?? ''
+          conditionFilteredData = metaValue ? [{ [effectiveColumnName]: metaValue }] : []
+        } else {
+          // Column path: pull values from the dataset, applying filters and conditions.
+          if (!workingVariable.columnName) {
+            console.warn(`Markup variable ${variableTag} has no columnName specified`)
+            return variableTag
+          }
+          effectiveColumnName = workingVariable.columnName
+
+          let variableData = getDataForVariable(workingVariable)
+          if (filters && filters.length > 0) {
+            variableData = filterVizData(filters, variableData)
+          }
+
+          conditionFilteredData =
+            workingVariable.conditions.length === 0
+              ? variableData
+              : filterDataByConditions(variableData, [...workingVariable.conditions])
         }
 
-        // Get the appropriate dataset for this variable
-        let variableData = getDataForVariable(workingVariable)
-
-        // Apply global filters if present
-        if (filters && filters.length > 0) {
-          variableData = filterVizData(filters, variableData)
-        }
-
-        // Filter data with error handling (apply conditions on top of already filtered data)
-        const conditionFilteredData =
-          workingVariable.conditions.length === 0
-            ? variableData
-            : filterDataByConditions(variableData, [...workingVariable.conditions])
-
         // Extract values with error handling
         const variableValues: string[] = _.uniq(
           (conditionFilteredData || []).map(dataObject => {
             try {
-              const dataObjectValue = dataObject[workingVariable.columnName]
+              const dataObjectValue = dataObject[effectiveColumnName]
 
-              // Handle undefined column
               if (dataObjectValue === undefined && isEditor) {
-                console.warn(
-                  `Column "${workingVariable.columnName}" not found in data for variable ${variableTag}`
-                )
+                console.warn(`Column "${effectiveColumnName}" not found in data for variable ${variableTag}`)
               }
 
               return workingVariable.addCommas && !isNaN(parseFloat(dataObjectValue))
-                ? parseFloat(dataObjectValue).toLocaleString('en-US', { useGrouping: true })
+                ? parseFloat(dataObjectValue).toLocaleString(locale, { useGrouping: true })
                 : String(dataObjectValue || '')
             } catch (error) {
               console.error(`Error processing data value for ${variableTag}:`, error)
@@ -153,13 +173,12 @@ const filterDataByConditions = (data: any[], conditions: MarkupCondition[]): any
   const [currentCondition, ...remainingConditions] = conditions
   const { columnName, isOrIsNotEqualTo, value } = currentCondition
 
-  const filteredData = isOrIsNotEqualTo === 'is'
-    ? data.filter(dataObject => String(dataObject[columnName]) === value)
-    : data.filter(dataObject => String(dataObject[columnName]) !== value)
+  const filteredData =
+    isOrIsNotEqualTo === 'is'
+      ? data.filter(dataObject => String(dataObject[columnName]) === value)
+      : data.filter(dataObject => String(dataObject[columnName]) !== value)
 
-  return remainingConditions.length === 0
-    ? filteredData
-    : filterDataByConditions(filteredData, remainingConditions)
+  return remainingConditions.length === 0 ? filteredData : filterDataByConditions(filteredData, remainingConditions)
 }
 
 /**
@@ -180,10 +199,7 @@ const formatValuesList = (values: string[], conjunction: string): string[] => {
 /**
  * Validates markup variables configuration
  */
-export const validateMarkupVariables = (
-  markupVariables: MarkupVariable[],
-  data: any[]
-): string[] => {
+export const validateMarkupVariables = (markupVariables: MarkupVariable[], data: any[]): string[] => {
   const errors: string[] = []
 
   if (!markupVariables || !Array.isArray(markupVariables)) {
@@ -197,9 +213,9 @@ export const validateMarkupVariables = (
       errors.push(`Variable ${index + 1}: Tag must be in format {{tagName}}`)
     }
 
-    if (!variable.columnName) {
+    if (!variable.metadataKey && !variable.columnName) {
       errors.push(`Variable ${index + 1}: Column name is required`)
-    } else if (availableColumns.length > 0 && !availableColumns.includes(variable.columnName)) {
+    } else if (variable.columnName && availableColumns.length > 0 && !availableColumns.includes(variable.columnName)) {
       errors.push(`Variable ${index + 1}: Column "${variable.columnName}" not found in data`)
     }
 
@@ -207,7 +223,9 @@ export const validateMarkupVariables = (
       if (!condition.columnName) {
         errors.push(`Variable ${index + 1}, Condition ${condIndex + 1}: Column name is required`)
       } else if (availableColumns.length > 0 && !availableColumns.includes(condition.columnName)) {
-        errors.push(`Variable ${index + 1}, Condition ${condIndex + 1}: Column "${condition.columnName}" not found in data`)
+        errors.push(
+          `Variable ${index + 1}, Condition ${condIndex + 1}: Column "${condition.columnName}" not found in data`
+        )
       }
 
       if (!condition.value) {

package/helpers/metrics/types.ts

@@ -80,3 +80,6 @@ export type ANALYTICS_EVENT_TYPES =
 
   // Image/export events
   | 'image_download' // generic image download event
+
+  // Embed events
+  | 'embed_loaded' // fired when a visualization is loaded via the embed system

package/helpers/palettes/colorDistributions.ts

@@ -53,4 +53,4 @@ export const mapV1ColorDistribution = {
   8: [0, 2, 3, 4, 5, 6, 7, 8],
   9: [0, 1, 2, 3, 4, 5, 6, 7, 8],
   10: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-}
+}

package/helpers/palettes/utils.ts

@@ -1,16 +1,16 @@
-import { map } from 'lodash'
 import { FALLBACK_COLOR_PALETTE_V1, FALLBACK_COLOR_PALETTE_V2, USE_V2_MIGRATION } from '../constants'
 import { getColorPaletteVersion } from '../getColorPaletteVersion'
 import { getPaletteAccessor } from '../getPaletteAccessor'
 import { chartPaletteMigrationMap } from './migratePaletteName'
 import { newMapPaletteNames } from './standardizePaletteNames'
+import { Visualization } from '../../types/Visualization'
 
 /**
  * Gets the current palette name from a visualization config
  * @param config - The visualization config object
  * @returns The current palette name or empty string if not found
  */
-export const getCurrentPaletteName = (config: any): string => {
+export const getCurrentPaletteName = (config: Partial<Visualization>): string => {
   // Check new v2 format first
   if (config?.general?.palette?.name) {
     return config.general.palette.name
@@ -35,7 +35,7 @@ export const getCurrentPaletteName = (config: any): string => {
  * @param colorPalettes - The color palettes object (e.g., mapColorPalettes, chartColorPalettes)
  * @returns The palette colors array or empty array if not found
  */
-export const getPaletteColors = (config: any, colorPalettes: any): string[] => {
+export const getPaletteColors = (config: Partial<Visualization>, colorPalettes: Record<string, Record<string, string[]>>): string[] => {
   // First check for custom colors (v2 format)
   if (config?.general?.palette?.customColors) {
     return config.general.palette.customColors
@@ -65,7 +65,7 @@ export const getPaletteColors = (config: any, colorPalettes: any): string[] => {
  * @param config - The visualization config object
  * @returns True if the config is using v1 palette configuration (which would show conversion modal)
  */
-export const isV1Palette = (config: any): boolean => {
+export const isV1Palette = (config: Partial<Visualization>): boolean => {
   // If v2 migration is disabled globally, don't treat as v1 (no conversion modal)
   if (!USE_V2_MIGRATION) {
     return false
@@ -84,7 +84,7 @@ export const isV1Palette = (config: any): boolean => {
  * @param config - The visualization config object
  * @returns The fallback palette name for the detected version
  */
-export const getFallbackColorPalette = (config: any): string => {
+export const getFallbackColorPalette = (config: Partial<Visualization>): string => {
   const paletteVersion = getColorPaletteVersion(config)
   return paletteVersion === 1 ? FALLBACK_COLOR_PALETTE_V1 : FALLBACK_COLOR_PALETTE_V2
 }
@@ -161,7 +161,7 @@ export const migratePaletteWithMap = (
  * @param config - The visualization config object
  * @returns True if backup data exists
  */
-export const hasPaletteBackup = (config: any): boolean => {
+export const hasPaletteBackup = (config: Partial<Visualization>): boolean => {
   return !!(config?.general?.palette?.backups?.length > 0)
 }
 
@@ -170,7 +170,7 @@ export const hasPaletteBackup = (config: any): boolean => {
  * @param config - The visualization config object
  * @returns The original palette name or null if no backup exists
  */
-export const getOriginalPaletteName = (config: any): string | null => {
+export const getOriginalPaletteName = (config: Partial<Visualization>): string | null => {
   const backups = config?.general?.palette?.backups
   if (!backups || backups.length === 0) return null
 
@@ -184,7 +184,7 @@ export const getOriginalPaletteName = (config: any): string | null => {
  * @param config - The visualization config object
  * @returns The original two-color palette name or null if no backup exists
  */
-export const getOriginalTwoColorPaletteName = (config: any): string | null => {
+export const getOriginalTwoColorPaletteName = (config: Partial<Visualization>): string | null => {
   const backups = config?.general?.palette?.backups
   if (!backups || backups.length === 0) return null
 
@@ -198,7 +198,7 @@ export const getOriginalTwoColorPaletteName = (config: any): string | null => {
  * @param config - The visualization config object
  * @returns True if two-color backup data exists
  */
-export const hasTwoColorPaletteBackup = (config: any): boolean => {
+export const hasTwoColorPaletteBackup = (config: Partial<Visualization>): boolean => {
   const backups = config?.general?.palette?.backups
   if (!backups || backups.length === 0) return false
   return backups.some((backup: any) => backup.type === 'twoColor')
@@ -209,7 +209,7 @@ export const hasTwoColorPaletteBackup = (config: any): boolean => {
  * @param config - The visualization config object to modify
  * @returns True if rollback was successful, false if no backup available
  */
-export const rollbackPaletteToOriginal = (config: any): boolean => {
+export const rollbackPaletteToOriginal = (config: Partial<Visualization>): boolean => {
   const backups = config?.general?.palette?.backups
   if (!backups || backups.length === 0) {
     return false
@@ -230,7 +230,7 @@ export const rollbackPaletteToOriginal = (config: any): boolean => {
     config.general.palette.version = '1.0' // Reset to v1
   }
 
-  return config
+  return true
 }
 
 /**
@@ -238,7 +238,7 @@ export const rollbackPaletteToOriginal = (config: any): boolean => {
  * @param config - The visualization config object to modify
  * @returns True if rollback was successful, false if no backup available
  */
-export const rollbackTwoColorPaletteToOriginal = (config: any): boolean => {
+export const rollbackTwoColorPaletteToOriginal = (config: Partial<Visualization>): boolean => {
   const backups = config?.general?.palette?.backups
   if (!backups || backups.length === 0) {
     return false

package/helpers/parseCsvWithQuotes.ts

@@ -2,7 +2,7 @@ import Papa from 'papaparse'
 
 /**
  * Parses CSV text while preserving newlines and commas within quoted fields.
- * 
+ *
  * @param responseText - The raw CSV text to parse
  * @param options - Parsing options
  * @param options.delimiter - The delimiter to use after processing (default: '|')
@@ -17,27 +17,28 @@ export function parseCsvWithQuotes(
   } = {}
 ): any[] {
   const { delimiter = '|', dynamicTyping = false } = options
-  
+
   const NEWLINE_PLACEHOLDER = '__COVE_NEWLINE__'
-  
+  const newlinePlaceholderRegex = new RegExp(NEWLINE_PLACEHOLDER, 'g')
+
   // Preserve newlines in quoted fields by replacing with placeholder
   const quotedFields: string[] = []
   let placeholderIndex = 0
-  let sanitizedText = responseText.replace(/("(?:[^"\\]|\\.|[\s\S])*?")/g, (match) => {
+  let sanitizedText = responseText.replace(/("(?:[^"\\]|\\.|[\s\S])*?")/g, match => {
     const preserved = match.replace(/\n/g, NEWLINE_PLACEHOLDER)
     quotedFields.push(preserved)
     return `__QUOTED_FIELD_${placeholderIndex++}__`
   })
-  
+
   // Replace commas outside quoted fields with pipe delimiter
   sanitizedText = sanitizedText.replace(/(__QUOTED_FIELD_\d+__)|,/g, (...m) => m[1] || delimiter)
-  
-  // Restore quoted fields without outer quotes
-  quotedFields.forEach((field, index) => {
-    const unquoted = field.slice(1, -1).replace(new RegExp(NEWLINE_PLACEHOLDER, 'g'), '\n')
-    sanitizedText = sanitizedText.replace(`__QUOTED_FIELD_${index}__`, unquoted)
+
+  // Restore quoted fields without outer quotes (single pass instead of N passes)
+  sanitizedText = sanitizedText.replace(/__QUOTED_FIELD_(\d+)__/g, (_, idx) => {
+    const field = quotedFields[parseInt(idx, 10)]
+    return field.slice(1, -1).replace(newlinePlaceholderRegex, '\n')
   })
-  
+
   // Parse with Papa.parse
   const parsedCsv = Papa.parse(sanitizedText, {
     header: true,
@@ -45,21 +46,21 @@ export function parseCsvWithQuotes(
     delimiter,
     dynamicTyping
   })
-  
+
   // Restore newlines in parsed data
   const restoredData = parsedCsv.data.map((row: any) => {
     const restoredRow: any = {}
     Object.keys(row).forEach(key => {
       const value = row[key]
       if (typeof value === 'string') {
-        restoredRow[key] = value.replace(new RegExp(NEWLINE_PLACEHOLDER, 'g'), '\n')
+        restoredRow[key] = value.replace(newlinePlaceholderRegex, '\n')
       } else {
         restoredRow[key] = value
       }
     })
     return restoredRow
   })
-  
+
   return restoredData
 }
 

package/helpers/prepareScreenshot.ts

@@ -80,7 +80,7 @@ function findNearestHeadingIndex(parentChildren: Element[], vizWrapperIndex: num
     const child = parentChildren[i] as HTMLElement
 
     // STOP: Another visualization found - don't include its content
-    if (child.classList.contains('cdc-open-viz-module') || child.querySelector('.cdc-open-viz-module')) {
+    if (child.classList.contains('cove-visualization') || child.querySelector('.cove-visualization')) {
       return -1
     }
 
@@ -135,7 +135,7 @@ function buildContextClone(
 }
 
 function isInEditorMode(element: HTMLElement): boolean {
-  return element.closest('.cdc-open-viz-module.isEditor') !== null
+  return element.closest('.cove-visualization.is-editor') !== null
 }
 
 /**
@@ -208,6 +208,23 @@ function convertCanvasToImages(baseSvg: HTMLElement, clonedViz: HTMLElement): vo
   })
 }
 
+/**
+ * Remove width classes that interfere with screenshot sizing
+ */
+function removeWidthClasses(clonedTree: HTMLElement): void {
+  const classesToRemove = ['dfe-block--width-wide', 'dfe-block--width-full_width']
+
+  classesToRemove.forEach(className => {
+    const elements = clonedTree.querySelectorAll(`.${className}`)
+    elements.forEach(el => el.classList.remove(className))
+  })
+
+  // Also check the root element itself
+  classesToRemove.forEach(className => {
+    clonedTree.classList.remove(className)
+  })
+}
+
 /**
  * Expand SVG widths and remove animation classes
  */
@@ -222,7 +239,10 @@ function expandSvgWidths(clonedViz: HTMLElement): void {
     }
 
     // Remove animation classes to show final state immediately
-    svg.classList.remove('animated', 'animate')
+    const isAnimatedPie = svg.classList.contains('animated-pie')
+    if (!isAnimatedPie) {
+      svg.classList.remove('animated', 'animate')
+    }
   })
 }
 
@@ -237,31 +257,34 @@ export function prepareScreenshotContainer(
   // 1. Clone elements (with or without context)
   const { clonedTree, clonedViz } = prepareClonedElements(baseSvg, includeContextInDownload, elementToCapture)
 
-  // 2. Strip all links (not clickable in static image)
+  // 2. Remove width classes that interfere with screenshot sizing
+  removeWidthClasses(clonedTree)
+
+  // 3. Strip all links (not clickable in static image)
   stripLinks(clonedTree)
 
-  // 3. Convert canvas elements to images
+  // 4. Convert canvas elements to images
   convertCanvasToImages(baseSvg, clonedViz)
 
-  // 4. Expand SVG widths to prevent clipping
+  // 5. Expand SVG widths to prevent clipping
   expandSvgWidths(clonedViz)
 
-  // 5. Calculate viz dimensions
+  // 6. Calculate viz dimensions
   const computedStyle = getComputedStyle(baseSvg)
   const vizWidth =
     parseFloat(computedStyle.width) -
     (parseFloat(computedStyle.paddingLeft) || 0) -
     (parseFloat(computedStyle.paddingRight) || 0)
 
-  // 6. Create and style container
+  // 7. Create and style container
   const container = document.createElement('div')
   container.style.width = `${vizWidth + 36}px`
   container.style.padding = '18px'
 
-  // 7. Reset viz padding
+  // 8. Reset viz padding
   clonedViz.style.padding = '0'
 
-  // 8. Append cloned tree to container
+  // 9. Append cloned tree to container
   container.appendChild(clonedTree)
 
   return container

package/helpers/testing.ts

@@ -313,6 +313,50 @@ export const testBooleanControl = async (checkbox: HTMLInputElement, getVisualSt
   expect(secondToggleVisualState).toEqual(initialVisualState)
 }
 
+// ============================================================================
+// VISUALIZATION RENDERING ASSERTIONS
+// ============================================================================
+
+/**
+ * Assert that a visualization has rendered successfully.
+ * Uses performAndAssert to poll until one of these conditions is met:
+ *   ((svgCount > 0 || canvasCount > 0) && hasCoveModule) || isDataBite || isDataTable
+ *
+ * Handles all visualization types:
+ * - Charts (SVG-based)
+ * - Maps with SVG rendering (US state, world, hex, etc.)
+ * - Maps with canvas rendering (county maps via UsaMap.County)
+ * - Data bites (.bite-content)
+ * - Data tables (.data-table)
+ * - Waffle charts (SVG-based)
+ *
+ * Use as a play function in any Components/Templates/ story:
+ *   play: async ({ canvasElement }) => {
+ *     await assertVisualizationRendered(canvasElement)
+ *   }
+ *
+ * @param vizElement The story's canvas element (Storybook's canvasElement)
+ */
+export const assertVisualizationRendered = async (vizElement: HTMLElement) => {
+  await performAndAssert(
+    'Wait for visualization to render',
+    () => {
+      const svgCount = vizElement.querySelectorAll('svg').length
+      const canvasCount = vizElement.querySelectorAll('canvas').length
+      const hasCoveModule = !!vizElement.querySelector('.cove-visualization')
+      const isDataBite = !!vizElement.querySelector('.bite-content')
+      const isDataTable = !!vizElement.querySelector('.type-data-table')
+      return { svgCount, canvasCount, hasCoveModule, isDataBite, isDataTable }
+    },
+    async () => {},
+    (_before, after) => {
+      return (
+        ((after.svgCount > 0 || after.canvasCount > 0) && after.hasCoveModule) || after.isDataBite || after.isDataTable
+      )
+    }
+  )
+}
+
 // ============================================================================
 // DATA EXTRACTION HELPERS
 // ============================================================================

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