@cdc/dashboard 4.26.3 → 4.26.5

package/src/helpers/dashboardFilterTargets.ts

@@ -0,0 +1,156 @@
+import { ConfigRow, DashboardCondition } from '../types/ConfigRow'
+import { DashboardConfig } from '../types/DashboardConfig'
+import { Dashboard } from '../types/Dashboard'
+import { SharedFilter } from '../types/SharedFilter'
+import { getConditionalWidgets, hasConditionalWidgets } from './dashboardColumnWidgets'
+import { getVizRowColumnLocator } from './getVizRowColumnLocator'
+
+export type SharedFilterTarget = string | number
+
+export type SharedFilterTargetOptions = {
+  nameLookup: Record<string, string>
+  options: SharedFilterTarget[]
+}
+
+export type DashboardConditionTarget = {
+  id: string
+  dashboardCondition: DashboardCondition
+  rowIndex: number
+  filterTarget: SharedFilterTarget
+  columnIndex?: number
+  entryIndex?: number
+}
+
+export const dashboardConditionsSupportedForRow = (row?: ConfigRow) =>
+  !!row && !row.toggle && !row.multiVizColumn && !row.originalMultiVizColumn
+
+const normalizeTarget = (target: SharedFilterTarget) => `${target}`
+
+const dedupeSharedFilterTargets = (targets: SharedFilterTarget[]) =>
+  targets.filter(
+    (value, index, values) => values.findIndex(entry => normalizeTarget(entry) === normalizeTarget(value)) === index
+  )
+
+export const matchesSharedFilterTarget = (usedBy: SharedFilter['usedBy'], target: SharedFilterTarget) =>
+  !!usedBy?.some(entry => normalizeTarget(entry) === normalizeTarget(target))
+
+export const getDashboardConditionTargets = (rows: ConfigRow[]): DashboardConditionTarget[] =>
+  rows.reduce((targets, row, rowIndex) => {
+    if (!dashboardConditionsSupportedForRow(row)) return targets
+
+    if (row.dashboardCondition?.id) {
+      targets.push({
+        id: row.dashboardCondition.id,
+        dashboardCondition: row.dashboardCondition,
+        rowIndex,
+        filterTarget: rowIndex
+      })
+    }
+
+    row.columns?.forEach((column, columnIndex) => {
+      if (hasConditionalWidgets(column)) {
+        getConditionalWidgets(column).forEach((entry, entryIndex) => {
+          if (!entry.dashboardCondition?.id) return
+          targets.push({
+            id: entry.dashboardCondition.id,
+            dashboardCondition: entry.dashboardCondition,
+            rowIndex,
+            filterTarget: row.dataKey ? rowIndex : entry.widget,
+            columnIndex,
+            entryIndex
+          })
+        })
+        return
+      }
+    })
+
+    return targets
+  }, [] as DashboardConditionTarget[])
+
+export const getSharedFilterTargetOptions = (
+  config: DashboardConfig,
+  filter: Pick<SharedFilter, 'usedBy' | 'setBy'>
+): SharedFilterTargetOptions => {
+  const nameLookup: Record<string, string> = {}
+  const options: SharedFilterTarget[] = []
+  const vizRowColumnLocator = getVizRowColumnLocator(config.rows)
+
+  Object.keys(config.visualizations).forEach(vizKey => {
+    const vizLookup = vizRowColumnLocator[vizKey]
+    if (!vizLookup) return
+
+    const viz = config.visualizations[vizKey] as any
+    if (viz.type === 'dashboardFilters') return
+
+    const vizName =
+      viz.visualizationType === 'markup-include'
+        ? viz.contentEditor?.title || vizKey
+        : viz.general?.title || viz.title || vizKey
+    const dataConfiguredOnRow = config.rows[vizLookup.row]?.dataKey
+
+    nameLookup[vizKey] = vizName
+    if (filter.setBy !== vizKey && !viz.usesSharedFilter && !dataConfiguredOnRow) {
+      options.push(vizKey)
+    }
+  })
+
+  config.rows.forEach((row, rowIndex) => {
+    if (row.dataKey || (dashboardConditionsSupportedForRow(row) && row.dashboardCondition)) {
+      nameLookup[`${rowIndex}`] = `Row ${rowIndex + 1}`
+      options.push(rowIndex)
+    }
+  })
+
+  // Preserve legacy row targets that are no longer offered as new selectable targets.
+  filter.usedBy?.forEach(target => {
+    const isNumericRowTarget = typeof target === 'number' || (typeof target === 'string' && /^-?\d+$/.test(target))
+    if (isNumericRowTarget) {
+      const rowIndex = Number(target)
+      if (!config.rows[rowIndex]) return
+      nameLookup[`${target}`] = `Row ${rowIndex + 1}`
+      options.push(target)
+    }
+  })
+
+  return {
+    nameLookup,
+    options: dedupeSharedFilterTargets(options)
+  }
+}
+
+export const remapRowTargetsInSharedFilters = (
+  sharedFilters: SharedFilter[],
+  remapRowIndex: (rowIndex: number) => number | null
+): SharedFilter[] =>
+  sharedFilters.map(sharedFilter => {
+    if (!sharedFilter.usedBy) return sharedFilter
+
+    const nextUsedBy = dedupeSharedFilterTargets(
+      sharedFilter.usedBy.flatMap(target => {
+        const isNumericRowTarget = typeof target === 'number' || (typeof target === 'string' && /^-?\d+$/.test(target))
+        if (!isNumericRowTarget) return [target]
+
+        const mappedRowIndex = remapRowIndex(Number(target))
+        return mappedRowIndex === null ? [] : [typeof target === 'number' ? mappedRowIndex : `${mappedRowIndex}`]
+      })
+    )
+
+    return nextUsedBy === sharedFilter.usedBy ? sharedFilter : { ...sharedFilter, usedBy: nextUsedBy }
+  })
+
+export const getApplicableFiltersForTarget = (
+  dashboard: Dashboard,
+  target: SharedFilterTarget,
+  options?: { includeUnscoped?: boolean }
+): SharedFilter[] | false => {
+  const applicableFilters =
+    dashboard.sharedFilters?.filter(sharedFilter => {
+      if (options?.includeUnscoped && (!sharedFilter.usedBy || sharedFilter.usedBy.length === 0)) {
+        return true
+      }
+
+      return matchesSharedFilterTarget(sharedFilter.usedBy, target)
+    }) || []
+
+  return applicableFilters.length > 0 ? applicableFilters : false
+}

