@gooddata/sdk-ui-dashboard 11.62.0-alpha.2 → 11.62.0-alpha.4

package/esm/model/store/tabs/filterContext/filterContextReducers.js

@@ -1,10 +1,11 @@
 // (C) 2021-2026 GoodData Corporation
 import { invariant } from "ts-invariant";
-import { areObjRefsEqual, attributeElementsIsEmpty, dashboardAttributeFilterItemFilterElementsBy, dashboardAttributeFilterItemFilterElementsByDate, dashboardAttributeFilterItemLocalIdentifier, dashboardAttributeFilterItemValidateElementsBy, dashboardFilterLocalIdentifier, isAttributeElementsByRef, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardMatchAttributeFilter, isDashboardMeasureValueFilter, newAllTimeDashboardDateFilter, } from "@gooddata/sdk-model";
+import { areObjRefsEqual, attributeElementsIsEmpty, dashboardAttributeFilterItemLocalIdentifier, dashboardFilterLocalIdentifier, isAllTimeDashboardDateFilter, isAttributeElementsByRef, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardMatchAttributeFilter, isDashboardMeasureValueFilter, newAllTimeDashboardDateFilter, } from "@gooddata/sdk-model";
 import { generateFilterLocalIdentifier, generateMeasureValueFilterLocalIdentifier, } from "../../_infra/generators.js";
-import { getActiveTab, getTabOrActive } from "../tabsState.js";
+import { getActiveTab, getTabOrActive, getTabsToMutate, } from "../tabsState.js";
 import { filterContextInitialState } from "./filterContextState.js";
 import { applyFilterContext, initializeFilterContext } from "./filterContextUtils.js";
