@cdc/dashboard 4.26.3 → 4.26.5

package/src/components/dashboard-condition-summary.css

@@ -0,0 +1,87 @@
+.cove-visualization button.cove-button.dashboard-condition-summary {
+  align-items: center !important;
+  align-self: stretch;
+  background: var(--dashboard-condition-active-blue-bg, #f2f7fb) !important;
+  border: 1px solid var(--dashboard-condition-active-blue, var(--blue)) !important;
+  border-radius: 4px;
+  box-shadow: none;
+  box-sizing: border-box;
+  color: var(--dashboard-condition-active-blue, var(--blue)) !important;
+  display: inline-flex !important;
+  flex-direction: row !important;
+  flex-wrap: nowrap !important;
+  font-family: var(--app-font-main, sans-serif) !important;
+  font-size: 0.8rem !important;
+  font-weight: 400 !important;
+  gap: 0.35rem;
+  justify-content: flex-start;
+  line-height: 1.2;
+  margin: 0 0 0.5rem;
+  min-height: 24px !important;
+  overflow: visible;
+  padding: 0.2rem 0.45rem !important;
+  text-align: left;
+  transform: none;
+  white-space: normal;
+  width: 100%;
+}
+
+.cove-visualization button.cove-button.dashboard-condition-summary:hover,
+.cove-visualization button.cove-button.dashboard-condition-summary:active,
+.cove-visualization button.cove-button.dashboard-condition-summary:focus {
+  background: var(--dashboard-condition-active-blue-bg-hover, #e6eff7) !important;
+  box-shadow: none;
+  color: var(--dashboard-condition-active-blue, var(--blue)) !important;
+  transform: none;
+}
+
+.cove-visualization button.cove-button.dashboard-condition-summary .dashboard-condition-summary__icon {
+  align-items: center;
+  display: inline-flex;
+  flex: 0 0 auto;
+  line-height: 1.2;
+  margin-top: 0.05rem;
+}
+
+.cove-visualization button.cove-button.dashboard-condition-summary .dashboard-condition-summary__icon svg {
+  display: block;
+  fill: currentColor;
+  height: 1em;
+  margin: 0 !important;
+  position: static;
+  top: auto;
+  transform: none;
+  width: 1em;
+}
+
+.cove-visualization button.cove-button.dashboard-condition-summary .dashboard-condition-summary__text {
+  display: block;
+  flex: 1 1 auto;
+  font-family: var(--app-font-main, sans-serif) !important;
+  font-size: 0.8rem !important;
+  font-weight: 400 !important;
+  line-height: 1.2;
+  min-width: 0;
+  overflow-wrap: break-word;
+  white-space: normal;
+  word-break: normal;
+}
+
+.cove-visualization button.cove-button.dashboard-condition-summary .dashboard-condition-summary__text strong {
+  font-family: inherit;
+  font-size: inherit;
+  font-weight: 700;
+  line-height: inherit;
+}
+
+.cove-visualization button.cove-button.dashboard-condition-summary.dashboard-condition-summary--row {
+  margin-top: 0.5rem;
+}
+
+.cove-visualization button.cove-button.dashboard-condition-summary.dashboard-condition-summary--widget {
+  align-items: flex-start !important;
+  flex: 0 0 auto;
+  margin: 0.5rem 0 0.4rem;
+  max-width: 100%;
+  width: 100%;
+}

package/src/data/initial-state.js

@@ -10,6 +10,7 @@ export default {
     label: 'Data Table',
     show: true,
     showDownloadUrl: false,
+    downloadUrlLabel: '',
     showDownloadLinkBelow: true,
     showVertical: true
   }

package/src/helpers/addValuesToDashboardFilters.ts

@@ -58,11 +58,9 @@ export const addValuesToDashboardFilters = (
         const active: string[] = Array.isArray(filterCopy.active) ? filterCopy.active : [filterCopy.active]
         filterCopy.active = active.filter(val => defaultValues.includes(val))
       } else {
-        // Use defaultValue if set, otherwise keep existing active or use first value
-        if (filterCopy.defaultValue) {
-          filterCopy.active = filterCopy.defaultValue
-        } else if (!filterCopy.active) {
-          filterCopy.active = filterCopy.resetLabel || filterCopy.values[0]
+        // Only set active when it is not already set; prefer defaultValue, then resetLabel, then first value
+        if (!filterCopy.active) {
+          filterCopy.active = filterCopy.defaultValue || filterCopy.resetLabel || filterCopy.values[0]
         }
       }
     }

package/src/helpers/addVisualization.ts

@@ -1,14 +1,22 @@
 import type { AnyVisualization } from '@cdc/core/types/Visualization'
 import type { Table } from '@cdc/core/types/Table'
+import { createCoveId } from '@cdc/core/helpers/createCoveId'
+import type { CreateCoveIdOptions } from '@cdc/core/helpers/createCoveId'
+
+export const addVisualization = (type, subType, idOptions?: CreateCoveIdOptions) => {
+  if (type === 'filtered-text') {
+    throw new Error(
+      'Cannot create new filtered-text visualizations. filtered-text is deprecated; use markup-include instead.'
+    )
+  }
 
-export const addVisualization = (type, subType) => {
   const modalWillOpen = type !== 'markup-include'
   const newVisualizationConfig: Partial<AnyVisualization> = {
     filters: [],
     filterBehavior: 'Filter Change',
     newViz: type !== 'table',
     openModal: modalWillOpen,
-    uid: type + Date.now(),
+    uid: createCoveId(type, idOptions),
     type
   }
 
@@ -35,10 +43,12 @@ export const addVisualization = (type, subType) => {
       }
       break
     case 'data-bite':
-    case 'waffle-chart':
-    case 'filtered-text':
+      newVisualizationConfig.biteStyle = 'tp5'
       newVisualizationConfig.visualizationType = type
       break
+    case 'waffle-chart':
+      newVisualizationConfig.visualizationType = subType === 'Waffle' ? 'TP5 Waffle' : subType
+      break
     case 'table': {
       const tableConfig: Table = {
         label: 'Data Table',
@@ -59,6 +69,9 @@ export const addVisualization = (type, subType) => {
       break
     case 'dashboardFilters': {
       newVisualizationConfig.sharedFilterIndexes = []
+      newVisualizationConfig.visual = {
+        grayBackground: false
+      }
       newVisualizationConfig.visualizationType = type
       break
     }

package/src/helpers/cloneDashboardWidget.ts

@@ -0,0 +1,127 @@
+import _ from 'lodash'
+import type { AnyVisualization } from '@cdc/core/types/Visualization'
+import { createCoveId } from '@cdc/core/helpers/createCoveId'
+import type { DashboardConfig } from '../types/DashboardConfig'
+import { ConfigRow, DashboardCondition } from '../types/ConfigRow'
+import { getDashboardConditionIds } from './dashboardConditions'
+import { getConditionalWidgets, hasConditionalWidgets, normalizeConditionalColumn } from './dashboardColumnWidgets'
+
+export type CloneDashboardWidgetTarget = {
+  rowIdx: number
+  colIdx: number
+  entryIdx?: number
+}
+
+const normalizeTarget = (target: string | number) => `${target}`
+
+const appendTarget = (targets: (string | number)[], target: string | number) => {
+  if (targets.some(existingTarget => normalizeTarget(existingTarget) === normalizeTarget(target))) return targets
+  return [...targets, target]
+}
+
+const createClonedWidgetKey = (sourceWidgetKey: string, visualizations: Record<string, AnyVisualization>) => {
+  const sourceVisualization = visualizations[sourceWidgetKey]
+  return createCoveId(sourceVisualization.type, { existingIds: Object.keys(visualizations) })
+}
+
+const getSourceDashboardCondition = (rows: ConfigRow[], sourceWidgetKey: string): DashboardCondition | undefined => {
+  for (const row of rows) {
+    for (const column of row.columns || []) {
+      if (!hasConditionalWidgets(column)) continue
+
+      const sourceEntry = getConditionalWidgets(column).find(entry => entry.widget === sourceWidgetKey)
+      if (sourceEntry?.dashboardCondition) return sourceEntry.dashboardCondition
+    }
+  }
+
+  return undefined
+}
+
+const getWidgetFilterTarget = (rows: ConfigRow[], widgetKey: string): string | number => {
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+    const row = rows[rowIndex]
+    const widgetInRow = row.columns?.some(
+      column => column.widget === widgetKey || getConditionalWidgets(column).some(entry => entry.widget === widgetKey)
+    )
+
+    if (widgetInRow) {
+      return row.dataKey ? rowIndex : widgetKey
+    }
+  }
+
+  return widgetKey
+}
+
+export const cloneDashboardWidget = (
+  config: DashboardConfig,
+  sourceWidgetKey: string,
+  target: CloneDashboardWidgetTarget
+): DashboardConfig => {
+  const sourceVisualization = config.visualizations?.[sourceWidgetKey]
+  const targetColumn = config.rows?.[target.rowIdx]?.columns?.[target.colIdx]
+
+  if (!sourceVisualization || !targetColumn) return config
+
+  if (target.entryIdx !== undefined) {
+    const existingEntry = getConditionalWidgets(targetColumn)[target.entryIdx]
+    if (existingEntry?.widget) return config
+  } else if (targetColumn.widget || hasConditionalWidgets(targetColumn)) {
+    return config
+  }
+
+  const clonedWidgetKey = createClonedWidgetKey(sourceWidgetKey, config.visualizations)
+  const clonedVisualization = { ..._.cloneDeep(sourceVisualization), uid: clonedWidgetKey }
+  const sourceDashboardCondition = getSourceDashboardCondition(config.rows, sourceWidgetKey)
+  const clonedDashboardCondition = sourceDashboardCondition
+    ? {
+        ..._.cloneDeep(sourceDashboardCondition),
+        id: createCoveId('condition', { existingIds: getDashboardConditionIds(config.rows) })
+      }
+    : undefined
+
+  const nextRows = _.cloneDeep(config.rows)
+  const nextTargetColumn = nextRows[target.rowIdx].columns[target.colIdx]
+
+  if (target.entryIdx !== undefined || hasConditionalWidgets(nextTargetColumn) || clonedDashboardCondition) {
+    const nextConditionalWidgets = [...(nextTargetColumn.conditionalWidgets || [])]
+    const targetEntryIndex = target.entryIdx ?? nextConditionalWidgets.length
+    nextConditionalWidgets[targetEntryIndex] = {
+      widget: clonedWidgetKey,
+      ...(clonedDashboardCondition ? { dashboardCondition: clonedDashboardCondition } : {})
+    }
+    nextRows[target.rowIdx].columns[target.colIdx] = normalizeConditionalColumn({
+      ...nextTargetColumn,
+      widget: undefined,
+      conditionalWidgets: nextConditionalWidgets.filter(entry => !!entry?.widget)
+    })
+  } else {
+    nextRows[target.rowIdx].columns[target.colIdx].widget = clonedWidgetKey
+  }
+
+  const sourceFilterTarget = getWidgetFilterTarget(config.rows, sourceWidgetKey)
+  const clonedFilterTarget = nextRows[target.rowIdx]?.dataKey ? target.rowIdx : clonedWidgetKey
+  const sharedFilters = config.dashboard.sharedFilters?.map(sharedFilter => {
+    if (!sharedFilter.usedBy?.length) return sharedFilter
+
+    let nextUsedBy = sharedFilter.usedBy
+
+    if (sharedFilter.usedBy.some(target => normalizeTarget(target) === normalizeTarget(sourceFilterTarget))) {
+      nextUsedBy = appendTarget(nextUsedBy, clonedFilterTarget)
+    }
+
+    return nextUsedBy === sharedFilter.usedBy ? sharedFilter : { ...sharedFilter, usedBy: nextUsedBy }
+  })
+
+  return {
+    ...config,
+    dashboard: {
+      ...config.dashboard,
+      ...(sharedFilters ? { sharedFilters } : {})
+    },
+    rows: nextRows,
+    visualizations: {
+      ...config.visualizations,
+      [clonedWidgetKey]: clonedVisualization
+    }
+  }
+}

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 }
+}