@cdc/dashboard 4.26.4 → 4.26.5

package/src/helpers/dashboardColumnWidgets.ts

@@ -0,0 +1,99 @@
+import type { ConditionalWidget, DashboardCondition } from '../types/ConfigRow'
+
+type ColumnWithWidgets = {
+  widget?: string | null
+  conditionalWidgets?: ConditionalWidget[]
+}
+
+export const hasConditionalWidgets = (column?: ColumnWithWidgets): boolean => !!column?.conditionalWidgets?.length
+
+export const hasAuthoredWidgetEntries = (column?: ColumnWithWidgets): boolean =>
+  getColumnWidgetEntries(column).length > 0
+
+export const getConditionalWidgets = (column?: ColumnWithWidgets): ConditionalWidget[] =>
+  column?.conditionalWidgets?.filter(entry => !!entry?.widget) || []
+
+export const getColumnWidgetEntries = (column?: ColumnWithWidgets): ConditionalWidget[] => {
+  if (!column) return []
+  if (hasConditionalWidgets(column)) {
+    return getConditionalWidgets(column)
+  }
+
+  return column.widget ? [{ widget: column.widget }] : []
+}
+
+export const getColumnWidgetKeys = (column?: ColumnWithWidgets): string[] =>
+  getColumnWidgetEntries(column)
+    .map(entry => entry.widget)
+    .filter(Boolean)
+
+export const getColumnPrimaryWidget = (column?: ColumnWithWidgets): string | undefined =>
+  getColumnWidgetEntries(column)[0]?.widget
+
+export type DashboardConditionMatch = {
+  matches: boolean
+  resolved: boolean
+}
+
+export type ResolvedColumnWidgetEntry = {
+  widget?: string
+  dashboardCondition?: DashboardCondition
+} & DashboardConditionMatch
+
+type ResolveColumnWidgetOptions = {
+  evaluateCondition?: (dashboardCondition?: DashboardCondition) => DashboardConditionMatch
+}
+
+export const resolveColumnWidgetEntry = (
+  column?: ColumnWithWidgets,
+  { evaluateCondition = () => ({ matches: true, resolved: true }) }: ResolveColumnWidgetOptions = {}
+): ResolvedColumnWidgetEntry | undefined => {
+  const widgetEntries = getColumnWidgetEntries(column)
+
+  for (const entry of widgetEntries) {
+    if (!entry.dashboardCondition) {
+      return { ...entry, matches: true, resolved: true }
+    }
+
+    const evaluation = evaluateCondition(entry.dashboardCondition)
+    if (evaluation.matches) {
+      return { ...entry, ...evaluation }
+    }
+  }
+
+  return widgetEntries.length ? { widget: undefined, matches: false, resolved: true } : undefined
+}
+
+export const normalizeConditionalColumn = <T extends ColumnWithWidgets>(column: T): T => {
+  const conditionalWidgets = getConditionalWidgets(column)
+
+  if (conditionalWidgets.length > 1) {
+    return {
+      ...column,
+      widget: undefined,
+      conditionalWidgets
+    }
+  }
+
+  if (conditionalWidgets.length === 1) {
+    const [entry] = conditionalWidgets
+    if (entry.dashboardCondition) {
+      return {
+        ...column,
+        widget: undefined,
+        conditionalWidgets: [entry]
+      }
+    }
+
+    return {
+      ...column,
+      widget: entry.widget,
+      conditionalWidgets: undefined
+    }
+  }
+
+  return {
+    ...column,
+    conditionalWidgets: undefined
+  }
+}

package/src/helpers/dashboardConditionUi.ts

