@cdc/dashboard 4.24.5 → 4.24.9

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

@@ -0,0 +1,86 @@
+import _ from 'lodash'
+import { SharedFilter } from '../../types/SharedFilter'
+import { getFilteredData } from '../getFilteredData'
+
+describe('getFilteredData', () => {
+  const sharedFilterDefaults = { values: [], showDropdown: true, id: 123, parents: [], key: 'key' }
+  const data = {
+    data1: [
+      { id: 1, name: 'Alice', age: 25 },
+      { id: 2, name: 'Bob', age: 30 },
+      { id: 3, name: 'Charlie', age: 35 }
+    ]
+  }
+  const state = {
+    data,
+    config: {
+      dashboard: {
+        sharedFilters: []
+      },
+      visualizations: {
+        vizA: { dataKey: 'data1' }
+      },
+      rows: [{ dataKey: 'data1' }]
+    }
+  }
+
+  it('should apply data to rows when there are no applicable filters', () => {
+    expect(getFilteredData(state)).toEqual({ '0': data.data1 })
+  })
+
+  it('should filter visualizations', () => {
+    const sharedFilters: SharedFilter[] = [
+      {
+        usedBy: ['vizA'],
+        active: 'Alice',
+        columnName: 'name',
+        ...sharedFilterDefaults
+      }
+    ]
+    const config = { ...state.config, dashboard: { sharedFilters } }
+    expect(getFilteredData({ ...state, config })).toEqual({ '0': data.data1, vizA: [data.data1[0]] })
+  })
+
+  it('should filter visualizations and rows', () => {
+    const sharedFilters: SharedFilter[] = [
+      {
+        usedBy: ['vizA', '0'],
+        active: 'Alice',
+        columnName: 'name',
+        ...sharedFilterDefaults
+      }
+    ]
+    const config = { ...state.config, dashboard: { sharedFilters } }
+    expect(getFilteredData({ ...state, config })).toEqual({ '0': [data.data1[0]], vizA: [data.data1[0]] })
+  })
+
+  it('should use initialFilteredData', () => {
+    const initialFilteredData = { newData: [data.data1[1]] }
+    const sharedFilters: SharedFilter[] = [
+      {
+        usedBy: ['vizA', '0'],
+        active: 'Alice',
+        columnName: 'name',
+        ...sharedFilterDefaults
+      }
+    ]
+    const config = { ...state.config, dashboard: { sharedFilters } }
+    expect(getFilteredData({ ...state, config }, initialFilteredData)).toEqual({ newData: [data.data1[1]], '0': [data.data1[0]], vizA: [data.data1[0]] })
+  })
+
+  it('should filter visualizations and rows', () => {
+    const sharedFilters: SharedFilter[] = [
+      {
+        usedBy: ['vizA', '0'],
+        active: 'Alice',
+        columnName: 'name',
+        ...sharedFilterDefaults
+      }
+    ]
+    const dataOverride = _.cloneDeep(data)
+    dataOverride.data1[0] = { id: 1, name: 'Alice', age: 30 }
+    const config = { ...state.config, dashboard: { sharedFilters } }
+    const filteredData = getFilteredData({ ...state, config }, undefined, dataOverride)
+    expect(filteredData.vizA[0].age).toEqual(30)
+  })
+})

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