package/src/helpers/filterData.ts

@@ -108,14 +108,9 @@ export const filterData = (filters: SharedFilter[], _data: Object[]): Object[] =
     return []
   }
 
-  for (let i = 0; i < maxTier; i++) {
-    const lastIteration = i === maxTier - 1
-
-    const filteredData = filterDataByTier(_data, filters, i + 1)
-
-    if (lastIteration) {
-      // not sure if this last run of filterDataByTier() function is necessary.
-      return filterDataByTier(filteredData, filters, maxTier - 1)
-    }
+  let filteredData = _data
+  for (let tier = 1; tier <= maxTier; tier++) {
+    filteredData = filterDataByTier(filteredData, filters, tier)
   }
+  return filteredData
 }

package/src/helpers/filterVisibility.ts

@@ -0,0 +1,20 @@
+import { FILTER_STYLE } from '../types/FilterStyles'
+import { SharedFilter } from '../types/SharedFilter'
+
+export const isVisibleDashboardFilter = (filter?: SharedFilter | null): boolean =>
+  Boolean(
+    filter &&
+      (filter.type === 'urlfilter' ||
+        filter.showDropdown ||
+        filter.filterStyle === FILTER_STYLE.nestedDropdown ||
+        filter.filterStyle === FILTER_STYLE.tabSimple)
+  )
+
+export const hasVisibleDashboardFiltersForIndexes = (
+  sharedFilters?: SharedFilter[] | null,
+  sharedFilterIndexes?: (number | string)[] | null
+): boolean =>
+  Boolean(
+    sharedFilterIndexes?.length &&
+      sharedFilterIndexes.map(Number).some(filterIndex => isVisibleDashboardFilter(sharedFilters?.[filterIndex]))
+  )