@@ -0,0 +1,47 @@
+import { DashboardCondition } from '../types/ConfigRow'
+
+export type DashboardConditionTypeOption = DashboardCondition['operator'] | ''
+type DashboardConditionOperator = NonNullable<DashboardCondition['operator']>
+
+export const DASHBOARD_CONDITION_TYPE_LABELS: Record<DashboardConditionOperator, string> = {
+  hasData: "Show when there's data",
+  hasNoData: "Show when there's no data",
+  columnHasAnyValue: 'Show when column has a value',
+  filtersIncomplete: 'Show when filters are incomplete'
+}
+
+export const DASHBOARD_CONDITION_TYPE_OPTIONS: { value: DashboardConditionTypeOption; label: string }[] = [
+  { value: '', label: 'Always show' },
+  { value: 'hasData', label: DASHBOARD_CONDITION_TYPE_LABELS.hasData },
+  { value: 'hasNoData', label: DASHBOARD_CONDITION_TYPE_LABELS.hasNoData },
+  { value: 'columnHasAnyValue', label: DASHBOARD_CONDITION_TYPE_LABELS.columnHasAnyValue },
+  { value: 'filtersIncomplete', label: DASHBOARD_CONDITION_TYPE_LABELS.filtersIncomplete }
+]
+
+export const getColumnHasAnyValueSummaryParts = (columnName?: string) => {
+  if (!columnName) return undefined
+
+  return {
+    prefix: 'Show based on the value in the ',
+    columnName,
+    suffix: ' column'
+  }
+}
+
+export const getColumnHasAnyValueSummary = (columnName?: string) => {
+  const summaryParts = getColumnHasAnyValueSummaryParts(columnName)
+
+  if (!summaryParts) return DASHBOARD_CONDITION_TYPE_LABELS.columnHasAnyValue
+
+  return `${summaryParts.prefix}${summaryParts.columnName}${summaryParts.suffix}`
+}
+
+export const getDashboardConditionSummary = (dashboardCondition?: DashboardCondition) => {
+  if (!dashboardCondition?.operator) return 'Dashboard condition configured'
+
+  if (dashboardCondition.operator === 'columnHasAnyValue') {
+    return getColumnHasAnyValueSummary(dashboardCondition.columnName)
+  }
+
+  return DASHBOARD_CONDITION_TYPE_LABELS[dashboardCondition.operator] || 'Dashboard condition configured'
+}

package/src/helpers/dashboardConditions.ts