@@ -0,0 +1,176 @@
+import { vi } from 'vitest'
+import { loadAPIFiltersFactory } from '../loadAPIFilters'
+import { faker } from '@faker-js/faker'
+import _ from 'lodash'
+import { SharedFilter } from '../../types/SharedFilter'
+
+faker.seed(123)
+
+const endpointMockData = {
+  'cdc.gov/filters/Sex': [
+    { Sex: 'male', Abbreviation: 'M' },
+    { Sex: 'female', Abbreviation: 'F' }
+  ],
+  'cdc.gov/filters/Quarter': [{ Quarter: 'Q1' }, { Quarter: 'Q2' }, { Quarter: 'Q3' }, { Quarter: 'Q4' }],
+  'cdc.gov/filters/YearQuarter': [
+    { Year: 2020, YearQuarter: '2020Q1' },
+    { Year: 2021, YearQuarter: '2021Q1' }
+  ]
+}
+
+const sharedFilters = [
+  {
+    key: 'Sex',
+    active: 'F',
+    showDropdown: true,
+    type: 'urlfilter',
+    apiFilter: {
+      apiEndpoint: 'cdc.gov/filters/Sex',
+      valueSelector: 'Abbreviation',
+      textSelector: 'Sex'
+    }
+  },
+  {
+    key: 'Quarter',
+    showDropdown: true,
+    type: 'urlfilter',
+    apiFilter: {
+      apiEndpoint: 'cdc.gov/filters/Quarter',
+      valueSelector: 'Quarter',
+      textSelector: ''
+    },
+    parents: ['Sex']
+  },
+  {
+    key: 'YearQuarter',
+    showDropdown: true,
+    type: 'urlfilter',
+    apiFilter: {
+      apiEndpoint: 'cdc.gov/filters/YearQuarter',
+      valueSelector: 'Year',
+      textSelector: 'YearQuarter'
+    },
+    parents: ['Sex', 'Quarter'],
+    multiSelect: true
+  }
+] as SharedFilter[]
+
+const fetch = vi.fn(endpoint => {
+  const baseEndpoint = endpoint.split('?')[0]
+  return Promise.resolve({
+    json: () => Promise.resolve(endpointMockData[baseEndpoint])
+  })
+})
+
+global.fetch = fetch
+
+describe('loadAPIFiltersFactory', () => {
+  const dispatch = vi.fn()
+  const setAPIFilterDropdowns = vi.fn()
+  const apiFilterDropdowns = {
+    'cdc.gov/filters/Sex': [
+      { text: 'male', value: 'M' },
+      { text: 'female', value: 'F' }
+    ]
+  }
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+  const loadAPIFilters = loadAPIFiltersFactory(dispatch, setAPIFilterDropdowns, [2])
+  it('creates a function', () => {
+    expect(typeof loadAPIFilters).toEqual('function')
+  })
+
+  it('loadAPIFilters() should return a promise', async () => {
+    const result = loadAPIFilters([], apiFilterDropdowns)
+    expect(result).toBeInstanceOf(Promise)
+    await result
+  })
+
+  it('loadAPIFilters() load dropdowns for children when parent is selected', async () => {
+    const newSharedFilters = await loadAPIFilters(sharedFilters, apiFilterDropdowns)
+    expect(dispatch).toHaveBeenCalledTimes(1)
+    expect(setAPIFilterDropdowns).toHaveBeenCalledTimes(1)
+
+    const expectedDropdowns = {
+      'cdc.gov/filters/Quarter': [
+        {
+          text: 'Q1',
+          value: 'Q1'
+        },
+        {
+          text: 'Q2',
+          value: 'Q2'
+        },
+        {
+          text: 'Q3',
+          value: 'Q3'
+        },
+        {
+          text: 'Q4',
+          value: 'Q4'
+        }
+      ],
+      'cdc.gov/filters/Sex': [
+        {
+          text: 'male',
+          value: 'M'
+        },
+        {
+          text: 'female',
+          value: 'F'
+        }
+      ]
+    }
+
+    expect(setAPIFilterDropdowns).toHaveBeenCalledWith(expectedDropdowns)
+    expect(fetch).toHaveBeenCalledTimes(1)
+    expect(newSharedFilters).toEqual(sharedFilters)
+  })
+
+  it('loadAPIFilters() load dropdowns for children when parents are selected, and autoload any autoloading filters', async () => {
+    sharedFilters[1].active = 'Q1'
+    const newSharedFilters = await loadAPIFilters(sharedFilters, apiFilterDropdowns)
+    expect(dispatch).toHaveBeenCalledTimes(1)
+    expect(setAPIFilterDropdowns).toHaveBeenCalledTimes(1)
+
+    const expectedDropdowns = {
+      'cdc.gov/filters/Quarter': [
+        {
+          text: 'Q1',
+          value: 'Q1'
+        },
+        {
+          text: 'Q2',
+          value: 'Q2'
+        },
+        {
+          text: 'Q3',
+          value: 'Q3'
+        },
+        {
+          text: 'Q4',
+          value: 'Q4'
+        }
+      ],
+      'cdc.gov/filters/Sex': [
+        {
+          text: 'male',
+          value: 'M'
+        },
+        {
+          text: 'female',
+          value: 'F'
+        }
+      ],
+      'cdc.gov/filters/YearQuarter': [
+        { value: 2020, text: '2020Q1' },
+        { value: 2021, text: '2021Q1' }
+      ]
+    }
+
+    expect(setAPIFilterDropdowns).toHaveBeenCalledWith(expectedDropdowns)
+    expect(fetch).toHaveBeenCalledTimes(2)
+    expect(newSharedFilters[2].active).toEqual([2020])
+  })
+})

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