package/src/helpers/formatConfigBeforeSave.ts

@@ -51,9 +51,9 @@ export const cleanSharedFilters = (config: DashboardConfig) => {
   if (config.dashboard?.sharedFilters) {
     const recursiveRemoveFilters = (sharedFilters, visualizations: Record<string, AnyVisualization>) => {
       const usedFilters = _.uniq(
-        Object.values(visualizations).reduce((acc, viz) => {
+        Object.values(visualizations).reduce((acc: number[], viz) => {
           if (viz.type === 'dashboardFilters') {
-            acc = acc.concat(viz.sharedFilterIndexes)
+            acc = acc.concat((viz.sharedFilterIndexes ?? []).map(Number))
           }
           return acc
         }, [])

package/src/helpers/getFilteredData.ts

@@ -1,16 +1,14 @@
 import { DashboardState } from '../store/dashboard.reducer'
 import { Dashboard } from '../types/Dashboard'
 import { SharedFilter } from '../types/SharedFilter'
+import { getDashboardConditionFilteredData } from './dashboardConditions'
+import { getApplicableFiltersForTarget, getDashboardConditionTargets } from './dashboardFilterTargets'
 import { filterData } from './filterData'
 import { getFormattedData } from './getFormattedData'
 import { getVizKeys } from './getVizKeys'
 
 export const getApplicableFilters = (dashboard: Dashboard, key: string | number): false | SharedFilter[] => {
-  const c = dashboard.sharedFilters?.filter(
-    sharedFilter =>
-      (sharedFilter.usedBy && sharedFilter.usedBy.indexOf(`${key}`) !== -1) || sharedFilter.usedBy?.indexOf(key) !== -1
-  )
-  return c?.length > 0 ? c : false
+  return getApplicableFiltersForTarget(dashboard, key, { includeUnscoped: true })
 }
 export const getFilteredData = (
   state: DashboardState,
@@ -45,5 +43,20 @@ export const getFilteredData = (
       }
     }
   })
+  const dashboardConditionTargets = getDashboardConditionTargets(config.rows)
+  dashboardConditionTargets.forEach(conditionTarget => {
+    delete newFilteredData[conditionTarget.id]
+
+    const filteredData = getDashboardConditionFilteredData(
+      conditionTarget.dashboardCondition,
+      config.dashboard,
+      (dataOverride || state.data) as Record<string, any[]>,
+      conditionTarget.filterTarget
+    )
+
+    if (filteredData !== undefined) {
+      newFilteredData[conditionTarget.id] = filteredData
+    }
+  })
   return newFilteredData
 }

package/src/helpers/getUpdateConfig.ts

@@ -1,5 +1,7 @@
 import { DashboardState } from '../store/dashboard.reducer'
 import { DashboardConfig as Config, DashboardConfig } from '../types/DashboardConfig'
+import { ensureRowConditionIds, getDashboardConditionFilteredData } from './dashboardConditions'
+import { getApplicableFiltersForTarget, getDashboardConditionTargets } from './dashboardFilterTargets'
 import { filterData } from './filterData'
 import { generateValuesForFilter } from './generateValuesForFilter'
 import { getFormattedData } from './getFormattedData'
@@ -16,6 +18,7 @@ export const getUpdateConfig =
   (state: UpdateState) =>
   (newConfig, dataOverride?: Object): [Config, Object] => {
     let newFilteredData = {}
+    newConfig.rows = ensureRowConditionIds(newConfig.rows)
     let visualizationKeys = getVizKeys(newConfig)
 
     const vizRowColumnLocator = getVizRowColumnLocator(newConfig.rows)
@@ -55,13 +58,13 @@ export const getUpdateConfig =
       })
 
       visualizationKeys.forEach(visualizationKey => {
-        const row = vizRowColumnLocator[visualizationKey]
-        if (newConfig.rows[row]?.datakey) return // data configured on the row level
-        const applicableFilters = newConfig.dashboard.sharedFilters.filter(
-          sharedFilter => sharedFilter.usedBy && sharedFilter.usedBy.indexOf(visualizationKey) !== -1
-        )
+        const locator = vizRowColumnLocator[visualizationKey]
+        if (newConfig.rows[locator?.row]?.dataKey) return // data configured on the row level
+        const applicableFilters = getApplicableFiltersForTarget(newConfig.dashboard, visualizationKey, {
+          includeUnscoped: true
+        })
 
-        if (applicableFilters.length > 0) {
+        if (applicableFilters) {
           const visualization = newConfig.visualizations[visualizationKey]
           const _newConfigDataSet = newConfig.datasets[visualization.dataKey]
           const formattedData = getFormattedData(
@@ -74,16 +77,44 @@ export const getUpdateConfig =
       })
 
       newConfig.rows.forEach((row, rowIndex) => {
-        const applicableFilters = newConfig.dashboard.sharedFilters.filter(
-          sharedFilter => sharedFilter.usedBy && sharedFilter.usedBy.indexOf(rowIndex) !== -1
-        )
+        if (!row.dataKey) return
+
+        const applicableFilters = getApplicableFiltersForTarget(newConfig.dashboard, rowIndex, {
+          includeUnscoped: true
+        })
 
-        if (applicableFilters.length > 0) {
-          const formattedData = getFormattedData(row.data, row.dataDescription)
-          const _data = formattedData || (dataOverride || state.data)[rowIndex]
+        if (applicableFilters) {
+          const datasetData = newConfig.datasets?.[row.dataKey]?.data
+          const formattedData = getFormattedData(row.data || datasetData, row.dataDescription)
+          const _data = formattedData || (dataOverride || state.data)[row.dataKey]
           newFilteredData[rowIndex] = filterData(applicableFilters, _data)
         }
       })
+
+      const conditionDataSource = {
+        ...(state.data || {}),
+        ...(dataOverride || {}),
+        ...Object.keys(newConfig.datasets || {}).reduce((acc, datasetKey) => {
+          const datasetData = newConfig.datasets[datasetKey]?.data
+          if (datasetData) {
+            acc[datasetKey] = datasetData
+          }
+          return acc
+        }, {} as Record<string, any[]>)
+      }
+
+      getDashboardConditionTargets(newConfig.rows).forEach(conditionTarget => {
+        const filteredData = getDashboardConditionFilteredData(
+          conditionTarget.dashboardCondition,
+          newConfig.dashboard,
+          conditionDataSource,
+          conditionTarget.filterTarget
+        )
+
+        if (filteredData !== undefined) {
+          newFilteredData[conditionTarget.id] = filteredData
+        }
+      })
     }
     //Enforce default values that need to be calculated at runtime
     newConfig.runtime = {}

package/src/helpers/getVizRowColumnLocator.ts

@@ -1,9 +1,19 @@
 import { ConfigRow } from '../types/ConfigRow'
+import { getConditionalWidgets, hasConditionalWidgets } from './dashboardColumnWidgets'
 
 // returns a dictionary of widget names and their corresponding row and column index
-export const getVizRowColumnLocator = (rows: ConfigRow[]): Record<string, { row: number; column: number }> =>
+export const getVizRowColumnLocator = (
+  rows: ConfigRow[]
+): Record<string, { row: number; column: number; entry?: number }> =>
   rows.reduce((acc, curr, index) => {
     curr.columns?.forEach((column, columnIndex) => {
+      if (hasConditionalWidgets(column)) {
+        getConditionalWidgets(column).forEach((entry, entryIndex) => {
+          acc[entry.widget] = { row: index, column: columnIndex, entry: entryIndex }
+        })
+        return
+      }
+
       if (column.widget !== undefined) acc[column.widget] = { row: index, column: columnIndex }
     })
     return acc

package/src/helpers/iconHash.tsx

@@ -1,13 +1,18 @@
+import React from 'react'
 import Icon from '@cdc/core/components/ui/Icon'
 import { AnyVisualization } from '@cdc/core/types/Visualization'
 
-export const iconHash = {
+const waffleAliases = ['TP5 Waffle', 'Waffle', 'TP5 Gauge', 'Gauge']
+const waffleIcon = <Icon display='grid' base />
+
+export const iconHash: Record<string, React.ReactNode> = {
   '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 />,
+  'waffle-chart': waffleIcon,
   'markup-include': <Icon display='code' base />,
+  condition: <Icon display='condition' base />,
   Line: <Icon display='chartLine' base />,
   Pie: <Icon display='chartPie' base />,
   us: <Icon display='mapUsa' base />,
@@ -29,7 +34,8 @@ export const iconHash = {
   'Box Plot': <Icon display='chartBar' base />,
   'Forest Plot': <Icon display='chartBar' base />,
   Forecasting: <Icon display='chartLine' base />,
-  'Warming Stripes': <Icon display='chartBar' base />
+  'Warming Stripes': <Icon display='chartBar' base />,
+  ...Object.fromEntries(waffleAliases.map(alias => [alias, waffleIcon]))
 }
 
 export const getIcon = (visualization: AnyVisualization) => {

package/src/helpers/mapDataToConfig.ts

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

package/src/helpers/reloadURLHelpers.ts

@@ -6,6 +6,8 @@ import _ from 'lodash'
 import { DashboardConfig } from '../types/DashboardConfig'
 import { ConfigRow } from '../types/ConfigRow'
 import { getVizRowColumnLocator } from './getVizRowColumnLocator'
+import { getDashboardConditionDatasetKeys } from './dashboardConditions'
+import { getDashboardConditionTargets } from './dashboardFilterTargets'
 
 export const isUpdateNeeded = (
   filters: SharedFilter[],
@@ -28,14 +30,26 @@ export const isUpdateNeeded = (
 }
 
 type GetDatasetKeysParams = Pick<DashboardConfig, 'visualizations' | 'datasets' | 'rows'>
-export const getDatasetKeys = ({ visualizations, datasets, rows }: GetDatasetKeysParams): string[] => {
+type GetDatasetKeysOptions = {
+  includeDashboardConditionDatasetKeys?: boolean
+}
+export const getDatasetKeys = (
+  { visualizations, datasets, rows }: GetDatasetKeysParams,
+  { includeDashboardConditionDatasetKeys = true }: GetDatasetKeysOptions = {}
+): string[] => {
   const vizDataKeys = Object.values(visualizations).map(viz => viz.dataKey)
   const rowDataKeys = rows.map(row => row.dataKey)
+  const dashboardConditionDataKeys = includeDashboardConditionDatasetKeys ? getDashboardConditionDatasetKeys(rows) : []
   const footnoteDataKeys = Object.values(visualizations)
     .map(viz => viz.footnotes?.dataKey)
     .filter(Boolean)
   // ensure to only load datasets for the specific dashboard tab.
-  const datasetsUsedByDashboard = _.uniq([...vizDataKeys, ...rowDataKeys, ...footnoteDataKeys])
+  const datasetsUsedByDashboard = _.uniq([
+    ...vizDataKeys,
+    ...rowDataKeys,
+    ...dashboardConditionDataKeys,
+    ...footnoteDataKeys
+  ])
   return Object.keys(datasets).filter(datasetKey => datasetsUsedByDashboard.includes(datasetKey))
 }
 
@@ -113,12 +127,18 @@ export const filterUsedByDataUrl = (
   rows: ConfigRow[]
 ) => {
   if (!filter.usedBy || !filter.usedBy.length) return true
-  const vizUsingFilters = filter.usedBy?.map(vizOrRowKey => visualizations[vizOrRowKey] || rows[vizOrRowKey])
+  const dashboardConditionTargets = getDashboardConditionTargets(rows)
 
-  return vizUsingFilters?.some(viz => {
+  return filter.usedBy.some(vizOrRowKey => {
+    const viz = visualizations[vizOrRowKey] || rows[vizOrRowKey]
     const usedByViz = viz?.dataKey === datasetKey
     // datasetKey might be a key to a dynamic footnotes URL
     const usedByVizFootnote = viz?.footnotes?.dataKey === datasetKey
-    return usedByViz || usedByVizFootnote
+    const usedByDashboardCondition = dashboardConditionTargets.some(
+      conditionTarget =>
+        conditionTarget.dashboardCondition.datasetKey === datasetKey &&
+        `${conditionTarget.filterTarget}` === `${vizOrRowKey}`
+    )
+    return usedByViz || usedByVizFootnote || usedByDashboardCondition
   })
 }

package/src/helpers/removeDashboardFilter.ts

@@ -1,33 +1,33 @@
-import { AnyVisualization } from '@cdc/core/types/Visualization'
-import _ from 'lodash'
-import { SharedFilter } from '../types/SharedFilter'
-
-type Viz = Record<string, AnyVisualization>
-
-export const removeDashboardFilter = (
-  index,
-  sharedFilters: SharedFilter[],
-  visualizations: Viz
-): [SharedFilter[], Viz] => {
-  const newSharedFilters = _.cloneDeep(sharedFilters)
-
-  newSharedFilters.splice(index, 1)
-  const shiftDownIndexes = Object.keys(sharedFilters).slice(index + 1)
-  const newVisualizations: Viz = _.cloneDeep(visualizations)
-  Object.keys(newVisualizations).forEach(vizKey => {
-    const viz = newVisualizations[vizKey]
-    if (viz.type === 'dashboardFilters') {
-      // shift the indexes down
-      const sharedFilterIndexes = viz.sharedFilterIndexes
-        .filter(filterIndex => filterIndex != index)
-        .map(filterIndex => {
-          if (shiftDownIndexes.includes(filterIndex.toString())) {
-            return filterIndex - 1
-          }
-          return filterIndex
-        })
-      newVisualizations[vizKey].sharedFilterIndexes = sharedFilterIndexes
-    }
-  })
-  return [newSharedFilters, newVisualizations]
-}
+import { AnyVisualization } from '@cdc/core/types/Visualization'
+import _ from 'lodash'
+import { SharedFilter } from '../types/SharedFilter'
+
+type Viz = Record<string, AnyVisualization>
+
+export const removeDashboardFilter = (
+  index,
+  sharedFilters: SharedFilter[],
+  visualizations: Viz
+): [SharedFilter[], Viz] => {
+  const newSharedFilters = _.cloneDeep(sharedFilters)
+
+  newSharedFilters.splice(index, 1)
+  const shiftDownIndexes = Object.keys(sharedFilters).slice(index + 1)
+  const newVisualizations: Viz = _.cloneDeep(visualizations)
+  Object.keys(newVisualizations).forEach(vizKey => {
+    const viz = newVisualizations[vizKey]
+    if (viz.type === 'dashboardFilters') {
+      // shift the indexes down
+      const sharedFilterIndexes = (viz.sharedFilterIndexes ?? [])
+        .filter(filterIndex => filterIndex != index)
+        .map(filterIndex => {
+          if (shiftDownIndexes.includes(filterIndex.toString())) {
+            return filterIndex - 1
+          }
+          return filterIndex
+        })
+      newVisualizations[vizKey].sharedFilterIndexes = sharedFilterIndexes
+    }
+  })
+  return [newSharedFilters, newVisualizations]
+}