@@ -0,0 +1,200 @@
+import { Dashboard } from '../types/Dashboard'
+import { ConfigRow, DashboardCondition } from '../types/ConfigRow'
+import { createCoveId } from '@cdc/core/helpers/createCoveId'
+import { getConditionalWidgets, hasConditionalWidgets } from './dashboardColumnWidgets'
+import { filterData, isFilterAtResetState } from './filterData'
+import {
+  dashboardConditionsSupportedForRow,
+  getApplicableFiltersForTarget,
+  SharedFilterTarget
+} from './dashboardFilterTargets'
+
+export type DashboardConditionEvaluation = {
+  matches: boolean
+  resolved: boolean
+}
+
+export const getDashboardConditionIds = (rows: ConfigRow[] = []) =>
+  rows.flatMap(row => {
+    if (Array.isArray(row)) return []
+
+    const rowConditionIds = row.dashboardCondition?.id ? [row.dashboardCondition.id] : []
+    const columnConditionIds =
+      row.columns?.flatMap(column =>
+        getConditionalWidgets(column).flatMap(entry =>
+          entry.dashboardCondition?.id ? [entry.dashboardCondition.id] : []
+        )
+      ) || []
+
+    return [...rowConditionIds, ...columnConditionIds]
+  })
+
+// This runs during initial config preparation before coveUpdateWorker normalizes legacy dashboard rows.
+// Preserve pre-4.24.3 array-shaped rows for packages/core/helpers/ver/4.24.3.ts, and tolerate rows
+// without normalized columns. This constraint can be removed if CdcDashboard.tsx runs coveUpdateWorker
+// before getUpdateConfig in formatInitialState.
+export const ensureRowConditionIds = (rows: ConfigRow[]): ConfigRow[] => {
+  const existingConditionIds = new Set(getDashboardConditionIds(rows).map(id => String(id)))
+
+  return rows.map(row => {
+    if (Array.isArray(row)) return row
+
+    const nextRow = { ...row }
+
+    if (nextRow.dashboardCondition && !nextRow.dashboardCondition.id) {
+      const id = createCoveId('condition', { existingIds: existingConditionIds })
+      existingConditionIds.add(id)
+      nextRow.dashboardCondition = { ...nextRow.dashboardCondition, id }
+    }
+
+    if (Array.isArray(nextRow.columns)) {
+      nextRow.columns = nextRow.columns.map(column => {
+        if (hasConditionalWidgets(column)) {
+          return {
+            ...column,
+            conditionalWidgets: getConditionalWidgets(column).map(entry => {
+              if (!entry.dashboardCondition || entry.dashboardCondition.id) return entry
+
+              const id = createCoveId('condition', { existingIds: existingConditionIds })
+              existingConditionIds.add(id)
+
+              return {
+                ...entry,
+                dashboardCondition: {
+                  ...entry.dashboardCondition,
+                  id
+                }
+              }
+            })
+          }
+        }
+        return column
+      })
+    }
+
+    return nextRow
+  })
+}
+
+const dashboardConditionHasRequiredInputs = (dashboardCondition?: DashboardCondition) => {
+  if (!dashboardCondition?.operator) return false
+  if (dashboardCondition.operator === 'filtersIncomplete') return true
+  if (!dashboardCondition.datasetKey) return false
+  if (dashboardCondition.operator !== 'columnHasAnyValue') return true
+
+  return !!dashboardCondition.columnName && !!dashboardCondition.values?.length
+}
+
+export const dashboardConditionUsesFiltersIncomplete = (dashboardCondition?: DashboardCondition) =>
+  dashboardCondition?.operator === 'filtersIncomplete'
+
+export const dashboardRowsUseFiltersIncomplete = (rows: ConfigRow[] = []) =>
+  rows.some(row => {
+    if (!dashboardConditionsSupportedForRow(row)) return false
+    if (dashboardConditionUsesFiltersIncomplete(row.dashboardCondition)) return true
+
+    return row.columns?.some(column =>
+      getConditionalWidgets(column).some(entry => dashboardConditionUsesFiltersIncomplete(entry.dashboardCondition))
+    )
+  })
+
+export const getDashboardConditionDatasetKeys = (rows: ConfigRow[] = []) =>
+  rows.flatMap(row => {
+    if (!dashboardConditionsSupportedForRow(row)) return []
+
+    const rowDatasetKey = row.dashboardCondition?.datasetKey ? [row.dashboardCondition.datasetKey] : []
+    const columnDatasetKeys =
+      row.columns?.flatMap(column =>
+        getConditionalWidgets(column).flatMap(entry =>
+          entry.dashboardCondition?.datasetKey ? [entry.dashboardCondition.datasetKey] : []
+        )
+      ) || []
+
+    return [...rowDatasetKey, ...columnDatasetKeys]
+  })
+
+const getDashboardConditionApplicableFilters = (
+  dashboard: Dashboard,
+  filterTarget: SharedFilterTarget,
+  datasetColumns: string[]
+) => {
+  const candidateFilters = getApplicableFiltersForTarget(dashboard, filterTarget, { includeUnscoped: true })
+  if (!candidateFilters) return []
+
+  return candidateFilters.filter(filter => !!filter.columnName && datasetColumns.includes(filter.columnName))
+}
+
+export const hasIncompleteFiltersForDashboardCondition = (
+  dashboardCondition: DashboardCondition | undefined,
+  dashboard: Dashboard,
+  filterTarget: SharedFilterTarget = ''
+) => {
+  if (!dashboardCondition?.id) return false
+
+  const applicableFilters = getApplicableFiltersForTarget(dashboard, filterTarget, { includeUnscoped: true })
+  if (!applicableFilters) return false
+
+  return applicableFilters.some(isFilterAtResetState)
+}
+
+export const getDashboardConditionFilteredData = (
+  dashboardCondition: DashboardCondition | undefined,
+  dashboard: Dashboard,
+  data: Record<string, any[]>,
+  filterTarget: SharedFilterTarget = ''
+): Record<string, any>[] | undefined => {
+  if (!dashboardConditionHasRequiredInputs(dashboardCondition)) {
+    return undefined
+  }
+
+  if (dashboardCondition.operator === 'filtersIncomplete') {
+    return hasIncompleteFiltersForDashboardCondition(dashboardCondition, dashboard, filterTarget) ? [{}] : []
+  }
+
+  const rawDataset = data[dashboardCondition.datasetKey]
+  if (!Array.isArray(rawDataset)) {
+    return undefined
+  }
+  const dataset = rawDataset || []
+
+  const datasetColumns = dataset[0] ? Object.keys(dataset[0]) : []
+  const applicableFilters = getDashboardConditionApplicableFilters(dashboard, filterTarget, datasetColumns)
+
+  if (applicableFilters.some(isFilterAtResetState)) {
+    return undefined
+  }
+
+  return applicableFilters.length ? filterData(applicableFilters, dataset) : dataset
+}
+
+export const evaluateDashboardCondition = (
+  dashboardCondition: DashboardCondition | undefined,
+  filteredData?: Record<string, any>[]
+): DashboardConditionEvaluation => {
+  if (!dashboardConditionHasRequiredInputs(dashboardCondition) || filteredData === undefined) {
+    return { matches: false, resolved: false }
+  }
+
+  if (dashboardCondition.operator === 'hasData') {
+    return { matches: filteredData.length > 0, resolved: true }
+  }
+
+  if (dashboardCondition.operator === 'hasNoData') {
+    return { matches: filteredData.length === 0, resolved: true }
+  }
+
+  if (dashboardCondition.operator === 'filtersIncomplete') {
+    return { matches: filteredData.length > 0, resolved: true }
+  }
+
+  const matches = filteredData.some(row => {
+    const currentValue = row?.[dashboardCondition.columnName]
+    return (
+      currentValue !== undefined &&
+      currentValue !== null &&
+      dashboardCondition.values?.some(value => String(currentValue) === String(value))
+    )
+  })
+
+  return { matches, resolved: true }
+}

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 = {}