@@ -0,0 +1,195 @@
+import { isUpdateNeeded, getDataURL, getNewFileName, filterUsedByDataUrl } from '../reloadURLHelpers'
+import { SharedFilter } from '../../types/SharedFilter'
+
+describe('isUpdateNeeded', () => {
+  it('should return false when there are no filters and no query params', () => {
+    const filters: SharedFilter[] = []
+    const currentQueryParams = {}
+    const newQueryParams = {}
+    expect(isUpdateNeeded(filters, currentQueryParams, newQueryParams)).toBe(false)
+  })
+
+  it('should return true when there is a filter with type "urlfilter" and filterBy "File Name"', () => {
+    const filters: SharedFilter[] = [{ type: 'urlfilter', active: 'someValue', filterBy: 'File Name' }]
+    const currentQueryParams = {}
+    const newQueryParams = {}
+    expect(isUpdateNeeded(filters, currentQueryParams, newQueryParams)).toBe(true)
+  })
+
+  it('should return true when query params are different', () => {
+    const filters: SharedFilter[] = []
+    const currentQueryParams = { param1: 'value1' }
+    const newQueryParams = { param1: 'value2' }
+    expect(isUpdateNeeded(filters, currentQueryParams, newQueryParams)).toBe(true)
+  })
+
+  it('should return false when query params are the same', () => {
+    const filters: SharedFilter[] = []
+    const currentQueryParams = { param1: 'value1' }
+    const newQueryParams = { param1: 'value1' }
+    expect(isUpdateNeeded(filters, currentQueryParams, newQueryParams)).toBe(false)
+  })
+
+  it('should return false when filter type is "urlfilter" but filterBy is not "File Name"', () => {
+    const filters: SharedFilter[] = [{ type: 'urlfilter', active: 'someValue', filterBy: 'Other' }]
+    const currentQueryParams = {}
+    const newQueryParams = {}
+    expect(isUpdateNeeded(filters, currentQueryParams, newQueryParams)).toBe(false)
+  })
+
+  it('should return false when filter type is "urlfilter" and filterBy is "File Name" but active is an array', () => {
+    const filters: SharedFilter[] = [{ type: 'urlfilter', active: ['someValue'], filterBy: 'File Name' }]
+    const currentQueryParams = {}
+    const newQueryParams = {}
+    expect(isUpdateNeeded(filters, currentQueryParams, newQueryParams)).toBe(false)
+  })
+})
+
+describe('getDataURL', () => {
+  it('should return the base URL when there are no query parameters and no new file name', () => {
+    const updatedQSParams = {}
+    const dataUrl = new URL('https://example.com/path/to/file.csv')
+    const newFileName = ''
+    expect(getDataURL(updatedQSParams, dataUrl, newFileName)).toBe('https://example.com/path/to/file.csv')
+  })
+
+  it('should append query parameters correctly when they are strings and there is no new file name', () => {
+    const updatedQSParams = { param1: 'value1', param2: 'value2' }
+    const dataUrl = new URL('https://example.com/path/to/file.csv')
+    const newFileName = ''
+    expect(getDataURL(updatedQSParams, dataUrl, newFileName)).toBe('https://example.com/path/to/file.csv?param1="value1"&param2="value2"')
+  })
+
+  it('should append query parameters correctly when they are arrays and there is no new file name', () => {
+    const updatedQSParams = { param1: ['value1', 'value2'], param2: 'value3' }
+    const dataUrl = new URL('https://example.com/path/to/file.csv')
+    const newFileName = ''
+    expect(getDataURL(updatedQSParams, dataUrl, newFileName)).toBe('https://example.com/path/to/file.csv?param1="value1"&param1="value2"&param2="value3"')
+  })
+
+  it('should change the file name correctly when there are no query parameters but there is a new file name', () => {
+    const updatedQSParams = {}
+    const dataUrl = new URL('https://example.com/path/to/file.csv')
+    const newFileName = 'newfile'
+    expect(getDataURL(updatedQSParams, dataUrl, newFileName)).toBe('https://example.com/path/to/newfile.csv')
+  })
+
+  it('should change the file name and append query parameters correctly when they are strings and there is a new file name', () => {
+    const updatedQSParams = { param1: 'value1', param2: 'value2' }
+    const dataUrl = new URL('https://example.com/path/to/file.csv')
+    const newFileName = 'newfile'
+    expect(getDataURL(updatedQSParams, dataUrl, newFileName)).toBe('https://example.com/path/to/newfile.csv?param1="value1"&param2="value2"')
+  })
+
+  it('should change the file name and append query parameters correctly when they are arrays and there is a new file name', () => {
+    const updatedQSParams = { param1: ['value1', 'value2'], param2: 'value3' }
+    const dataUrl = new URL('https://example.com/path/to/file.csv')
+    const newFileName = 'newfile'
+    expect(getDataURL(updatedQSParams, dataUrl, newFileName)).toBe('https://example.com/path/to/newfile.csv?param1="value1"&param1="value2"&param2="value3"')
+  })
+})
+
+describe('getNewFileName', () => {
+  it('should return the formatted fileName when filter matches datasetKey and has a fileName', () => {
+    const newFileName = 'defaultFile'
+    const filter = {
+      datasetKey: 'dataset1',
+      fileName: 'state_${query}',
+      active: 'activeFilter',
+      whitespaceReplacement: 'Replace With Underscore'
+    }
+    const datasetKey = 'dataset1'
+    expect(getNewFileName(newFileName, filter, datasetKey)).toBe('State_ActiveFilter')
+  })
+
+  it('should return the active filter when filter matches datasetKey and does not have a fileName', () => {
+    const newFileName = 'defaultFile'
+    const filter = {
+      datasetKey: 'dataset1',
+      active: 'activeFilter',
+      whitespaceReplacement: 'Keep Spaces'
+    }
+    const datasetKey = 'dataset1'
+    expect(getNewFileName(newFileName, filter, datasetKey)).toBe('activeFilter')
+  })
+
+  it('should return the newFileName as is when filter does not match datasetKey', () => {
+    const newFileName = 'defaultFile'
+    const filter = {
+      datasetKey: 'dataset2',
+      fileName: 'state_${query}',
+      active: 'activeFilter',
+      whitespaceReplacement: 'Replace With Underscore'
+    }
+    const datasetKey = 'dataset1'
+    expect(getNewFileName(newFileName, filter, datasetKey)).toBe('defaultFile')
+  })
+
+  it('should replace ${query} with the active filter when filter matches datasetKey, has a fileName, and includes ${query}', () => {
+    const newFileName = 'defaultFile'
+    const filter = {
+      datasetKey: 'dataset1',
+      fileName: 'state_${query}',
+      active: 'activeFilter',
+      whitespaceReplacement: 'Keep Spaces'
+    }
+    const datasetKey = 'dataset1'
+    expect(getNewFileName(newFileName, filter, datasetKey)).toBe('State_ActiveFilter')
+  })
+
+  it('should handle whitespace replacement options correctly', () => {
+    const newFileName = 'defaultFile'
+    const filter = {
+      datasetKey: 'dataset1',
+      fileName: 'state_${query}',
+      active: 'active Filter',
+      whitespaceReplacement: 'Remove Spaces'
+    }
+    const datasetKey = 'dataset1'
+    expect(getNewFileName(newFileName, filter, datasetKey)).toBe('State_ActiveFilter')
+
+    filter.whitespaceReplacement = 'Keep Spaces'
+    expect(getNewFileName(newFileName, filter, datasetKey)).toBe('State_Active Filter')
+
+    filter.whitespaceReplacement = 'Replace With Underscore'
+    expect(getNewFileName(newFileName, filter, datasetKey)).toBe('State_Active_Filter')
+  })
+})
+
+describe('filterUsedByDataUrl', () => {
+  const visualizations = {
+    viz1: { dataKey: 'dataset1' },
+    viz2: { dataKey: 'dataset2' },
+    viz3: { dataKey: 'dataset1' }
+  }
+
+  it('should return true when filter has no usedBy property', () => {
+    const filter = { datasetKey: 'dataset1' }
+    const datasetKey = 'dataset1'
+    expect(filterUsedByDataUrl(filter, datasetKey, visualizations)).toBe(true)
+  })
+
+  it('should return true when filter has an empty usedBy array', () => {
+    const filter = { usedBy: [], datasetKey: 'dataset1' }
+    const datasetKey = 'dataset1'
+    expect(filterUsedByDataUrl(filter, datasetKey, visualizations)).toBe(true)
+  })
+
+  it('should return true when filter has usedBy array with visualization keys that match the datasetKey', () => {
+    const filter = { usedBy: ['viz1', 'viz3'], datasetKey: 'dataset1' }
+    const datasetKey = 'dataset1'
+    expect(filterUsedByDataUrl(filter, datasetKey, visualizations)).toBe(true)
+  })
+
+  it('should return false when filter has usedBy array with visualization keys that do not match the datasetKey', () => {
+    const filter = { usedBy: ['viz2'], datasetKey: 'dataset1' }
+    const datasetKey = 'dataset1'
+    expect(filterUsedByDataUrl(filter, datasetKey, visualizations)).toBe(false)
+  })
+
+  it('should return true when filter has usedBy array with a mix of matching and non-matching visualization keys', () => {
+    const filter = { usedBy: ['viz1', 'viz2'], datasetKey: 'dataset1' }
+    const datasetKey = 'dataset1'
+    expect(filterUsedByDataUrl(filter, datasetKey, visualizations)).toBe(true)
+  })
+})