+import { findCounterpartFilter, findOriginalFilter, isCrossFilteringVirtualFilter, preserveFilterDependencies, retargetAttributeFilterItem, } from "./filterSync.js";
 const setFilterContext = (state, action) => {
     const activeTab = getActiveTab(state);
     if (!activeTab) {
@@ -91,18 +92,90 @@ const setPreloadedAttributesWithReferences = (state, action) => {
     state.attributesWithReferences = action.payload;
 };
 const upsertDateFilter = (state, action) => {
-    const targetTab = getTabOrActive(state, action.payload.tabLocalIdentifier);
-    if (!targetTab) {
+    const { tabLocalIdentifier, enablePersistentFiltersAcrossTabs, isWorkingSelectionChange } = action.payload;
+    const tabs = getTabsToMutate(state, tabLocalIdentifier, enablePersistentFiltersAcrossTabs, isWorkingSelectionChange);
+    const source = tabs[0];
+    if (!source) {
         return;
     }
+    upsertDateFilterOnTab(source, action.payload, true);
+    for (const tab of tabs.slice(1)) {
+        const payload = action.payload.restoreTargetOriginal
+            ? restoredDateFilterPayload(tab, action.payload)
+            : action.payload;
+        if (!payload) {
+            continue;
+        }
+        upsertDateFilterOnTab(tab, payload, false);
+    }
+};
+/**
+ * Saved date filter for a non-source tab during reset.
+ * A common date filter with no saved original is all time, which is stored as the filter's absence.
+ * A dimension date filter with no counterpart, or no saved original, is left unchanged.
+ */
+function restoredDateFilterPayload(tab, payload) {
+    const applied = findAppliedDateFilter(tab, payload.dataSet);
+    if (!applied && payload.dataSet) {
+        return undefined;
+    }
+    const original = findOriginalFilter(tab, applied ?? {
+        dateFilter: { type: "relative", granularity: "GDC.time.date" },
+    });
+    if (isDashboardDateFilter(original)) {
+        return toUpsertDateFilterPayload(original, payload);
+    }
+    if (!payload.dataSet) {
+        return { type: "allTime" };
+    }
+    return undefined;
+}
+function findAppliedDateFilter(tab, dataSet) {
+    const filters = tab.filterContext?.filterContextDefinition?.filters;
+    if (!filters) {
+        return undefined;
+    }
+    if (dataSet) {
+        return filters.find((item) => isDashboardDateFilter(item) && areObjRefsEqual(item.dateFilter.dataSet, dataSet));
+    }
+    return filters.find(isDashboardCommonDateFilter);
+}
+function toUpsertDateFilterPayload(filter, source) {
+    const { dataSet, localIdentifier, emptyValueHandling, boundedFilter, type, granularity, from, to } = filter.dateFilter;
+    const shared = {
+        ...(dataSet ? { dataSet } : {}),
+        ...(localIdentifier ? { localIdentifier } : {}),
+        ...(emptyValueHandling ? { emptyValueHandling } : {}),
+        ...(source.isWorkingSelectionChange ? { isWorkingSelectionChange: true } : {}),
+        ...(source.tabLocalIdentifier ? { tabLocalIdentifier: source.tabLocalIdentifier } : {}),
+    };
+    if (isAllTimeDashboardDateFilter(filter)) {
+        return { type: "allTime", ...shared };
+    }
+    return {
+        type,
+        granularity,
+        from,
+        to,
+        ...(boundedFilter ? { boundedFilter } : {}),
+        ...shared,
+    };
+}
+function upsertDateFilterOnTab(targetTab, payload, isSource) {
     if (!targetTab.filterContext) {
+        if (!isSource) {
+            return;
+        }
         targetTab.filterContext = { ...filterContextInitialState };
     }
-    const filterContextDefinition = action.payload.isWorkingSelectionChange
+    const filterContextDefinition = payload.isWorkingSelectionChange
         ? targetTab.filterContext.workingFilterContextDefinition
         : targetTab.filterContext.filterContextDefinition;
+    if (!isSource && !filterContextDefinition?.filters) {
+        return;
+    }
     invariant(filterContextDefinition?.filters, "Attempt to edit uninitialized filter context");
-    const dateDataSet = action.payload.dataSet;
+    const dateDataSet = payload.dataSet;
     let existingFilterIndex = -1;
     if (dateDataSet) {
         existingFilterIndex = filterContextDefinition.filters.findIndex((item) => isDashboardDateFilter(item) && areObjRefsEqual(item.dateFilter.dataSet, dateDataSet));
@@ -110,30 +183,39 @@ const upsertDateFilter = (state, action) => {
     else {
         existingFilterIndex = filterContextDefinition.filters.findIndex((item) => isDashboardCommonDateFilter(item));
     }
-    if (action.payload.isWorkingSelectionChange && action.payload.type === "allTime") {
+    if (!isSource && existingFilterIndex < 0 && dateDataSet) {
+        return;
+    }
+    if (payload.isWorkingSelectionChange && payload.type === "allTime") {
         // we need to allways set working filter to distinguish between "not changed" and "all time" filter
         if (existingFilterIndex >= 0) {
             const dateFilter = filterContextDefinition.filters[existingFilterIndex];
             if (isDashboardDateFilter(dateFilter)) {
-                filterContextDefinition.filters[existingFilterIndex] = newAllTimeDashboardDateFilter(dateFilter.dateFilter.dataSet, dateFilter.dateFilter.localIdentifier, action.payload.emptyValueHandling);
+                filterContextDefinition.filters[existingFilterIndex] = newAllTimeDashboardDateFilter(dateFilter.dateFilter.dataSet, dateFilter.dateFilter.localIdentifier, payload.emptyValueHandling);
             }
         }
         else {
-            filterContextDefinition.filters.unshift(newAllTimeDashboardDateFilter(action.payload.dataSet, action.payload.localIdentifier, action.payload.emptyValueHandling));
+            filterContextDefinition.filters.unshift(newAllTimeDashboardDateFilter(payload.dataSet, payload.localIdentifier, payload.emptyValueHandling));
         }
     }
-    else if (action.payload.type === "allTime") {
+    else if (payload.type === "allTime") {
         if (existingFilterIndex >= 0) {
             if (dateDataSet) {
                 const dateFilter = filterContextDefinition.filters[existingFilterIndex];
                 if (isDashboardDateFilter(dateFilter)) {
-                    filterContextDefinition.filters[existingFilterIndex] = newAllTimeDashboardDateFilter(dateFilter.dateFilter.dataSet, dateFilter.dateFilter.localIdentifier, action.payload.emptyValueHandling);
+                    filterContextDefinition.filters[existingFilterIndex] = newAllTimeDashboardDateFilter(dateFilter.dateFilter.dataSet, dateFilter.dateFilter.localIdentifier, payload.emptyValueHandling);
                 }
             }
             else {
-                if (action.payload.emptyValueHandling) {
+                const existing = filterContextDefinition.filters[existingFilterIndex];
+                const preservedLocalIdentifier = isSource
+                    ? payload.localIdentifier
+                    : isDashboardDateFilter(existing)
+                        ? existing.dateFilter.localIdentifier
+                        : undefined;
+                if (payload.emptyValueHandling) {
                     // Preserve all-time common DF when it carries additional config (e.g. emptyValueHandling).
-                    filterContextDefinition.filters[existingFilterIndex] = newAllTimeDashboardDateFilter(undefined, action.payload.localIdentifier, action.payload.emptyValueHandling);
+                    filterContextDefinition.filters[existingFilterIndex] = newAllTimeDashboardDateFilter(undefined, preservedLocalIdentifier, payload.emptyValueHandling);
                 }
                 else {
                     // if allTime common DF remove the date filter altogether
@@ -141,20 +223,20 @@ const upsertDateFilter = (state, action) => {
                 }
             }
         }
-        else if (!dateDataSet && action.payload.emptyValueHandling) {
+        else if (!dateDataSet && payload.emptyValueHandling) {
             // No common date filter existed (all time was represented by absence); create it to preserve extra config.
-            filterContextDefinition.filters.unshift(newAllTimeDashboardDateFilter(undefined, action.payload.localIdentifier, action.payload.emptyValueHandling));
+            filterContextDefinition.filters.unshift(newAllTimeDashboardDateFilter(undefined, payload.localIdentifier, payload.emptyValueHandling));
         }
     }
     else if (existingFilterIndex >= 0) {
-        const { type, granularity, from, to, localIdentifier, boundedFilter, emptyValueHandling } = action.payload;
+        const { type, granularity, from, to, localIdentifier, boundedFilter, emptyValueHandling } = payload;
         const dateFilter = filterContextDefinition.filters[existingFilterIndex];
         if (isDashboardDateFilter(dateFilter)) {
             dateFilter.dateFilter.type = type;
             dateFilter.dateFilter.granularity = granularity;
             dateFilter.dateFilter.from = from;
             dateFilter.dateFilter.to = to;
-            if (localIdentifier) {
+            if (localIdentifier && isSource) {
                 dateFilter.dateFilter.localIdentifier = localIdentifier;
             }
             if (boundedFilter) {
@@ -171,8 +253,8 @@ const upsertDateFilter = (state, action) => {
             }
         }
     }
-    else {
-        const { type, granularity, from, to, dataSet, localIdentifier, boundedFilter, emptyValueHandling } = action.payload;
+    else if (isSource || !dateDataSet) {
+        const { type, granularity, from, to, dataSet, localIdentifier, boundedFilter, emptyValueHandling } = payload;
         filterContextDefinition.filters.unshift({
             dateFilter: {
                 granularity,
@@ -186,21 +268,71 @@ const upsertDateFilter = (state, action) => {
             },
         });
     }
-};
+}
 const updateAttributeFilterSelection = (state, action) => {
-    const targetTab = getTabOrActive(state, action.payload.tabLocalIdentifier);
-    if (!targetTab) {
+    const { tabLocalIdentifier, enablePersistentFiltersAcrossTabs, isWorkingSelectionChange, crossFilteringLocalIdsByTab, } = action.payload;
+    const tabs = getTabsToMutate(state, tabLocalIdentifier, enablePersistentFiltersAcrossTabs, isWorkingSelectionChange);
+    const source = tabs[0];
+    if (!source) {
+        return;
+    }
+    const sourceFilter = findAppliedFilterByLocalId(source, action.payload.filterLocalId);
+    updateAttributeFilterSelectionOnTab(source, action.payload, action.payload.filterLocalId, true);
+    if (tabs.length === 1 ||
+        !sourceFilter ||
+        !isDashboardAttributeFilter(sourceFilter) ||
+        isCrossFilteringVirtualFilter(source, action.payload.filterLocalId, crossFilteringLocalIdsByTab)) {
         return;
     }
+    for (const tab of tabs.slice(1)) {
+        const match = findCounterpartFilter(source, sourceFilter, tab, state.attributesWithReferences, {
+            allowListToText: false,
+            crossFilteringLocalIdsByTab,
+        });
+        if (!match || !isDashboardAttributeFilter(match)) {
+            continue;
+        }
+        const targetLocalId = match.attributeFilter.localIdentifier;
+        if (!targetLocalId) {
+            continue;
+        }
+        const original = action.payload.restoreTargetOriginal ? findOriginalFilter(tab, match) : undefined;
+        if (action.payload.restoreTargetOriginal && !isDashboardAttributeFilter(original)) {
+            continue;
+        }
+        updateAttributeFilterSelectionOnTab(tab, {
+            ...action.payload,
+            filterLocalId: targetLocalId,
+            ...(isDashboardAttributeFilter(original)
+                ? {
+                    elements: original.attributeFilter.attributeElements,
+                    negativeSelection: original.attributeFilter.negativeSelection,
+                }
+                : {}),
+            enableImmediateAttributeFilterDisplayAsLabelMigration: false,
+            isResultOfMigration: false,
+        }, targetLocalId, false);
+    }
+};
+function updateAttributeFilterSelectionOnTab(targetTab, payload, filterLocalId, isSource) {
     if (!targetTab.filterContext) {
+        if (!isSource) {
+            return;
+        }
         targetTab.filterContext = { ...filterContextInitialState };
     }
-    const { elements, filterLocalId, negativeSelection, isWorkingSelectionChange, enableImmediateAttributeFilterDisplayAsLabelMigration, isResultOfMigration, isSelectionInvalid, } = action.payload;
+    const { elements, negativeSelection, isWorkingSelectionChange, enableImmediateAttributeFilterDisplayAsLabelMigration, isResultOfMigration, isSelectionInvalid, } = payload;
     const filterContextDefinition = isWorkingSelectionChange
         ? targetTab.filterContext.workingFilterContextDefinition
         : targetTab.filterContext.filterContextDefinition;
+    if (!isSource && !filterContextDefinition?.filters) {
+        return;
+    }
     invariant(filterContextDefinition?.filters, "Attempt to edit uninitialized filter context");
     const existingFilterIndex = filterContextDefinition.filters.findIndex((item) => isDashboardAttributeFilter(item) && item.attributeFilter.localIdentifier === filterLocalId);
+    if (!isSource && existingFilterIndex < 0) {
+        return;
+    }
     invariant(existingFilterIndex >= 0 || isWorkingSelectionChange, "Attempt to update non-existing filter");
     if (isWorkingSelectionChange && existingFilterIndex >= 0) {
         filterContextDefinition.filters[existingFilterIndex] = {
@@ -241,6 +373,9 @@ const updateAttributeFilterSelection = (state, action) => {
             };
         }
     }
+    if (!targetTab.filterContext.filtersWithInvalidSelection) {
+        targetTab.filterContext.filtersWithInvalidSelection = [];
+    }
     // Handle isSelectionInvalid flag to update filtersWithInvalidSelection array
     if (isSelectionInvalid) {
         // Add filterLocalId to the array if not already present
@@ -253,58 +388,65 @@ const updateAttributeFilterSelection = (state, action) => {
         targetTab.filterContext.filtersWithInvalidSelection =
             targetTab.filterContext.filtersWithInvalidSelection.filter((id) => id !== filterLocalId);
     }
-};
-/**
- * Carries over filterElementsBy, filterElementsByDate, and validateElementsBy from the existing filter
- * to the replacement filter, so that parent filter dependencies are not lost
- * when filter selection/params change.
- */
-function preserveFilterDependencies(existing, replacement) {
-    const filterElementsBy = dashboardAttributeFilterItemFilterElementsBy(existing);
-    const filterElementsByDate = dashboardAttributeFilterItemFilterElementsByDate(existing);
-    const validateElementsBy = dashboardAttributeFilterItemValidateElementsBy(existing);
-    if (!filterElementsBy?.length && !filterElementsByDate?.length && !validateElementsBy?.length) {
-        return replacement;
-    }
-    const preserved = {
-        ...(filterElementsBy?.length ? { filterElementsBy } : {}),
-        ...(filterElementsByDate?.length ? { filterElementsByDate } : {}),
-        ...(validateElementsBy?.length ? { validateElementsBy } : {}),
-    };
-    if (isDashboardAttributeFilter(replacement)) {
-        return {
-            attributeFilter: {
-                ...replacement.attributeFilter,
-                ...preserved,
-            },
-        };
-    }
-    if (isDashboardArbitraryAttributeFilter(replacement)) {
-        return {
-            arbitraryAttributeFilter: {
-                ...replacement.arbitraryAttributeFilter,
-                ...preserved,
-            },
-        };
-    }
-    // Match filters do not support parent dependencies
-    return replacement;
+}
+function findAppliedFilterByLocalId(tab, localIdentifier) {
+    return tab.filterContext?.filterContextDefinition?.filters.find((item) => dashboardFilterLocalIdentifier(item) === localIdentifier);
 }
 const replaceAttributeFilterItem = (state, action) => {
-    const targetTab = getTabOrActive(state, action.payload.tabLocalIdentifier);
-    if (!targetTab) {
+    const { tabLocalIdentifier, enablePersistentFiltersAcrossTabs, isWorkingSelectionChange, crossFilteringLocalIdsByTab, } = action.payload;
+    const tabs = getTabsToMutate(state, tabLocalIdentifier, enablePersistentFiltersAcrossTabs, isWorkingSelectionChange);
+    const source = tabs[0];
+    if (!source) {
         return;
     }
+    const sourceFilter = findAppliedFilterByLocalId(source, action.payload.filterLocalId);
+    replaceAttributeFilterItemOnTab(source, action.payload, action.payload.filter, true);
+    if (tabs.length === 1 ||
+        !sourceFilter ||
+        !isDashboardAttributeFilterItem(sourceFilter) ||
+        isCrossFilteringVirtualFilter(source, action.payload.filterLocalId, crossFilteringLocalIdsByTab)) {
+        return;
+    }
+    for (const tab of tabs.slice(1)) {
+        const match = findCounterpartFilter(source, sourceFilter, tab, state.attributesWithReferences, {
+            allowListToText: true,
+            crossFilteringLocalIdsByTab,
+        });
+        if (!match || !isDashboardAttributeFilterItem(match)) {
+            continue;
+        }
+        const targetLocalId = dashboardAttributeFilterItemLocalIdentifier(match);
+        if (!targetLocalId) {
+            continue;
+        }
+        const original = action.payload.restoreTargetOriginal ? findOriginalFilter(tab, match) : undefined;
+        if (action.payload.restoreTargetOriginal && !isDashboardAttributeFilterItem(original)) {
+            continue;
+        }
+        const replacement = isDashboardAttributeFilterItem(original) ? original : action.payload.filter;
+        replaceAttributeFilterItemOnTab(tab, { ...action.payload, filterLocalId: targetLocalId }, retargetAttributeFilterItem(replacement, targetLocalId), false);
+    }
+};
+function replaceAttributeFilterItemOnTab(targetTab, payload, filter, isSource) {
     if (!targetTab.filterContext) {
+        if (!isSource) {
+            return;
+        }
         targetTab.filterContext = { ...filterContextInitialState };
     }
-    const { filterLocalId, filter, isWorkingSelectionChange, isSelectionInvalid } = action.payload;
+    const { filterLocalId, isWorkingSelectionChange, isSelectionInvalid } = payload;
     const filterContextDefinition = isWorkingSelectionChange
         ? targetTab.filterContext.workingFilterContextDefinition
         : targetTab.filterContext.filterContextDefinition;
+    if (!isSource && !filterContextDefinition?.filters) {
+        return;
+    }
     invariant(filterContextDefinition?.filters, "Attempt to edit uninitialized filter context");
     const existingFilterIndex = filterContextDefinition.filters.findIndex((item) => isDashboardAttributeFilterItem(item) &&
         dashboardAttributeFilterItemLocalIdentifier(item) === filterLocalId);
+    if (!isSource && existingFilterIndex < 0) {
+        return;
+    }
     // Preserve parent filter relationships from the existing filter when replacing.
     // The replacement filter typically only carries selection data, not dependency configuration.
     const replacementFilter = existingFilterIndex >= 0
@@ -323,6 +465,9 @@ const replaceAttributeFilterItem = (state, action) => {
     else if (existingFilterIndex >= 0) {
         filters[existingFilterIndex] = replacementFilter;
     }
+    if (!targetTab.filterContext.filtersWithInvalidSelection) {
+        targetTab.filterContext.filtersWithInvalidSelection = [];
+    }
     // Handle isSelectionInvalid flag to update filtersWithInvalidSelection array
     if (isSelectionInvalid) {
         if (!targetTab.filterContext.filtersWithInvalidSelection.includes(filterLocalId)) {
@@ -333,7 +478,7 @@ const replaceAttributeFilterItem = (state, action) => {
         targetTab.filterContext.filtersWithInvalidSelection =
             targetTab.filterContext.filtersWithInvalidSelection.filter((id) => id !== filterLocalId);
     }
-};
+}
 const addAttributeFilter = (state, action) => {
     const activeTab = getActiveTab(state);
     if (!activeTab) {
@@ -496,26 +641,71 @@ const setAttributeFilterDependentDateFilters = (state, action) => {
     // Match filters do not support filterElementsByDate
 };
 const clearAttributeFiltersSelection = (state, action) => {
-    const targetTab = getTabOrActive(state, action.payload.tabLocalIdentifier);
-    if (!targetTab) {
+    const { tabLocalIdentifier, enablePersistentFiltersAcrossTabs, filterLocalIds, crossFilteringLocalIdsByTab, } = action.payload;
+    const tabs = getTabsToMutate(state, tabLocalIdentifier, enablePersistentFiltersAcrossTabs);
+    const source = tabs[0];
+    if (!source) {
         return;
     }
-    if (!targetTab.filterContext) {
-        targetTab.filterContext = { ...filterContextInitialState };
+    if (!source.filterContext) {
+        source.filterContext = { ...filterContextInitialState };
     }
-    const { filterLocalIds } = action.payload;
+    const sourceFilters = filterLocalIds.map((filterLocalId) => ({
+        filterLocalId,
+        filter: findAppliedFilterByLocalId(source, filterLocalId),
+    }));
     filterLocalIds.forEach((filterLocalId) => {
-        invariant(targetTab.filterContext?.filterContextDefinition, "Attempt to edit uninitialized filter context");
-        const currentFilterIndex = targetTab.filterContext.filterContextDefinition.filters.findIndex((item) => isDashboardAttributeFilter(item) && item.attributeFilter.localIdentifier === filterLocalId);
-        invariant(currentFilterIndex >= 0, "Attempt to clear selection of a non-existing filter");
-        const currentFilter = targetTab.filterContext.filterContextDefinition.filters[currentFilterIndex];
-        currentFilter.attributeFilter.negativeSelection =
-            currentFilter.attributeFilter.selectionMode !== "single";
-        currentFilter.attributeFilter.attributeElements = isAttributeElementsByRef(currentFilter.attributeFilter.attributeElements)
-            ? { uris: [] }
-            : { values: [] };
+        clearAttributeFilterSelectionOnTab(source, filterLocalId, true);
     });
+    for (const tab of tabs.slice(1)) {
+        for (const { filterLocalId, filter } of sourceFilters) {
+            if (!filter ||
+                !isDashboardAttributeFilter(filter) ||
+                isCrossFilteringVirtualFilter(source, filterLocalId, crossFilteringLocalIdsByTab)) {
+                continue;
+            }
+            const match = findCounterpartFilter(source, filter, tab, state.attributesWithReferences, {
+                allowListToText: false,
+                crossFilteringLocalIdsByTab,
+            });
+            if (!match || !isDashboardAttributeFilter(match) || !match.attributeFilter.localIdentifier) {
+                continue;
+            }
+            const targetLocalId = match.attributeFilter.localIdentifier;
+            if (action.payload.restoreTargetOriginal) {
+                const original = findOriginalFilter(tab, match);
+                if (!isDashboardAttributeFilter(original)) {
+                    continue;
+                }
+                updateAttributeFilterSelectionOnTab(tab, {
+                    filterLocalId: targetLocalId,
+                    elements: original.attributeFilter.attributeElements,
+                    negativeSelection: original.attributeFilter.negativeSelection,
+                }, targetLocalId, false);
+                continue;
+            }
+            clearAttributeFilterSelectionOnTab(tab, targetLocalId, false);
+        }
+    }
 };
+function clearAttributeFilterSelectionOnTab(tab, filterLocalId, isSource) {
+    const filters = tab.filterContext?.filterContextDefinition?.filters;
+    if (!isSource && !filters) {
+        return;
+    }
+    invariant(tab.filterContext?.filterContextDefinition, "Attempt to edit uninitialized filter context");
+    const currentFilterIndex = tab.filterContext.filterContextDefinition.filters.findIndex((item) => isDashboardAttributeFilter(item) && item.attributeFilter.localIdentifier === filterLocalId);
+    if (!isSource && currentFilterIndex < 0) {
+        return;
+    }
+    invariant(currentFilterIndex >= 0, "Attempt to clear selection of a non-existing filter");
+    const currentFilter = tab.filterContext.filterContextDefinition.filters[currentFilterIndex];
+    currentFilter.attributeFilter.negativeSelection =
+        currentFilter.attributeFilter.selectionMode !== "single";
+    currentFilter.attributeFilter.attributeElements = isAttributeElementsByRef(currentFilter.attributeFilter.attributeElements)
+        ? { uris: [] }
+        : { values: [] };
+}
 /**
  * Changes the display form for the filter given by its local identifier.
  */
@@ -662,7 +852,9 @@ const addDateFilter = (state, action) => {
 //
 //
 const addMeasureValueFilter = (state, action) => {
-    const activeTab = getActiveTab(state);
+    // A new measure value filter has no counterpart yet. Creating one on other tabs would be a
+    // phantom filter, so the add stays on the source tab even when sync is on.
+    const activeTab = getTabsToMutate(state)[0];
     if (!activeTab) {
         return;
     }
@@ -820,11 +1012,9 @@ export function clearFilterContextWorkingValues(tab) {
     tab.filterContext.workingFilterContextDefinition = { filters: [] };
 }
 const resetWorkingFilterSelection = (state) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
-        return;
+    for (const tab of getTabsToMutate(state)) {
+        clearFilterContextWorkingValues(tab);
     }
-    clearFilterContextWorkingValues(activeTab);
 };
 //
 //
@@ -840,21 +1030,59 @@ const setDefaultFilterOverrides = (state, action) => {
     activeTab.filterContext.defaultFilterOverrides = action.payload;
 };
 const changeMeasureValueFilterCondition = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const { localIdentifier, isWorkingSelectionChange, enablePersistentFiltersAcrossTabs } = action.payload;
+    const tabs = getTabsToMutate(state, undefined, enablePersistentFiltersAcrossTabs, isWorkingSelectionChange);
+    const source = tabs[0];
+    if (!source) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
+    const sourceFilter = findAppliedFilterByLocalId(source, localIdentifier);
+    changeMeasureValueFilterConditionOnTab(source, action.payload, localIdentifier, true);
+    if (!sourceFilter || !isDashboardMeasureValueFilter(sourceFilter)) {
+        return;
+    }
+    for (const tab of tabs.slice(1)) {
+        const match = findCounterpartFilter(source, sourceFilter, tab, state.attributesWithReferences);
+        const targetLocalId = match ? dashboardFilterLocalIdentifier(match) : undefined;
+        if (!targetLocalId || !match) {
+            continue;
+        }
+        if (action.payload.restoreTargetOriginal) {
+            const original = findOriginalFilter(tab, match);
+            if (!isDashboardMeasureValueFilter(original)) {
+                continue;
+            }
+            changeMeasureValueFilterConditionOnTab(tab, {
+                ...action.payload,
+                localIdentifier: targetLocalId,
+                conditions: original.dashboardMeasureValueFilter.conditions,
+            }, targetLocalId, false);
+            continue;
+        }
+        changeMeasureValueFilterConditionOnTab(tab, action.payload, targetLocalId, false);
     }
-    const { localIdentifier, conditions, isWorkingSelectionChange } = action.payload;
+};
+function changeMeasureValueFilterConditionOnTab(tab, payload, localIdentifier, isSource) {
+    if (!tab.filterContext) {
+        if (!isSource) {
+            return;
+        }
+        tab.filterContext = { ...filterContextInitialState };
+    }
+    const { conditions, isWorkingSelectionChange } = payload;
     const filterContextDefinition = isWorkingSelectionChange
-        ? activeTab.filterContext?.workingFilterContextDefinition
-        : activeTab.filterContext?.filterContextDefinition;
+        ? tab.filterContext?.workingFilterContextDefinition
+        : tab.filterContext?.filterContextDefinition;
+    if (!isSource && !filterContextDefinition?.filters) {
+        return;
+    }
     invariant(filterContextDefinition?.filters, "Attempt to edit uninitialized filter context");
     const filters = filterContextDefinition.filters;
     const index = filters.findIndex((item) => isDashboardMeasureValueFilter(item) && dashboardFilterLocalIdentifier(item) === localIdentifier);
     const hasConditions = !!conditions && conditions.length > 0;
+    if (!isSource && index < 0) {
+        return;
+    }
     invariant(index >= 0 || isWorkingSelectionChange, `Attempt to change condition of measure value filter ${localIdentifier} that does not exist`);
     if (isWorkingSelectionChange && index < 0) {
         const workingFilter = {
@@ -863,7 +1091,7 @@ const changeMeasureValueFilterCondition = (state, action) => {
                 conditions: hasConditions ? conditions : undefined,
             },
         };
-        activeTab.filterContext.workingFilterContextDefinition.filters.push(workingFilter);
+        tab.filterContext.workingFilterContextDefinition.filters.push(workingFilter);
         return;
     }
     const filter = filters[index];
@@ -873,28 +1101,60 @@ const changeMeasureValueFilterCondition = (state, action) => {
             conditions: hasConditions ? conditions : undefined,
         },
     };
-};
+}
 const setMeasureValueFilterDimensionality = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const { localIdentifier, restoreTargetOriginal, enablePersistentFiltersAcrossTabs } = action.payload;
+    const tabs = getTabsToMutate(state, undefined, enablePersistentFiltersAcrossTabs);
+    const source = tabs[0];
+    if (!source) {
         return;
     }
-    invariant(activeTab.filterContext?.filterContextDefinition?.filters, "Attempt to edit uninitialized filter context");
-    const filters = activeTab.filterContext.filterContextDefinition.filters;
-    const index = filters.findIndex((item) => isDashboardMeasureValueFilter(item) &&
-        dashboardFilterLocalIdentifier(item) === action.payload.localIdentifier);
-    invariant(index >= 0, `Attempt to change dimensionality of measure value filter ${action.payload.localIdentifier} that does not exist`);
+    const sourceFilter = findAppliedFilterByLocalId(source, localIdentifier);
+    setMeasureValueFilterDimensionalityOnTab(source, action.payload, localIdentifier, true);
+    if (!sourceFilter || !isDashboardMeasureValueFilter(sourceFilter)) {
+        return;
+    }
+    for (const tab of tabs.slice(1)) {
+        const match = findCounterpartFilter(source, sourceFilter, tab, state.attributesWithReferences);
+        const targetLocalId = match ? dashboardFilterLocalIdentifier(match) : undefined;
+        if (!targetLocalId || !match) {
+            continue;
+        }
+        if (restoreTargetOriginal) {
+            const original = findOriginalFilter(tab, match);
+            if (!isDashboardMeasureValueFilter(original)) {
+                continue;
+            }
+            setMeasureValueFilterDimensionalityOnTab(tab, {
+                ...action.payload,
+                localIdentifier: targetLocalId,
+                dimensionality: original.dashboardMeasureValueFilter.dimensionality,
+            }, targetLocalId, false);
+            continue;
+        }
+        setMeasureValueFilterDimensionalityOnTab(tab, action.payload, targetLocalId, false);
+    }
+};
+function setMeasureValueFilterDimensionalityOnTab(tab, payload, localIdentifier, isSource) {
+    const filters = tab.filterContext?.filterContextDefinition?.filters;
+    if (!isSource && !filters) {
+        return;
+    }
+    invariant(filters, "Attempt to edit uninitialized filter context");
+    const index = filters.findIndex((item) => isDashboardMeasureValueFilter(item) && dashboardFilterLocalIdentifier(item) === localIdentifier);
+    if (!isSource && index < 0) {
+        return;
+    }
+    invariant(index >= 0, `Attempt to change dimensionality of measure value filter ${localIdentifier} that does not exist`);
     const filter = filters[index];
-    const dimensionality = action.payload.dimensionality && action.payload.dimensionality.length > 0
-        ? action.payload.dimensionality
-        : undefined;
+    const dimensionality = payload.dimensionality && payload.dimensionality.length > 0 ? payload.dimensionality : undefined;
     filters[index] = {
         dashboardMeasureValueFilter: {
             ...filter.dashboardMeasureValueFilter,
             dimensionality,
         },
     };
-};
+}
 const changeMeasureValueFilterTitle = (state, action) => {
     const activeTab = getActiveTab(state);
     if (!activeTab) {