@cdc/core 4.25.8 → 4.25.11

package/helpers/palettes/colorDistributions.ts

@@ -0,0 +1,56 @@
+// Chart color distributions for v2 9-color sequential palettes to improve contrast
+// Similar to map distributions but optimized for chart legends
+export const v2ColorDistribution = {
+  1: [4], // Middle color for single item
+  2: [0, 8], // First and middle
+  3: [0, 4, 8], // First, middle, last
+  4: [0, 2, 6, 8], // Evenly spaced
+  5: [0, 2, 4, 6, 8], // Well-distributed
+  6: [0, 1, 3, 5, 7, 8], // Good spacing
+  7: [0, 1, 2, 4, 6, 7, 8], // Skip middle-adjacent
+  8: [0, 1, 2, 3, 5, 6, 7, 8], // Skip one in middle
+  9: [0, 1, 2, 3, 4, 5, 6, 7, 8] // Use all colors
+}
+
+// Enhanced color distributions for divergent palettes to maximize contrast
+// Prioritizes endpoints and avoids the neutral middle region
+export const divergentColorDistribution = {
+  1: [4], // Neutral middle for single item
+  2: [1, 7], // Strong contrast from each end
+  3: [0, 4, 8], // Maximum endpoints plus neutral
+  4: [0, 2, 6, 8], // Well-spaced with emphasis on extremes
+  5: [0, 1, 4, 7, 8], // Skip adjacent to middle, emphasize ends
+  6: [0, 1, 3, 5, 7, 8], // Avoid immediate middle area
+  7: [0, 1, 2, 4, 6, 7, 8], // Skip one middle-adjacent
+  8: [0, 1, 2, 3, 5, 6, 7, 8], // Skip one in middle
+  9: [0, 1, 2, 3, 4, 5, 6, 7, 8] // Use all colors
+}
+
+// Color distribution optimized for colorblind-safe palette accessibility
+// Maximizes perceptual differences for color vision deficiency
+export const colorblindColorDistribution = {
+  1: [0], // Start with strongest color
+  2: [0, 4], // High contrast pair (orange, blue)
+  3: [0, 2, 4], // Orange, green, blue - maximum differentiation
+  4: [0, 1, 2, 4], // Add cyan for more separation
+  5: [0, 1, 2, 4, 5], // Add dark blue for depth
+  6: [0, 1, 2, 4, 5, 6], // Add pink for additional distinction
+  7: [0, 1, 2, 4, 5, 6, 8], // Add brown, skip black temporarily
+  8: [0, 1, 2, 4, 5, 6, 7, 8], // Add black for maximum contrast
+  9: [0, 1, 2, 3, 4, 5, 6, 7, 8] // Use all colors
+}
+
+// Basic color distribution for map v1 compatibility
+// Simple distribution pattern for any palette length up to 10 items
+export const mapV1ColorDistribution = {
+  1: [1],
+  2: [1, 3],
+  3: [1, 3, 5],
+  4: [0, 2, 4, 6],
+  5: [0, 2, 4, 6, 7],
+  6: [0, 2, 3, 4, 5, 7],
+  7: [0, 2, 3, 4, 5, 6, 7],
+  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/migratePaletteName.ts

@@ -0,0 +1,150 @@
+// Chart palette migration map
+export const chartPaletteMigrationMap: Record<string, string> = {
+  yelloworangered: 'sequential_orange',
+  yelloworangebrown: 'sequential_orange',
+  orangered: 'sequential_orange',
+  yellowpurple: 'sequential_orange',
+  red: 'sequential_orange',
+  'Sequential Orange': 'sequential_orange',
+  'Sequential Orange Two': 'sequential_orange',
+  'sequential-orange(MPX)': 'sequential_orange',
+  'sequential-orange-(MPX)': 'sequential_orange',
+  pinkpurple: 'sequential_purple',
+  bluegreen: 'sequential_blue',
+  'sequential-blue': 'sequential_blue',
+  'sequential-blue-2-(MPX)': 'sequential_blue',
+  'sequential-blue-2(MPX)': 'sequential_blue',
+  'Sequential Blue': 'sequential_blue',
+  'sequential Blue Two': 'sequential_blue',
+  'sequential Blue Three': 'sequential_blue',
+  greenblue: 'sequential_green',
+  'Sequential Green': 'sequential_green',
+  qualitative1: 'qualitative_standard',
+  qualitative2: 'qualitative_standard',
+  qualitative3: 'qualitative_standard',
+  qualitative4: 'qualitative_standard',
+  colorblindsafe: 'qualitative_standard',
+  'qualitative-bold': 'qualitative_standard',
+  'qualitative-soft': 'qualitative_standard',
+  // Reverse palette migrations
+  yelloworangeredreverse: 'sequential_orangereverse',
+  yelloworangebrownreverse: 'sequential_orangereverse',
+  orangeredreverse: 'sequential_orangereverse',
+  yellowpurplereverse: 'sequential_orangereverse',
+  redreverse: 'sequential_orangereverse',
+  'Sequential Orangereverse': 'sequential_orangereverse',
+  'Sequential Orange Tworeverse': 'sequential_orangereverse',
+  'sequential-orange(MPX)reverse': 'sequential_orangereverse',
+  'sequential-orange-(MPX)reverse': 'sequential_orangereverse',
+  pinkpurplereverse: 'sequential_purplereverse',
+  bluegreenreverse: 'sequential_bluereverse',
+  'sequential-bluereverse': 'sequential_bluereverse',
+  'sequential-blue-2-(MPX)reverse': 'sequential_bluereverse',
+  'sequential-blue-2(MPX)reverse': 'sequential_bluereverse',
+  'Sequential Bluereverse': 'sequential_bluereverse',
+  'sequential Blue Tworeverse': 'sequential_bluereverse',
+  'sequential Blue Threereverse': 'sequential_bluereverse',
+  greenbluereverse: 'sequential_greenreverse',
+  'Sequential Greenreverse': 'sequential_greenreverse',
+  qualitative1reverse: 'qualitative_standardreverse',
+  qualitative2reverse: 'qualitative_standardreverse',
+  qualitative3reverse: 'qualitative_standardreverse',
+  qualitative4reverse: 'qualitative_standardreverse',
+  colorblindsafereverse: 'qualitative_standardreverse',
+  'qualitative-boldreverse': 'qualitative_standardreverse',
+  'qualitative-softreverse': 'qualitative_standardreverse'
+}
+
+// Map palette migration map  
+export const mapPaletteMigrationMap: Record<string, string> = {
+  sequential_yellow_orange_red: 'sequential_orange',
+  sequential_yellow_orange_brown: 'sequential_orange',
+  sequential_orange_red: 'sequential_orange',
+  sequential_orange_extended: 'sequential_orange',
+  sequential_pink_purple: 'sequential_purple',
+  divergent_yellow_purple: 'divergent_blue_purple',
+  sequential_blue_green: 'sequential_blue',
+  sequential_blue_extended: 'sequential_blue',
+  sequential_green_blue: 'sequential_teal',
+  sequential_red: 'sequential_orange',
+  qualitative_earth_tones: 'qualitative',
+  // Reverse palette migrations
+  sequential_yellow_orange_redreverse: 'sequential_orangereverse',
+  sequential_yellow_orange_brownreverse: 'sequential_orangereverse',
+  sequential_orange_redreverse: 'sequential_orangereverse',
+  sequential_orange_extendedreverse: 'sequential_orangereverse',
+  sequential_pink_purplereverse: 'sequential_purplereverse',
+  divergent_yellow_purplereverse: 'divergent_blue_purplereverse',
+  sequential_blue_greenreverse: 'sequential_bluereverse',
+  sequential_blue_extendedreverse: 'sequential_bluereverse',
+  sequential_green_bluereverse: 'sequential_tealreverse',
+  sequential_redreverse: 'sequential_orangereverse',
+  qualitative_earth_tonesreverse: 'qualitativereverse',
+  'qualitative_bold': 'qualitative_standard',
+  'qualitative_soft': 'qualitative_standard',
+  'qualitative_boldreverse': 'qualitative_standardreverse',
+  'qualitative_softreverse': 'qualitative_standardreverse',
+  'qualitative1': 'qualitative_standard',
+  'qualitative2': 'qualitative_standard',
+  'qualitative3': 'qualitative_standard',
+  'qualitative4': 'qualitative_standard',
+  'colorblindsafe': 'qualitative_standard',
+  'qualitative1reverse': 'qualitative_standardreverse',
+  'qualitative2reverse': 'qualitative_standardreverse',
+  'qualitative3reverse': 'qualitative_standardreverse',
+  'qualitative4reverse': 'qualitative_standardreverse',
+}
+
+// Two-color palette migration map (v1 to v2)
+export const twoColorPaletteMigrationMap: Record<string, string> = {
+  // Monochrome palettes → divergent_blue_purple
+  'monochrome-1': 'divergent_blue_purple',
+  'monochrome-2': 'divergent_blue_purple', 
+  'monochrome-3': 'divergent_blue_purple',
+  'monochrome-4': 'divergent_blue_purple',
+  
+  // Warm palettes → divergent_green_orange
+  'monochrome-5': 'divergent_green_orange',
+  'warm-1': 'divergent_green_orange',
+  
+  // Cool palettes → divergent_blue_cyan
+  'cool-1': 'divergent_blue_cyan',
+  'cool-2': 'divergent_blue_cyan',
+  'cool-3': 'divergent_blue_cyan', 
+  'cool-4': 'divergent_blue_cyan',
+  'cool-5': 'divergent_blue_cyan',
+  
+  // Complementary palettes → divergent_blue_orange
+  'complementary-1': 'divergent_blue_orange',
+  'complementary-2': 'divergent_blue_orange',
+  'complementary-3': 'divergent_blue_orange',
+  'complementary-4': 'divergent_blue_orange',
+  'complementary-5': 'divergent_blue_orange',
+  
+  // Reverse palette migrations
+  'monochrome-1reverse': 'divergent_blue_purplereverse',
+  'monochrome-2reverse': 'divergent_blue_purplereverse',
+  'monochrome-3reverse': 'divergent_blue_purplereverse', 
+  'monochrome-4reverse': 'divergent_blue_purplereverse',
+  'monochrome-5reverse': 'divergent_green_orangereverse',
+  'warm-1reverse': 'divergent_green_orangereverse',
+  'cool-1reverse': 'divergent_blue_cyanreverse',
+  'cool-2reverse': 'divergent_blue_cyanreverse',
+  'cool-3reverse': 'divergent_blue_cyanreverse',
+  'cool-4reverse': 'divergent_blue_cyanreverse',
+  'cool-5reverse': 'divergent_blue_cyanreverse',
+  'complementary-1reverse': 'divergent_blue_orangereverse',
+  'complementary-2reverse': 'divergent_blue_orangereverse',
+  'complementary-3reverse': 'divergent_blue_orangereverse',
+  'complementary-4reverse': 'divergent_blue_orangereverse',
+  'complementary-5reverse': 'divergent_blue_orangereverse'
+}
+
+// Combined palette migration map for backward compatibility
+export const paletteMigrationMap: Record<string, string> = {
+  ...chartPaletteMigrationMap,
+  ...mapPaletteMigrationMap,
+  ...twoColorPaletteMigrationMap
+}
+
+

package/helpers/palettes/standardizePaletteNames.ts

@@ -0,0 +1,77 @@
+// Rename Palettes
+export const newMapPaletteNames = {
+    'yelloworangered': 'sequential_yellow_orange_red',
+    'yelloworangebrown': 'sequential_yellow_orange_brown',
+    'yelloworangebrownreverse': 'sequential_yellow_orange_brownreverse',
+    'pinkpurple': 'sequential_pink_purple',
+    'pinkpurplereverse': 'sequential_pink_purplereverse',
+    'bluegreen': 'sequential_blue_green',
+    'bluegreenreverse': 'sequential_blue_greenreverse',
+    'orangered': 'sequential_orange_red',
+    'orangeredreverse': 'sequential_orange_redreverse',
+    'red': 'sequential_red',
+    'redreverse': 'sequential_red_reverse',
+    'greenblue': 'sequential_green_blue',
+    'greenbluereverse': 'sequential_green_bluereverse',
+    'yelloworangeredreverse': 'sequential_yellow_orange_redreverse',
+    'yellowpurple': 'divergent_yellow_purple',
+    'yellowpurplereverse': 'divergent_yellow_purplereverse',
+    'qualitative1': 'qualitative1',
+    'qualitative2': 'qualitative2',
+    'qualitative3': 'qualitative3',
+    'qualitative4': 'qualitative4',
+    'qualitative9': 'qualitative9',
+    'sequential-blue-2(MPX)': 'sequential_blue_extended',
+    'sequential-blue-2(MPX)reverse': 'sequential_blue_extendedreverse',
+    'sequential-orange(MPX)': 'sequential_orange_extended',
+    'sequential-orange(MPX)reverse': 'sequential_orange_extendedreverse',
+    'colorblindsafe': 'colorblindsafe',
+    'qualitative1reverse': 'qualitative1reverse',
+    'qualitative2reverse': 'qualitative2reverse',
+    'qualitative3reverse': 'qualitative3reverse',
+    'qualitative4reverse': 'qualitative4reverse',
+    'qualitative9reverse': 'qualitative9reverse',
+    'colorblindsafereverse': 'colorblindsafereverse',
+}
+
+export const newChartPaletteNames = {
+    'qualitative-bold': 'qualitative_bold',
+    'qualitative-soft': 'qualitative_soft',
+    'qualitative-standard': 'qualitative_standard',
+    'sequential-blue': 'sequential_blue',
+    'sequential-blue-2-(MPX)': 'sequential_blue_extended',
+    'sequential-orange': 'sequential_orange',
+    'sequential-orange-(MPX)': 'sequential_orange_extended',
+    'sequential-green': 'sequential_green',
+    'sequential-purple': 'sequential_purple',
+    'sequential-teal': 'sequential_teal',
+    'divergent-bluecyan': 'divergent_blue_cyan',
+    'divergent-bluepurple': 'divergent_blue_purple',
+    'divergent-greenorange': 'divergent_green_orange',
+    'divergent-blueorange': 'divergent_blue_orange',
+    'qualitative1': 'qualitative1',
+    'qualitative2': 'qualitative2',
+    'qualitative3': 'qualitative3',
+    'qualitative4': 'qualitative4',
+    'colorblindsafe': 'colorblindsafe',
+    // Reverse variants
+    'qualitative-boldreverse': 'qualitative_boldreverse',
+    'qualitative-softreverse': 'qualitative_softreverse',
+    'qualitative-standardreverse': 'qualitative_standardreverse',
+    'sequential-bluereverse': 'sequential_bluereverse',
+    'sequential-blue-2-(MPX)reverse': 'sequential_blue_extendedreverse',
+    'sequential-orangereverse': 'sequential_orangereverse',
+    'sequential-orange-(MPX)reverse': 'sequential_orange_extendedreverse',
+    'sequential-greenreverse': 'sequential_greenreverse',
+    'sequential-purplereverse': 'sequential_purplereverse',
+    'sequential-tealreverse': 'sequential_tealreverse',
+    'divergent-bluecyanreverse': 'divergent_blue_cyanreverse',
+    'divergent-bluepurplereverse': 'divergent_blue_purplereverse',
+    'divergent-greenorangereverse': 'divergent_green_orangereverse',
+    'divergent-blueorangereverse': 'divergent_blue_orangereverse',
+    'qualitative1reverse': 'qualitative1reverse',
+    'qualitative2reverse': 'qualitative2reverse',
+    'qualitative3reverse': 'qualitative3reverse',
+    'qualitative4reverse': 'qualitative4reverse',
+    'colorblindsafereverse': 'colorblindsafereverse'
+}

package/helpers/palettes/utils.ts

@@ -0,0 +1,267 @@
+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'
+
+/**
+ * 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 => {
+  // Check new v2 format first
+  if (config?.general?.palette?.name) {
+    return config.general.palette.name
+  }
+
+  // Check legacy v1 formats
+  if (config?.palette) {
+    return config.palette
+  }
+
+  if (config?.color) {
+    return config.color
+  }
+
+  const paletteVersion = getColorPaletteVersion(config)
+  return paletteVersion === 1 ? FALLBACK_COLOR_PALETTE_V1 : FALLBACK_COLOR_PALETTE_V2
+}
+
+/**
+ * Gets the palette colors array from a visualization config
+ * @param config - The visualization config object
+ * @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[] => {
+  // First check for custom colors (v2 format)
+  if (config?.general?.palette?.customColors) {
+    return config.general.palette.customColors
+  }
+
+  // Get the raw palette name
+  let paletteName = getCurrentPaletteName(config)
+
+  // Apply v1 palette name migrations if this is a v1 config
+  const paletteVersion = getColorPaletteVersion(config)
+  if (paletteVersion === 1) {
+    paletteName = migratePaletteWithMap(paletteName, chartPaletteMigrationMap, true)
+  }
+
+  // Get the versioned palette accessor
+  const versionedPalettes = getPaletteAccessor(colorPalettes, config)
+
+  if (paletteName && versionedPalettes?.[paletteName]) {
+    return versionedPalettes[paletteName]
+  }
+
+  return []
+}
+
+/**
+ * Determines if the config is using a v1 palette configuration
+ * @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 => {
+  // If v2 migration is disabled globally, don't treat as v1 (no conversion modal)
+  if (!USE_V2_MIGRATION) {
+    return false
+  }
+
+  const currentVersion = getColorPaletteVersion(config)
+  return (
+    currentVersion === 1 ||
+    config?.general?.palette?.version === '1.0' ||
+    !config?.general?.palette?.version
+  )
+}
+
+/**
+ * Returns the appropriate fallback color palette based on the palette version
+ * @param config - The visualization config object
+ * @returns The fallback palette name for the detected version
+ */
+export const getFallbackColorPalette = (config: any): string => {
+  const paletteVersion = getColorPaletteVersion(config)
+  return paletteVersion === 1 ? FALLBACK_COLOR_PALETTE_V1 : FALLBACK_COLOR_PALETTE_V2
+}
+
+/**
+ * Finds a palette name in a migration map using exact match first, then case-insensitive fallback
+ * @param paletteName - The palette name to look up
+ * @param migrationMap - The migration map to search in
+ * @returns The migrated palette name or null if not found
+ */
+export const findPaletteInMigrationMap = (paletteName: string, migrationMap: Record<string, string>): string | null => {
+  // Try exact match first
+  if (migrationMap[paletteName]) {
+    return migrationMap[paletteName]
+  }
+
+  // Try case-insensitive match
+  const lowerCaseName = paletteName.toLowerCase()
+  const matchingKey = Object.keys(migrationMap).find(key => key.toLowerCase() === lowerCaseName)
+
+  return matchingKey ? migrationMap[matchingKey] : null
+}
+
+/**
+ * Handles reverse palette suffix logic for chart palettes
+ * @param originalPaletteName - The original palette name that may have 'reverse' suffix
+ * @param migratedBase - The migrated base name
+ * @returns The properly formatted migrated palette name with reverse suffix if needed
+ */
+export const handleReversePalette = (originalPaletteName: string, migratedBase: string): string => {
+  const isReverse = originalPaletteName.endsWith('reverse')
+  return isReverse ? migratedBase + 'reverse' : migratedBase
+}
+
+/**
+ * Generic migration function that works with any migration map
+ * @param oldPaletteName - The palette name to migrate
+ * @param migrationMap - The migration map to use
+ * @param handleReverse - Whether to handle reverse palette suffixes (for chart palettes)
+ * @returns The migrated palette name or original if no migration found
+ */
+export const migratePaletteWithMap = (
+  oldPaletteName: string,
+  migrationMap: Record<string, string>,
+  handleReverse: boolean = false
+): string => {
+  // Handle null/undefined/empty cases - maintain original behavior
+  if (!oldPaletteName) {
+    return oldPaletteName
+  }
+
+  if (handleReverse) {
+    // Chart palette logic - handle reverse suffix
+    const isReverse = oldPaletteName.endsWith('reverse')
+    const basePaletteName = isReverse ? oldPaletteName.slice(0, -7) : oldPaletteName
+
+    const migratedBase = findPaletteInMigrationMap(basePaletteName, migrationMap)
+    if (migratedBase) {
+      return handleReversePalette(oldPaletteName, migratedBase)
+    }
+  } else {
+    // Map palette logic - direct lookup
+    const migrated = findPaletteInMigrationMap(oldPaletteName, migrationMap)
+    if (migrated) {
+      return migrated
+    }
+  }
+
+  return oldPaletteName
+}
+
+/**
+ * Checks if a config has palette backup data available for rollback
+ * @param config - The visualization config object
+ * @returns True if backup data exists
+ */
+export const hasPaletteBackup = (config: any): boolean => {
+  return !!(config?.general?.palette?.backups?.length > 0)
+}
+
+/**
+ * Gets the original palette name from backup data
+ * @param config - The visualization config object
+ * @returns The original palette name or null if no backup exists
+ */
+export const getOriginalPaletteName = (config: any): string | null => {
+  const backups = config?.general?.palette?.backups
+  if (!backups || backups.length === 0) return null
+
+  // Get the most recent backup (last in array)
+  const latestBackup = backups[backups.length - 1]
+  return latestBackup?.name || null
+}
+
+/**
+ * Gets the original two-color palette name from backup data
+ * @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 => {
+  const backups = config?.general?.palette?.backups
+  if (!backups || backups.length === 0) return null
+
+  // Find the two-color palette backup
+  const twoColorBackup = backups.find((backup: any) => backup.type === 'twoColor')
+  return twoColorBackup?.name || null
+}
+
+/**
+ * Checks if a config has two-color palette backup data available for rollback
+ * @param config - The visualization config object
+ * @returns True if two-color backup data exists
+ */
+export const hasTwoColorPaletteBackup = (config: any): boolean => {
+  const backups = config?.general?.palette?.backups
+  if (!backups || backups.length === 0) return false
+  return backups.some((backup: any) => backup.type === 'twoColor')
+}
+
+/**
+ * Rolls back palette configuration to original pre-migration state
+ * @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 => {
+  const backups = config?.general?.palette?.backups
+  if (!backups || backups.length === 0) {
+    return false
+  }
+
+  // Get the most recent backup
+  const latestBackup = backups[backups.length - 1]
+  if (!latestBackup?.name) {
+    return false
+  }
+
+  // Restore the original configuration
+  if (config.type === 'map') {
+    config.general.palette.name = newMapPaletteNames[latestBackup.name] || latestBackup.name
+    config.general.palette.version = '1.0' // Reset to v1
+  } else if (config.type === 'chart') {
+    config.general.palette.name = chartPaletteMigrationMap[latestBackup.name] || latestBackup.name
+    config.general.palette.version = '1.0' // Reset to v1
+  }
+
+  return config
+}
+
+/**
+ * Rolls back two-color palette configuration to original pre-migration state
+ * @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 => {
+  const backups = config?.general?.palette?.backups
+  if (!backups || backups.length === 0) {
+    return false
+  }
+
+  // Find the two-color palette backup
+  const twoColorBackup = backups.find((backup: any) => backup.type === 'twoColor')
+  if (!twoColorBackup?.name) {
+    return false
+  }
+
+  // Restore the original two-color palette configuration
+  if (config.twoColor) {
+    config.twoColor.palette = twoColorBackup.name
+    config.twoColor.isPaletteReversed = twoColorBackup.isReversed || false
+  }
+
+  // Reset to v1
+  if (config.general?.palette) {
+    config.general.palette.version = twoColorBackup.version || '1.0'
+    // Remove the two-color backup since we've rolled back
+    config.general.palette.backups = backups.filter((backup: any) => backup.type !== 'twoColor')
+  }
+
+  return true
+}

package/helpers/parseCsvWithQuotes.ts

@@ -0,0 +1,65 @@
+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: '|')
+ * @param options.dynamicTyping - Whether to automatically convert types (default: false)
+ * @returns Parsed CSV data as an array of objects
+ */
+export function parseCsvWithQuotes(
+  responseText: string,
+  options: {
+    delimiter?: string
+    dynamicTyping?: boolean
+  } = {}
+): any[] {
+  const { delimiter = '|', dynamicTyping = false } = options
+  
+  const NEWLINE_PLACEHOLDER = '__COVE_NEWLINE__'
+  
+  // Preserve newlines in quoted fields by replacing with placeholder
+  const quotedFields: string[] = []
+  let placeholderIndex = 0
+  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)
+  })
+  
+  // Parse with Papa.parse
+  const parsedCsv = Papa.parse(sanitizedText, {
+    header: true,
+    skipEmptyLines: true,
+    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')
+      } else {
+        restoredRow[key] = value
+      }
+    })
+    return restoredRow
+  })
+  
+  return restoredData
+}
+

package/helpers/queryStringUtils.ts

@@ -49,3 +49,16 @@ export function removeQueryParam(key: string) {
   delete queryParams[key]
   updateQueryString(queryParams)
 }
+
+/**
+ * Checks if developer mode is enabled via URL parameter
+ * @returns true if isCoveDeveloper URL parameter is present and truthy
+ */
+export function isCoveDeveloperMode(): boolean {
+  const param = getQueryParam('isCoveDeveloper')
+  if (!param) return false
+
+  // Handle various truthy values
+  const lowerParam = param.toLowerCase()
+  return lowerParam === 'true' || lowerParam === '1' || lowerParam === 'yes'
+}