package/src/scss/editor-panel.scss

@@ -249,7 +249,7 @@
     }
     &.checkbox {
       display: flex;
-      span {
+      span:not(.cove-icon) {
         display: inline;
       }
       input {

package/src/scss/grid.scss

@@ -7,15 +7,6 @@ $red: #f74242;
   margin-left: calc($editorWidth + 1em);
 }
 
-.visualizations-panel {
-  background-color: #fff;
-  padding: 1em;
-  width: $editorWidth;
-  border-right: #c7c7c7 1px solid;
-  z-index: 1;
-  overflow-y: scroll;
-}
-
 .hidden.editor-panel + .builder-grid {
   margin-left: 0 !important;
 }
@@ -30,30 +21,16 @@ $red: #f74242;
   padding: 5em 3em 3em;
 }
 
-.column-container {
-  display: flex;
-  flex-flow: row;
-  width: 100%;
-  position: relative;
-  padding: 2em 1em 1em;
-  border: 1px solid #c2c2c2;
-  transition: border 300ms cubic-bezier(0.16, 1, 0.3, 1);
-  background-color: #f2f2f2;
-  user-select: none;
-
-  &.can-drop {
-    border-color: $blue-light;
-  }
-}
-
 .row-menu {
   display: flex;
   align-items: flex-start;
   transition: opacity 300ms cubic-bezier(0.16, 1, 0.3, 1);
   user-select: none;
-  position: relative;
+  position: absolute;
   z-index: 1;
-  bottom: -1px;
+  top: -27px;
+  width: 100%;
+  left: 0;
 
   > li:not(.spacer) + li:not(.spacer) {
     margin-left: 0.3em;
@@ -337,6 +314,35 @@ $red: #f74242;
     top: 0;
   }
 
+  .footnotes {
+    margin: 0.5rem;
+    margin-bottom: 0;
+    width: calc(100% - 1rem);
+    border: 1px solid #c2c2c2;
+    transition: background-color 300ms cubic-bezier(0.16, 1, 0.3, 1);
+    background-color: #c2c2c2;
+    &:hover {
+      border-color: $blue;
+      background-color: $blue;
+    }
+  }
+  
+  padding: 2em 1em 1em;
+  border: 1px solid #c2c2c2;
+  transition: border 300ms cubic-bezier(0.16, 1, 0.3, 1);
+  background-color: #f2f2f2;
+  user-select: none;
+
+  &.can-drop {
+    border-color: $blue-light;
+  }
+
+  .column-container {
+    display: flex;
+    flex-flow: row;
+    width: 100%;
+  }
+
   .widget__content {
     padding: 0 2em;
 
@@ -369,5 +375,6 @@ $red: #f74242;
     .column-container {
       border-color: $blue;
     }
+    border-color: $blue;
   }
 }

package/src/scss/main.scss

@@ -156,6 +156,13 @@
       z-index: -1;
       position: relative;
     }
