@cdc/dashboard 4.24.5 → 4.24.9-1

package/src/helpers/getFilteredData.ts

@@ -10,14 +10,14 @@ export const getApplicableFilters = (dashboard: Dashboard, key: string | number)
   return c?.length > 0 ? c : false
 }
 
-export const getFilteredData = (state: DashboardState, initialFilteredData = {}, dataOverride?: Object) => {
-  const newFilteredData = initialFilteredData
+export const getFilteredData = (state: DashboardState, initialFilteredData?: Record<string, any>, dataOverride?: Object) => {
+  const newFilteredData = initialFilteredData || {}
   const { config } = state
   getVizKeys(config).forEach(key => {
     const applicableFilters = getApplicableFilters(config.dashboard, key)
     if (applicableFilters) {
       const { dataKey, data, dataDescription } = config.visualizations[key]
-      const _data = state.data[dataKey] || data
+      const _data = (dataOverride || state.data)[dataKey] || data
       const formattedData = dataOverride?.[dataKey] || (dataDescription ? getFormattedData(_data, dataDescription) : _data)
 
       newFilteredData[key] = filterData(applicableFilters, formattedData)
@@ -26,12 +26,14 @@ export const getFilteredData = (state: DashboardState, initialFilteredData = {},
   config.rows.forEach((row, index) => {
     if (row.dataKey) {
       const applicableFilters = getApplicableFilters(config.dashboard, index)
+      const { dataKey, data, dataDescription } = row
+      const _data = (dataOverride || state.data)[dataKey] || data
       if (applicableFilters) {
-        const { dataKey, data, dataDescription } = row
-        const _data = state.data[dataKey] || data
         const formattedData = dataOverride?.[dataKey] ?? dataDescription ? getFormattedData(_data, dataDescription) : _data
 
         newFilteredData[index] = filterData(applicableFilters, formattedData)
+      } else {
+        newFilteredData[index] = _data || []
       }
     }
   })

package/src/helpers/getVizConfig.ts

@@ -1,12 +1,33 @@
 import _ from 'lodash'
 import { MultiDashboardConfig } from '../types/MultiDashboard'
 import DataTransform from '@cdc/core/helpers/DataTransform'
+import { getApplicableFilters } from './getFilteredData'
+import { filterData } from './filterData'
+import Footnotes from '@cdc/core/types/Footnotes'
 
 const transform = new DataTransform()
 
+export const getFootnotesVizConfig = (vizKey: string, rowNumber: number, config: MultiDashboardConfig) => {
+  const visualizationConfig = _.cloneDeep(config.visualizations[vizKey])
+
+  const data = config.datasets[visualizationConfig.dataKey]?.data
+  const dataColumns = data?.length ? Object.keys(data[0]) : []
+  const filters = (getApplicableFilters(config.dashboard, rowNumber) || []).filter(filter => dataColumns.includes(filter.columnName))
+  if (filters.length) {
+    visualizationConfig.formattedData = filterData(filters, data)
+  }
+  visualizationConfig.data = data
+  return visualizationConfig as Footnotes
+}
+
 export const getVizConfig = (visualizationKey: string, rowNumber: number, config: MultiDashboardConfig, data: Object, filteredData?: Object) => {
+  if (rowNumber === undefined) return {}
   const visualizationConfig = _.cloneDeep(config.visualizations[visualizationKey])
   const rowData = config.rows[rowNumber]
+  if (rowData.footnotesId && rowData.footnotesId === visualizationKey) {
+    // return the footnotes visualization config with filtered data
+    return getFootnotesVizConfig(visualizationKey, rowNumber, config)
+  }
   if (rowData?.dataKey) {
     // data configured on the row
     Object.assign(visualizationConfig, _.pick(rowData, ['dataKey', 'dataDescription', 'formattedData', 'data']))
@@ -16,13 +37,13 @@ export const getVizConfig = (visualizationKey: string, rowNumber: number, config
   const filteredVizData = filteredData?.[rowNumber] ?? filteredData?.[visualizationKey]
 
   if (filteredVizData) {
-    visualizationConfig.data = filteredVizData
+    visualizationConfig.data = filteredVizData || []
     if (visualizationConfig.formattedData) {
       visualizationConfig.formattedData = visualizationConfig.data
     }
   } else {
     const dataKey = visualizationConfig.dataKey || 'backwards-compatibility'
-    visualizationConfig.data = data[dataKey]
+    visualizationConfig.data = data[dataKey] || []
     if (visualizationConfig.formattedData) {
       visualizationConfig.formattedData = transform.developerStandardize(visualizationConfig.data, visualizationConfig.dataDescription) || visualizationConfig.data
     }

package/src/helpers/getVizRowColumnLocator.ts

@@ -1,9 +1,10 @@
 import { ConfigRow } from '../types/ConfigRow'
 
-export const getVizRowColumnLocator = (rows: ConfigRow[]) =>
+export const getVizRowColumnLocator = (rows: ConfigRow[]): Record<string, { row: number; column: number }> =>
   rows.reduce((acc, curr, index) => {
     curr.columns?.forEach((column, columnIndex) => {
       if (column.widget !== undefined) acc[column.widget] = { row: index, column: columnIndex }
     })
+    if (curr.footnotesId) acc[curr.footnotesId] = { row: index, column: 0 }
     return acc
   }, {})

package/src/helpers/hasDashboardApplyBehavior.ts

@@ -0,0 +1,5 @@
+import { AnyVisualization } from '@cdc/core/types/Visualization'
+
+export const hasDashboardApplyBehavior = (visualizations: Record<string, AnyVisualization>) => {
+  return Object.values(visualizations).some(v => v.filterBehavior === 'Apply Button' && v.type === 'dashboardFilters')
+}

package/src/helpers/iconHash.tsx

@@ -1,10 +1,11 @@
 import Icon from '@cdc/core/components/ui/Icon'
-import { Visualization } from '@cdc/core/types/Visualization'
+import { AnyVisualization } from '@cdc/core/types/Visualization'
 
 export const iconHash = {
   'data-bite': <Icon display='databite' base />,
   Bar: <Icon display='chartBar' base />,
   'Spark Line': <Icon display='chartLine' />,
+  'Bump Chart': <Icon display='chartLine' />,
   'waffle-chart': <Icon display='grid' base />,
   'markup-include': <Icon display='code' base />,
   Line: <Icon display='chartLine' base />,
@@ -14,14 +15,15 @@ export const iconHash = {
   world: <Icon display='mapWorld' base />,
   'single-state': <Icon display='mapAl' base />,
   gear: <Icon display='gear' base />,
+  gearMulti: <Icon display='gearMulti' base />,
   tools: <Icon display='tools' base />,
   'filtered-text': <Icon display='filtered-text' base />,
-  'filter-dropdowns': <Icon display='filter-dropdowns' base />,
+  dashboardFilters: <Icon display='dashboardFilters' base />,
   table: <Icon display='table' base />,
   Sankey: <Icon display='sankey' base />
 }
 
-export const getIcon = (visualization: Visualization) => {
+export const getIcon = (visualization: AnyVisualization) => {
   const { type, visualizationType, general } = visualization
   if (visualizationType) return iconHash[visualizationType]
   if (general?.geoType) {

package/src/helpers/loadAPIFilters.ts

@@ -0,0 +1,74 @@
+import _ from 'lodash'
+import { APIFilterDropdowns } from '../components/DashboardFilters'
+import { SharedFilter } from '../types/SharedFilter'
+import * as apiFilterHelpers from './apiFilterHelpers'
+import { APIFilter } from '../types/APIFilter'
+
+export const loadAPIFiltersFactory = (
+  dispatch: Function,
+  setAPIFilterDropdowns: Function,
+  autoLoadFilterIndexes: number[]
+) => {
+  const loadAPIFilters = (
+    sharedFilters: SharedFilter[],
+    dropdowns: APIFilterDropdowns,
+    recursiveLimit = 3
+  ): Promise<SharedFilter[]> => {
+    if (!sharedFilters) return
+    sharedFilters = sharedFilters.map((filter, index) =>
+      apiFilterHelpers.setAutoLoadDefaultValue(
+        index,
+        dropdowns[filter.apiFilter?.apiEndpoint],
+        sharedFilters,
+        autoLoadFilterIndexes
+      )
+    )
+    const sharedAPIFilters = sharedFilters.filter(f => f.apiFilter)
+    const filterLookup = new Map(sharedAPIFilters.map(filter => [filter.apiFilter.apiEndpoint, filter.apiFilter]))
+    const toFetch = apiFilterHelpers.getToFetch(sharedFilters, dropdowns)
+    const newDropdowns = _.cloneDeep(dropdowns)
+    return Promise.all(
+      Object.keys(toFetch).map(
+        endpoint =>
+          new Promise<void>(resolve => {
+            fetch(endpoint)
+              .then(resp => resp.json())
+              .then(data => {
+                if (!Array.isArray(data)) {
+                  console.error('COVE only supports response data in the shape Array<Object>')
+                  return
+                }
+                const [_key, index] = toFetch[endpoint]
+                const apiFilter = filterLookup.get(_key) as APIFilter
+                const _filterValues = apiFilterHelpers.getFilterValues(data, apiFilter)
+                newDropdowns[_key] = _filterValues
+                const newDefaultSelectedFilter = apiFilterHelpers.setAutoLoadDefaultValue(
+                  index,
+                  _filterValues,
+                  sharedFilters,
+                  autoLoadFilterIndexes
+                )
+                sharedFilters[index] = newDefaultSelectedFilter
+              })
+              .catch(console.error)
+              .finally(() => {
+                resolve()
+              })
+          })
+      )
+    ).then(() => {
+      const finishedLoading = sharedFilters.reduce((acc, curr, index) => {
+        if (autoLoadFilterIndexes.includes(index) && !curr.active) return false
+        return acc
+      }, true)
+      if (finishedLoading || recursiveLimit === 0) {
+        setAPIFilterDropdowns(newDropdowns)
+        dispatch({ type: 'SET_SHARED_FILTERS', payload: sharedFilters })
+        return sharedFilters
+      } else {
+        return loadAPIFilters(sharedFilters, newDropdowns, recursiveLimit - 1)
+      }
+    })
+  }
+  return loadAPIFilters
+}

package/src/helpers/mapDataToConfig.ts

@@ -0,0 +1,29 @@
+import { getFormattedData } from './getFormattedData'
+import { DashboardConfig } from '../types/DashboardConfig'
+
+const mapDataToVisualizations = (config: DashboardConfig) => {
+  Object.keys(config.visualizations).forEach((vizKey, i) => {
+    const viz = config.visualizations[vizKey]
+    if (viz.dataKey && !viz.data) {
+      const data = config.datasets[viz.dataKey].data
+      config.visualizations[vizKey].data = data
+      config.visualizations[vizKey].formattedData = getFormattedData(data, viz.dataDescription)
+    }
+  })
+}
+
+const mapDataToRows = (config: DashboardConfig) => {
+  config.rows.forEach((row, i) => {
+    if (row.dataKey && !row.data) {
+      const data = config.datasets[row.dataKey].data
+      config.rows[i].data = data
+      config.rows[i].formattedData = getFormattedData(data, row.dataDescription)
+    }
+  })
+}
+
+export const mapDataToConfig = (config: DashboardConfig) => {
+  mapDataToVisualizations(config)
+  mapDataToRows(config)
+  return config
+}

package/src/helpers/processData.ts

@@ -1,10 +1,9 @@
-import { FilterBehavior } from '../components/Header/Header'
 import { DataSet } from '../types/DataSet'
 import fetchRemoteData from '@cdc/core/helpers/fetchRemoteData'
 import { getFormattedData } from './getFormattedData'
 
-export const processData = async (dataSet: DataSet, filterBehavior) => {
-  if (dataSet.dataUrl && filterBehavior !== FilterBehavior.Apply) {
+export const processData = async (dataSet: DataSet, hasFilterChangeBehavior: boolean) => {
+  if (dataSet.dataUrl && hasFilterChangeBehavior) {
     const dataset = await fetchRemoteData(`${dataSet.dataUrl}`)
     return getFormattedData(dataset, dataSet.dataDescription)
   }

package/src/helpers/reloadURLHelpers.ts

@@ -0,0 +1,102 @@
+import { gatherQueryParams } from '@cdc/core/helpers/gatherQueryParams'
+import { SharedFilter } from '../types/SharedFilter'
+import { capitalizeSplitAndJoin } from '@cdc/core/helpers/cove/string'
+import { AnyVisualization, Visualization } from '@cdc/core/types/Visualization'
+import _ from 'lodash'
+
+export const isUpdateNeeded = (
+  filters: SharedFilter[],
+  currentQueryParams: Record<string, string>,
+  newQueryParams: Record<string, string>
+): boolean => {
+  let needsUpdate = false
+  filters.find(filter => {
+    if (filter.type === 'urlfilter' && !Array.isArray(filter.active) && filter.filterBy === 'File Name') {
+      needsUpdate = true
+      return true
+    }
+  })
+  Object.keys(newQueryParams).forEach(updatedParam => {
+    if (decodeURIComponent(newQueryParams[updatedParam]) !== currentQueryParams[updatedParam]) {
+      needsUpdate = true
+    }
+  })
+  return needsUpdate
+}
+
+export const getDataURL = (updatedQSParams: Record<string, string | string[]>, dataUrl: URL, newFileName: string) => {
+  const _params = Object.keys(updatedQSParams).flatMap(key => {
+    const value = updatedQSParams[key]
+    if (value === undefined) return []
+    if (typeof value === 'string' && (value as String).match(/undefined/)) return []
+    if (Array.isArray(value)) return value.map(v => ({ key, value: v }))
+    return { key, value }
+  })
+  const baseURL = dataUrl.origin + dataUrl.pathname
+  let dataUrlFinal = `${baseURL}${gatherQueryParams(baseURL, _params)}`
+
+  if (newFileName !== '') {
+    const fileExtension = dataUrl.pathname.split('.').pop()
+    const pathWithoutFilename = dataUrl.pathname.substring(0, dataUrl.pathname.lastIndexOf('/'))
+    dataUrlFinal = `${dataUrl.origin}${pathWithoutFilename}/${newFileName}.${fileExtension}${gatherQueryParams(
+      baseURL,
+      _params
+    )}`
+  }
+  return dataUrlFinal
+}
+
+export const getNewFileName = (newFileName: string, filter: SharedFilter, datasetKey: string) => {
+  const replacements = {
+    'Remove Spaces': '',
+    'Keep Spaces': ' ',
+    'Replace With Underscore': '_'
+  }
+  let fileName = newFileName
+  if (filter.datasetKey === datasetKey) {
+    if (filter.fileName) {
+      // if a file name is found, ie, state_${query}, use that, ie. state_activeFilter.json
+      fileName = capitalizeSplitAndJoin.call(
+        String(filter.fileName),
+        ' ',
+        replacements[filter.whitespaceReplacement ?? 'Keep Spaces']
+      )
+    } else {
+      // if no file name is entered use the default active filter. ie. /activeFilter.json
+      fileName = filter.active as string
+    }
+  }
+
+  if (fileName?.includes('${query}')) {
+    fileName = fileName.replace(
+      '${query}',
+      capitalizeSplitAndJoin.call(
+        String(filter.active),
+        ' ',
+        replacements[filter.whitespaceReplacement ?? 'Keep Spaces']
+      )
+    )
+  }
+
+  return fileName
+}
+
+export const getVisualizationsWithFormattedData = (visualizations: Record<string, Visualization>, newData: Object) => {
+  return Object.keys(visualizations).reduce((acc, vizKey) => {
+    const dataKey = visualizations[vizKey].dataKey
+    if (newData[dataKey]) {
+      acc[vizKey].formattedData = newData[dataKey]
+    }
+    return acc
+  }, _.cloneDeep(visualizations))
+}
+
+export const filterUsedByDataUrl = (
+  filter: SharedFilter,
+  datasetKey: string,
+  visualizations: Record<string, AnyVisualization>
+) => {
+  if (!filter.usedBy || !filter.usedBy.length) return true
+  const vizUsingFilters = filter.usedBy?.map(vizKey => visualizations[vizKey])
+  return vizUsingFilters?.some(viz => viz?.dataKey === datasetKey)
+}

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

@@ -0,0 +1,44 @@
+import { SharedFilter } from '../../types/SharedFilter'
+import { addValuesToDashboardFilters } from '../addValuesToDashboardFilters'
+
+describe('addValuesToDashboardFilters', () => {
+  const colA = { columnName: 'colA', id: 11, active: 'apple', values: [], type: 'datafilter' } as SharedFilter
+  const colB = { columnName: 'colB', id: 22, active: '1', values: [], type: 'datafilter' } as SharedFilter
+  const colC = { columnName: 'colC', id: 33, values: [], setByQueryParameter: 'colC', type: 'datafilter' } as SharedFilter
+
+  const data = {
+    key: [
+      { colA: 'apple', colB: 3, colC: 'abc' },
+      { colA: 'apple', colB: 1, colC: 'bcd' },
+      { colA: 'pear', colB: 4, colC: 'test' }
+    ]
+  }
+  const filters = [colA, colC, colB]
+  it('adds filter values', () => {
+    const newFilters = addValuesToDashboardFilters(filters, data)
+    expect(newFilters[0].values).toEqual(['apple', 'pear'])
+  })
+  it('converts to multiselect', () => {
+    colA.multiSelect = true
+    const newFilters = addValuesToDashboardFilters(filters, data)
+    expect(newFilters[0].active).toEqual(['apple'])
+  })
+
+  it('sets active value by query string', () => {
+    delete window.location
+    window.location = new URL('https://www.example.com?colC=test')
+    const newFilters = addValuesToDashboardFilters(filters, data)
+    expect(newFilters[1].active).toEqual('test')
+  })
+  const colA2 = { apiFilter: { valueSelector: 'colA' }, id: 11, active: 'apple', values: [], type: 'urlfilter' } as SharedFilter
+  const colB2 = { apiFilter: { valueSelector: 'colB' }, id: 22, active: '1', values: [], type: 'urlfilter' } as SharedFilter
+  const colC2 = { apiFilter: { valueSelector: 'colC' }, id: 33, values: [], setByQueryParameter: 'colC', type: 'urlfilter' } as SharedFilter
+  const filters2 = [colA2, colC2, colB2]
+  it('skips urlfilters', () => {
+    // urlfilter reloading happens in the dashboard in the loadAPIFilters function
+    delete window.location
+    window.location = new URL('https://www.example.com?colC=test')
+    const newFilters = addValuesToDashboardFilters(filters2, data)
+    expect(newFilters[1].active).toEqual(undefined)
+  })
+})

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

@@ -0,0 +1,155 @@
+import { setAutoLoadDefaultValue, getToFetch, getFilterValues, getLoadingFilterMemo } from '../apiFilterHelpers'
+import _ from 'lodash'
+import type { APIFilterDropdowns } from '../../components/DashboardFilters'
+
+describe('getLoadingFilterMemo', () => {
+  it('should return correct APIFilterDropdowns for valid inputs', () => {
+    const sharedAPIFilters = ['endpoint1', 'endpoint2']
+    const apiFilterDropdowns: APIFilterDropdowns = {
+      endpoint1: { text: 'text1', value: 'value1' }
+    }
+    const expectedOutput: APIFilterDropdowns = {
+      endpoint1: { text: 'text1', value: 'value1' },
+      endpoint2: null
+    }
+    expect(getLoadingFilterMemo(sharedAPIFilters, apiFilterDropdowns)).toEqual(expectedOutput)
+  })
+
+  it('should return an empty object for empty sharedAPIFilters', () => {
+    const sharedAPIFilters: string[] = []
+    const apiFilterDropdowns: APIFilterDropdowns = {
+      endpoint1: { text: 'text1', value: 'value1' }
+    }
+    const expectedOutput: APIFilterDropdowns = {}
+    expect(getLoadingFilterMemo(sharedAPIFilters, apiFilterDropdowns)).toEqual(expectedOutput)
+  })
+
+  it('should return APIFilterDropdowns with null values for empty apiFilterDropdowns', () => {
+    const sharedAPIFilters = ['endpoint1', 'endpoint2']
+    const apiFilterDropdowns: APIFilterDropdowns = {}
+    const expectedOutput: APIFilterDropdowns = {
+      endpoint1: null,
+      endpoint2: null
+    }
+    expect(getLoadingFilterMemo(sharedAPIFilters, apiFilterDropdowns)).toEqual(expectedOutput)
+  })
+
+  it('should not overwrite existing data in apiFilterDropdowns, so return original dropdowns', () => {
+    const sharedAPIFilters = ['endpoint1', 'endpoint2']
+    const apiFilterDropdowns: APIFilterDropdowns = {
+      endpoint1: { text: 'text1', value: 'value1' },
+      endpoint2: { text: 'text2', value: 'value2' }
+    }
+    expect(getLoadingFilterMemo(sharedAPIFilters, apiFilterDropdowns)).toEqual(apiFilterDropdowns)
+  })
+})
+
+describe('getFilterValues', () => {
+  it('should return correct filter values for valid inputs', () => {
+    const data = [{ key1: 'value1', key2: 'value2' }]
+    const apiFilter = { textSelector: 'key1', valueSelector: 'key2' }
+    const expectedOutput = [{ text: 'value1', value: 'value2' }]
+    expect(getFilterValues(data, apiFilter)).toEqual(expectedOutput)
+    delete apiFilter.textSelector
+    const expectedOutput2 = [{ text: 'value2', value: 'value2' }]
+    expect(getFilterValues(data, apiFilter)).toEqual(expectedOutput2)
+  })
+})
+
+describe('getToFetch', () => {
+  it('should return an empty object when sharedAPIFilters is empty', () => {
+    const result = getToFetch([], {})
+    expect(result).toEqual({})
+  })
+
+  it('should return an object with endpoints when apiFilterDropdowns is empty', () => {
+    const sharedAPIFilters = [{ apiFilter: { apiEndpoint: '/endpoint1' }, parents: [] }]
+    const result = getToFetch(sharedAPIFilters, {})
+    expect(result).toEqual({ '/endpoint1': ['/endpoint1', 0] })
+  })
+
+  it('should return and empty object when sharedAPIFilters contains filters with no parents', () => {
+    const sharedAPIFilters = [{ apiFilter: { apiEndpoint: '/endpoint1' }, parents: [] }]
+    const apiFilterDropdowns = { '/endpoint1': true }
+    const result = getToFetch(sharedAPIFilters, apiFilterDropdowns)
+    expect(result).toEqual({})
+  })
+
+  it('should return an empty object when parentParams contains an empty value', () => {
+    const sharedAPIFilters = [
+      { key: 'parent1', apiFilter: { apiEndpoint: '/endpoint1' }, parents: [] },
+      { apiFilter: { apiEndpoint: '/endpoint1' }, parents: ['parent1'] }
+    ]
+    const apiFilterDropdowns = { '/endpoint1': true }
+    const result = getToFetch(sharedAPIFilters, apiFilterDropdowns)
+    expect(result).toEqual({})
+  })
+
+  it('should return an empty object when parentParams contains an empty value', () => {
+    const sharedAPIFilters = [
+      { key: 'parent1', value: '', apiFilter: { apiEndpoint: '/endpoint1' }, parents: [] },
+      { apiFilter: { apiEndpoint: '/endpoint1' }, parents: ['parent1'] }
+    ]
+    const apiFilterDropdowns = { '/endpoint1': true }
+    const result = getToFetch(sharedAPIFilters, apiFilterDropdowns)
+    expect(result).toEqual({})
+  })
+})
+
+describe('setAutoLoadDefaultValue', () => {
+  const dropdownOptions = [
+    { value: 'option1', label: 'Option 1' },
+    { value: 'option2', label: 'Option 2' }
+  ]
+
+  const sharedFilters = [
+    { key: 'filter1', active: null, queuedActive: null, parents: [] },
+    { key: 'filter2', active: null, queuedActive: null, parents: ['filter1'] }
+  ]
+
+  it('should return the original filter when autoLoadFilterIndexes is empty', () => {
+    const result = setAutoLoadDefaultValue(0, dropdownOptions, sharedFilters, [])
+    expect(result).toEqual(sharedFilters[0])
+  })
+
+  it('should return the original filter when dropdownOptions is empty', () => {
+    const result = setAutoLoadDefaultValue(0, [], sharedFilters, [0])
+    expect(result).toEqual(sharedFilters[0])
+  })
+
+  it('should return the original filter when dropdownOptions is undefined', () => {
+    const result = setAutoLoadDefaultValue(0, undefined, sharedFilters, [0])
+    expect(result).toEqual(sharedFilters[0])
+  })
+
+  it('should return the original filter when sharedFilterIndex is not in autoLoadFilterIndexes', () => {
+    const result = setAutoLoadDefaultValue(0, dropdownOptions, sharedFilters, [1])
+    expect(result).toEqual(sharedFilters[0])
+  })
+
+  it('should return the original filter when not all parent filters are selected', () => {
+    const result = setAutoLoadDefaultValue(1, dropdownOptions, sharedFilters, [1])
+    expect(result).toEqual(sharedFilters[1])
+  })
+
+  it('should assign the default value from dropdownOptions when no active value is set', () => {
+    const sharedFiltersCopy = _.cloneDeep(sharedFilters)
+    sharedFiltersCopy[0].active = null
+    const result = setAutoLoadDefaultValue(0, dropdownOptions, sharedFiltersCopy, [0])
+    expect(result.active).toEqual('option1')
+  })
+
+  it('should retain the current active value if it exists in dropdownOptions', () => {
+    const sharedFiltersCopy = _.cloneDeep(sharedFilters)
+    sharedFiltersCopy[0].active = 'option1'
+    const result = setAutoLoadDefaultValue(0, dropdownOptions, sharedFiltersCopy, [0])
+    expect(result.active).toEqual('option1')
+  })
+
+  it('should assign the default value if the current active value does not exist in dropdownOptions', () => {
+    const sharedFiltersCopy = _.cloneDeep(sharedFilters)
+    sharedFiltersCopy[0].active = 'nonexistent'
+    const result = setAutoLoadDefaultValue(0, dropdownOptions, sharedFiltersCopy, [0])
+    expect(result.active).toEqual('option1')
+  })
+})

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

@@ -1,3 +1,4 @@
+import _ from 'lodash'
 import { SharedFilter } from '../../types/SharedFilter'
 import { filterData } from '../filterData'
 
@@ -36,48 +37,6 @@ describe('filterData', () => {
     expect(result).toEqual([{ name: 'John', age: 30 }])
   })
 
-  it('causes sideEffects to filters', () => {
-    // the side effect is not desired, but current functionality depends on the sideEffect.
-    // hopefully the side effect will be refactored in the future to be a returned value.
-    const filters = [
-      { columnName: 'name', active: 'John', queuedActive: 'John', fileName: 'abc', key: 'name' },
-      { columnName: 'age', fileName: 'abc', key: 'age' },
-      { columnName: 'color', fileName: 'abc', key: 'color', parents: ['age'] }
-    ] as SharedFilter[]
-    const data = [
-      { name: 'John', age: 30, color: 'blue' },
-      { name: 'Jane', age: 25, color: 'red' },
-      { name: 'John', age: 35, color: 'yellow' },
-      { name: 'Jane', age: 30, color: 'green' }
-    ]
-
-    const result = filterData(filters, data)
-
-    expect(result).toEqual([{ name: 'John', age: 30, color: 'blue' }])
-
-    const sideEffectOfFiltering = [
-      {
-        columnName: 'name',
-        active: 'John',
-        queuedActive: 'John',
-        fileName: 'abc',
-        key: 'name',
-        tier: 1
-      },
-      { columnName: 'age', fileName: 'abc', key: 'age', tier: 1 },
-      {
-        columnName: 'color',
-        fileName: 'abc',
-        key: 'color',
-        parents: ['age'],
-        tier: 2,
-        values: ['blue', 'yellow'],
-        active: 'blue'
-      }
-    ]
-    expect(filters).toEqual(sideEffectOfFiltering)
-  })
-
   it('should not include data that does not meet the filter criteria', () => {
     const filters = [
       //{ columnName: 'apple', fileName: 'abc', key: 'banana' },
@@ -95,55 +54,4 @@ describe('filterData', () => {
     const result = filterData(filters, data)
     expect(result).toEqual([{ name: 'John', age: 25, color: 'red' }])
   })
-
-  it('should pivot data based on the provided filters', () => {
-    const filters = [{ key: 'Race', type: 'datafilter', showDropdown: true, columnName: 'Race', pivot: 'Age-adjusted rate', usedBy: ['table1707935263149'] }] as SharedFilter[]
-    const data = [
-      {
-        Race: 'Hispanic or Latino',
-        'Age-adjusted rate': '644.2',
-        Year: '2016'
-      },
-      {
-        Race: 'Non-Hispanic American Indian',
-        'Age-adjusted rate': '636.1',
-        Year: '2016'
-      },
-      {
-        Race: 'Non-Hispanic Black',
-        'Age-adjusted rate': '563.7',
-        Year: '2016'
-      },
-      {
-        Race: 'Hispanic or Latino',
-        'Age-adjusted rate': '644.2',
-        Year: '2017'
-      },
-      {
-        Race: 'Non-Hispanic American Indian',
-        'Age-adjusted rate': '636.1',
-        Year: '2017'
-      },
-      {
-        Race: 'Non-Hispanic Black',
-        'Age-adjusted rate': '563.7',
-        Year: '2017'
-      }
-    ]
-
-    expect(filterData(filters, data)).toEqual([
-      {
-        'Hispanic or Latino': '644.2',
-        'Non-Hispanic American Indian': '636.1',
-        'Non-Hispanic Black': '563.7',
-        Year: '2016'
-      },
-      {
-        'Hispanic or Latino': '644.2',
-        'Non-Hispanic American Indian': '636.1',
-        'Non-Hispanic Black': '563.7',
-        Year: '2017'
-      }
-    ])
-  })
 })