+
+    // Expand and Collapse Buttons for Multiviz Dashboard
+    &.expand-collapse-buttons {
+      background-color: var(--lightestGray);
+      border: 1px var(--lightGray) solid;
+      color: black;
+    }
   }
 
   .warning-icon {
@@ -181,6 +188,40 @@
     }
   }
 
+  .collapsable-multiviz-container {
+    position: relative;
+    border: $lightGray 1px solid;
+    clear: both;
+    margin-bottom: 20px;
+    .multi-visualiation-heading {
+      position: relative;
+      background: var(--lightestGray);
+      padding: 0.5em 0.7em;
+      cursor: pointer;
+      svg {
+        position: absolute;
+        height: 100%;
+        width: 15px;
+        top: 0;
+        right: 1em;
+      }
+
+      &:focus {
+        z-index: 2;
+        position: relative;
+      }
+      @include breakpoint(xs) {
+        font-size: $font-small + 0.2em;
+      }
+    }
+    .data-table-heading {
+      display: none;
+    }
+    .table-container {
+      margin: 0 1em;
+    }
+  }
+
   .dashboard-download-link {
     font-size: 14px;
   }
@@ -205,9 +246,6 @@
       margin-left: 0;
       margin-right: 0;
     }
-    &.hidden-toggle {
-      display: none;
-    }
   }
 
   .dashboard-col-12 {

package/src/scss/variables.scss

@@ -1 +1,5 @@
 $editorWidth: 350px;
+
+:root {
+  --editorWidth: #{$editorWidth};
+}

package/src/store/dashboard.actions.ts

@@ -1,15 +1,20 @@
 import type { DashboardConfig as Config } from '../types/DashboardConfig'
 import { type Action } from '@cdc/core/types/Action'
 import { Tab } from '../types/Tab'
-import { ConfigureData } from '@cdc/core/types/ConfigureData'
 import { ConfigRow } from '../types/ConfigRow'
+import { AnyVisualization } from '@cdc/core/types/Visualization'
+import Footnotes from '@cdc/core/types/Footnotes'
+import { SharedFilter } from '../types/SharedFilter'
 
-type SET_CONFIG = Action<'SET_CONFIG', Config>
+type ADD_FOOTNOTE = Action<'ADD_FOOTNOTE', { id: string; rowIndex: number; config: Footnotes }>
+type APPLY_CONFIG = Action<'APPLY_CONFIG', [Config, Object?]>
+type SET_CONFIG = Action<'SET_CONFIG', Partial<Config>>
 type UPDATE_CONFIG = Action<'UPDATE_CONFIG', [Config, Object?]>
-type SET_DATA = Action<'SET_DATA', Object>
+type SET_DATA = Action<'SET_DATA', Record<string, any[]>>
 type SET_LOADING = Action<'SET_LOADING', boolean>
 type SET_PREVIEW = Action<'SET_PREVIEW', boolean>
 type SET_FILTERED_DATA = Action<'SET_FILTERED_DATA', Object>
+type SET_SHARED_FILTERS = Action<'SET_SHARED_FILTERS', SharedFilter[]>
 type SET_TAB_SELECTED = Action<'SET_TAB_SELECTED', Tab>
 type RENAME_DASHBOARD_TAB = Action<'RENAME_DASHBOARD_TAB', { current: string; new: string }>
 type INITIALIZE_MULTIDASHBOARDS = Action<'INITIALIZE_MULTIDASHBOARDS', undefined>
@@ -19,10 +24,12 @@ type ADD_NEW_DASHBOARD = Action<'ADD_NEW_DASHBOARD', undefined>
 type SAVE_CURRENT_CHANGES = Action<'SAVE_CURRENT_CHANGES', undefined>
 type SWITCH_CONFIG = Action<'SWITCH_CONFIG', number>
 type TOGGLE_ROW = Action<'TOGGLE_ROW', { rowIndex: number; colIndex: number }>
-type UPDATE_VISUALIZATION = Action<'UPDATE_VISUALIZATION', { vizKey: string; configureData: Partial<ConfigureData> }>
+type UPDATE_VISUALIZATION = Action<'UPDATE_VISUALIZATION', { vizKey: string; configureData: Partial<AnyVisualization> }>
 type UPDATE_ROW = Action<'UPDATE_ROW', { rowIndex: number; rowData: Partial<ConfigRow> }>
 
 type DashboardActions =
+  | ADD_FOOTNOTE
+  | APPLY_CONFIG
   | ADD_NEW_DASHBOARD
   | SET_CONFIG
   | UPDATE_CONFIG
@@ -34,6 +41,7 @@ type DashboardActions =
   | SET_LOADING
   | SET_PREVIEW
   | SET_FILTERED_DATA
+  | SET_SHARED_FILTERS
   | SET_TAB_SELECTED
   | SWITCH_CONFIG
   | INITIALIZE_MULTIDASHBOARDS