@gooddata/sdk-ui-dashboard 11.65.0-alpha.1 → 11.65.0-alpha.11

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

@@ -1,11 +1,36 @@
 // (C) 2021-2026 GoodData Corporation
+import { cloneDeep } from "lodash-es";
 import { invariant } from "ts-invariant";
-import { areObjRefsEqual, attributeElementsIsEmpty, dashboardAttributeFilterItemLocalIdentifier, dashboardFilterLocalIdentifier, isAllTimeDashboardDateFilter, isAttributeElementsByRef, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardMatchAttributeFilter, isDashboardMeasureValueFilter, newAllTimeDashboardDateFilter, } from "@gooddata/sdk-model";
+import { areObjRefsEqual, attributeElementsIsEmpty, dashboardAttributeFilterItemDisplayForm, dashboardAttributeFilterItemLocalIdentifier, dashboardFilterLocalIdentifier, isAttributeElementsByRef, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardDateFilterWithDimension, isDashboardMatchAttributeFilter, isDashboardMeasureValueFilter, isIdentifierRef, newAllTimeDashboardDateFilter, } from "@gooddata/sdk-model";
+import { isDisplayFormMetadataReferencedBy } from "../../../utils/attributeFilterMatching.js";
 import { generateFilterLocalIdentifier, generateMeasureValueFilterLocalIdentifier, } from "../../_infra/generators.js";
-import { getActiveTab, getTabOrActive, getTabsToMutate, } from "../tabsState.js";
-import { filterContextInitialState } from "./filterContextState.js";
+import { getActiveTab, getTabOrActive } from "../tabsState.js";
+import { filterContextInitialState, } from "./filterContextState.js";
 import { applyFilterContext, initializeFilterContext } from "./filterContextUtils.js";
-import { findCounterpartFilter, findOriginalFilter, isCrossFilteringVirtualFilter, preserveFilterDependencies, retargetAttributeFilterItem, } from "./filterSync.js";
+import { findOriginalFilter, preserveFilterDependencies } from "./filterSync.js";
+/**
+ * Filter context of the tab addressed by `tabLocalIdentifier`, or of the active tab when omitted.
+ * Initializes an empty filter context on a tab that has none.
+ */
+function getTabFilterContext(state, tabLocalIdentifier) {
+    const tab = getTabOrActive(state, tabLocalIdentifier);
+    if (!tab) {
+        return undefined;
+    }
+    if (!tab.filterContext) {
+        tab.filterContext = { ...filterContextInitialState };
+    }
+    return { tab, filterContext: tab.filterContext };
+}
+function getEditableFilterContext(state, tabLocalIdentifier) {
+    const target = getTabFilterContext(state, tabLocalIdentifier);
+    if (!target) {
+        return undefined;
+    }
+    const definition = target.filterContext.filterContextDefinition;
+    invariant(definition, "Attempt to edit uninitialized filter context");
+    return { ...target, definition };
+}
 const setFilterContext = (state, action) => {
     const activeTab = getActiveTab(state);
     if (!activeTab) {
@@ -46,42 +71,34 @@ const updateFilterContextIdentityForTab = (state, action) => {
     }
     tab.filterContext.filterContextIdentity = filterContextIdentity;
 };
-//
-//
-//
 const removeAttributeFilterDisplayForms = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const { displayForm, tabLocalIdentifier } = action.payload;
+    const target = getTabFilterContext(state, tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.attributeFilterDisplayForms, "attempting to work with uninitialized state");
-    activeTab.filterContext.attributeFilterDisplayForms =
-        activeTab.filterContext.attributeFilterDisplayForms.filter((df) => {
-            return !areObjRefsEqual(df, action.payload);
-        });
+    const { filterContext } = target;
+    invariant(filterContext.attributeFilterDisplayForms, "attempting to work with uninitialized state");
+    // A cross-filtering virtual filter shares its display form with the dashboard filter it duplicates.
+    const usedDisplayForms = (filterContext.filterContextDefinition?.filters ?? [])
+        .filter(isDashboardAttributeFilterItem)
+        .map(dashboardAttributeFilterItemDisplayForm);
+    filterContext.attributeFilterDisplayForms = filterContext.attributeFilterDisplayForms.filter((df) => !isDisplayFormMetadataReferencedBy(df, displayForm) ||
+        usedDisplayForms.some((used) => isDisplayFormMetadataReferencedBy(df, used)));
 };
 const addAttributeFilterDisplayForm = (state, action) => {
     // Handle both old and new payload formats for backward compatibility
     const displayForm = "displayForm" in action.payload ? action.payload.displayForm : action.payload;
     const tabLocalIdentifier = "tabLocalIdentifier" in action.payload ? action.payload.tabLocalIdentifier : undefined;
-    const targetTab = getTabOrActive(state, tabLocalIdentifier);
-    if (!targetTab) {
+    const target = getTabFilterContext(state, tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!targetTab.filterContext) {
-        targetTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(targetTab.filterContext.attributeFilterDisplayForms, "attempting to work with uninitialized state");
+    const { filterContext } = target;
+    invariant(filterContext.attributeFilterDisplayForms, "attempting to work with uninitialized state");
     // if there is already a display form with the same ref, replace it
-    const existing = targetTab.filterContext.attributeFilterDisplayForms.find((df) => areObjRefsEqual(df, displayForm.ref));
-    if (existing) {
-        targetTab.filterContext.attributeFilterDisplayForms =
-            targetTab.filterContext.attributeFilterDisplayForms.filter((df) => !areObjRefsEqual(df, displayForm));
-    }
-    targetTab.filterContext.attributeFilterDisplayForms.push(displayForm);
+    filterContext.attributeFilterDisplayForms = filterContext.attributeFilterDisplayForms.filter((df) => !isDisplayFormMetadataReferencedBy(df, displayForm.ref));
+    filterContext.attributeFilterDisplayForms.push(displayForm);
 };
 //
 //
@@ -92,88 +109,19 @@ const setPreloadedAttributesWithReferences = (state, action) => {
     state.attributesWithReferences = action.payload;
 };
 const upsertDateFilter = (state, action) => {
-    const { tabLocalIdentifier, enablePersistentFiltersAcrossTabs, isWorkingSelectionChange } = action.payload;
-    const tabs = getTabsToMutate(state, tabLocalIdentifier, enablePersistentFiltersAcrossTabs, isWorkingSelectionChange);
-    const source = tabs[0];
-    if (!source) {
+    const tab = getTabOrActive(state, action.payload.tabLocalIdentifier);
+    if (!tab) {
         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);
-    }
+    upsertDateFilterOnTab(tab, action.payload);
 };
-/**
- * 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) {
+function upsertDateFilterOnTab(targetTab, payload) {
     if (!targetTab.filterContext) {
-        if (!isSource) {
-            return;
-        }
         targetTab.filterContext = { ...filterContextInitialState };
     }
     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 = payload.dataSet;
     let existingFilterIndex = -1;
@@ -183,9 +131,6 @@ function upsertDateFilterOnTab(targetTab, payload, isSource) {
     else {
         existingFilterIndex = filterContextDefinition.filters.findIndex((item) => isDashboardCommonDateFilter(item));
     }
-    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) {
@@ -207,15 +152,9 @@ function upsertDateFilterOnTab(targetTab, payload, isSource) {
                 }
             }
             else {
-                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, preservedLocalIdentifier, payload.emptyValueHandling);
+                    filterContextDefinition.filters[existingFilterIndex] = newAllTimeDashboardDateFilter(undefined, payload.localIdentifier, payload.emptyValueHandling);
                 }
                 else {
                     // if allTime common DF remove the date filter altogether
@@ -236,7 +175,7 @@ function upsertDateFilterOnTab(targetTab, payload, isSource) {
             dateFilter.dateFilter.granularity = granularity;
             dateFilter.dateFilter.from = from;
             dateFilter.dateFilter.to = to;
-            if (localIdentifier && isSource) {
+            if (localIdentifier) {
                 dateFilter.dateFilter.localIdentifier = localIdentifier;
             }
             if (boundedFilter) {
@@ -253,7 +192,7 @@ function upsertDateFilterOnTab(targetTab, payload, isSource) {
             }
         }
     }
-    else if (isSource || !dateDataSet) {
+    else {
         const { type, granularity, from, to, dataSet, localIdentifier, boundedFilter, emptyValueHandling } = payload;
         filterContextDefinition.filters.unshift({
             dateFilter: {
@@ -270,69 +209,22 @@ function upsertDateFilterOnTab(targetTab, payload, isSource) {
     }
 }
 const updateAttributeFilterSelection = (state, action) => {
-    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)) {
+    const tab = getTabOrActive(state, action.payload.tabLocalIdentifier);
+    if (!tab) {
         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);
-    }
+    updateAttributeFilterSelectionOnTab(tab, action.payload);
 };
-function updateAttributeFilterSelectionOnTab(targetTab, payload, filterLocalId, isSource) {
+function updateAttributeFilterSelectionOnTab(targetTab, payload) {
     if (!targetTab.filterContext) {
-        if (!isSource) {
-            return;
-        }
         targetTab.filterContext = { ...filterContextInitialState };
     }
-    const { elements, negativeSelection, isWorkingSelectionChange, enableImmediateAttributeFilterDisplayAsLabelMigration, isResultOfMigration, isSelectionInvalid, } = payload;
+    const { filterLocalId, 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] = {
@@ -393,60 +285,23 @@ function findAppliedFilterByLocalId(tab, localIdentifier) {
     return tab.filterContext?.filterContextDefinition?.filters.find((item) => dashboardFilterLocalIdentifier(item) === localIdentifier);
 }
 const replaceAttributeFilterItem = (state, action) => {
-    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)) {
+    const tab = getTabOrActive(state, action.payload.tabLocalIdentifier);
+    if (!tab) {
         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);
-    }
+    replaceAttributeFilterItemOnTab(tab, action.payload);
 };
-function replaceAttributeFilterItemOnTab(targetTab, payload, filter, isSource) {
+function replaceAttributeFilterItemOnTab(targetTab, payload) {
     if (!targetTab.filterContext) {
-        if (!isSource) {
-            return;
-        }
         targetTab.filterContext = { ...filterContextInitialState };
     }
-    const { filterLocalId, isWorkingSelectionChange, isSelectionInvalid } = payload;
+    const { filterLocalId, filter, 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
@@ -480,17 +335,14 @@ function replaceAttributeFilterItemOnTab(targetTab, payload, filter, isSource) {
     }
 }
 const addAttributeFilter = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { displayForm, index, initialIsNegativeSelection, initialSelection, parentFilters, selectionMode, localIdentifier, title, } = action.payload;
+    const { definition } = target;
     // Filters are indexed just for attribute filters, if DateFilter is present should be always first item
-    const isDateFilterPresent = activeTab.filterContext.filterContextDefinition.filters.findIndex(isDashboardDateFilter) >= 0;
+    const isDateFilterPresent = definition.filters.findIndex(isDashboardDateFilter) >= 0;
     const hasSelection = initialSelection && !attributeElementsIsEmpty(initialSelection);
     const isNegative = selectionMode !== "single" && (initialIsNegativeSelection || !hasSelection);
     // If DateFilter is present we have to move index by 1 because index of filter is calculated just for AttributeFilers array
@@ -500,117 +352,152 @@ const addAttributeFilter = (state, action) => {
             attributeElements: initialSelection ?? { uris: [] },
             displayForm,
             negativeSelection: isNegative,
-            localIdentifier: localIdentifier ??
-                generateFilterLocalIdentifier(displayForm, Math.max(0, attributeFilterIndex)),
+            localIdentifier: resolveAttributeFilterLocalIdentifier(definition, displayForm, attributeFilterIndex, localIdentifier),
             filterElementsBy: parentFilters ? [...parentFilters] : undefined,
             ...(selectionMode === undefined ? {} : { selectionMode }),
             title,
         },
     };
     if (index === -1) {
-        activeTab.filterContext.filterContextDefinition.filters.push(filter);
+        definition.filters.push(filter);
     }
     else {
-        activeTab.filterContext.filterContextDefinition.filters.splice(attributeFilterIndex, 0, filter);
+        definition.filters.splice(attributeFilterIndex, 0, filter);
     }
 };
 const addTextAttributeFilter = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { filter, index } = action.payload;
+    const { definition } = target;
     // Filters are indexed just for attribute filters, if DateFilter is present should be always first item
-    const isDateFilterPresent = activeTab.filterContext.filterContextDefinition.filters.findIndex(isDashboardDateFilter) >= 0;
+    const isDateFilterPresent = definition.filters.findIndex(isDashboardDateFilter) >= 0;
     const attributeFilterIndex = isDateFilterPresent ? index + 1 : index;
-    const generatedLocalIdentifierIndex = Math.max(0, attributeFilterIndex);
-    const filterWithLocalIdentifier = isDashboardArbitraryAttributeFilter(filter)
-        ? {
+    const filterWithLocalIdentifier = withAttributeFilterLocalIdentifier(filter, resolveAttributeFilterLocalIdentifier(definition, dashboardAttributeFilterItemDisplayForm(filter), attributeFilterIndex, dashboardAttributeFilterItemLocalIdentifier(filter)));
+    if (!filterWithLocalIdentifier) {
+        return;
+    }
+    if (index === -1) {
+        definition.filters.push(filterWithLocalIdentifier);
+    }
+    else {
+        definition.filters.splice(attributeFilterIndex, 0, filterWithLocalIdentifier);
+    }
+};
+function withAttributeFilterLocalIdentifier(filter, localIdentifier) {
+    if (isDashboardArbitraryAttributeFilter(filter)) {
+        return {
             arbitraryAttributeFilter: {
                 ...filter.arbitraryAttributeFilter,
-                localIdentifier: filter.arbitraryAttributeFilter.localIdentifier ??
-                    generateFilterLocalIdentifier(filter.arbitraryAttributeFilter.displayForm, generatedLocalIdentifierIndex),
+                localIdentifier,
+            },
+        };
+    }
+    if (isDashboardMatchAttributeFilter(filter)) {
+        return {
+            matchAttributeFilter: {
+                ...filter.matchAttributeFilter,
+                localIdentifier,
             },
+        };
+    }
+    return undefined;
+}
+/**
+ * Keeps `preferred` unless another filter on the tab already uses it, otherwise generates
+ * the first free identifier. A filter mirrored from another tab can collide with a local one.
+ */
+function resolveAttributeFilterLocalIdentifier(definition, displayForm, index, preferred) {
+    return resolveFilterLocalIdentifier(definition, (candidateIndex) => generateFilterLocalIdentifier(displayForm, candidateIndex), index, preferred);
+}
+function resolveFilterLocalIdentifier(definition, generate, index, preferred) {
+    const used = new Set();
+    for (const item of definition.filters) {
+        const localIdentifier = dashboardFilterLocalIdentifier(item);
+        if (localIdentifier) {
+            used.add(localIdentifier);
         }
-        : isDashboardMatchAttributeFilter(filter)
-            ? {
-                matchAttributeFilter: {
-                    ...filter.matchAttributeFilter,
-                    localIdentifier: filter.matchAttributeFilter.localIdentifier ??
-                        generateFilterLocalIdentifier(filter.matchAttributeFilter.displayForm, generatedLocalIdentifierIndex),
-                },
-            }
-            : filter;
-    if (index === -1) {
-        activeTab.filterContext.filterContextDefinition.filters.push(filterWithLocalIdentifier);
     }
-    else {
-        activeTab.filterContext.filterContextDefinition.filters.splice(attributeFilterIndex, 0, filterWithLocalIdentifier);
+    if (preferred && !used.has(preferred)) {
+        return preferred;
     }
-};
+    let candidateIndex = Math.max(0, index);
+    let localIdentifier = generate(candidateIndex);
+    while (used.has(localIdentifier)) {
+        candidateIndex += 1;
+        localIdentifier = generate(candidateIndex);
+    }
+    return localIdentifier;
+}
 const removeAttributeFilter = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { filterLocalId } = action.payload;
-    const newFilters = activeTab.filterContext.filterContextDefinition.filters.filter((item) => isDashboardDateFilter(item) ||
-        !isDashboardAttributeFilterItem(item) ||
-        dashboardAttributeFilterItemLocalIdentifier(item) !== filterLocalId);
-    activeTab.filterContext.filterContextDefinition = {
-        ...activeTab.filterContext.filterContextDefinition,
-        filters: newFilters,
+    const { filterContext, definition } = target;
+    filterContext.filterContextDefinition = {
+        ...definition,
+        filters: definition.filters.filter((item) => isDashboardDateFilter(item) ||
+            !isDashboardAttributeFilterItem(item) ||
+            dashboardAttributeFilterItemLocalIdentifier(item) !== filterLocalId),
     };
+    removeAttributeFilterParentReferences(filterContext.filterContextDefinition, filterLocalId);
 };
+/**
+ * Drops parent references to a removed filter, including children that exist only on this tab.
+ */
+function removeAttributeFilterParentReferences(definition, removedLocalId) {
+    for (const item of definition.filters) {
+        if (isDashboardAttributeFilter(item) && item.attributeFilter.filterElementsBy) {
+            const remaining = item.attributeFilter.filterElementsBy.filter((parent) => parent.filterLocalIdentifier !== removedLocalId);
+            if (remaining.length !== item.attributeFilter.filterElementsBy.length) {
+                item.attributeFilter.filterElementsBy = remaining;
+            }
+        }
+        else if (isDashboardArbitraryAttributeFilter(item) &&
+            item.arbitraryAttributeFilter.filterElementsBy) {
+            const remaining = item.arbitraryAttributeFilter.filterElementsBy.filter((parent) => parent.filterLocalIdentifier !== removedLocalId);
+            if (remaining.length !== item.arbitraryAttributeFilter.filterElementsBy.length) {
+                item.arbitraryAttributeFilter.filterElementsBy = remaining;
+            }
+        }
+    }
+}
 const moveAttributeFilter = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { filterLocalId, index } = action.payload;
-    const currentFilterIndex = activeTab.filterContext.filterContextDefinition.filters.findIndex((item) => isDashboardAttributeFilterItem(item) &&
+    const filters = target.definition.filters;
+    const currentFilterIndex = filters.findIndex((item) => isDashboardAttributeFilterItem(item) &&
         dashboardAttributeFilterItemLocalIdentifier(item) === filterLocalId);
     invariant(currentFilterIndex >= 0, "Attempt to move non-existing filter");
-    const filter = activeTab.filterContext.filterContextDefinition.filters[currentFilterIndex];
-    activeTab.filterContext.filterContextDefinition.filters.splice(currentFilterIndex, 1);
+    const filter = filters[currentFilterIndex];
+    filters.splice(currentFilterIndex, 1);
     // Filters are indexed just for attribute filters, if DateFilter is present should be always first item
-    const isDateFilterPresent = activeTab.filterContext.filterContextDefinition.filters.findIndex(isDashboardDateFilter) >= 0;
+    const isDateFilterPresent = filters.findIndex(isDashboardDateFilter) >= 0;
     if (index === -1) {
-        activeTab.filterContext.filterContextDefinition.filters.push(filter);
+        filters.push(filter);
     }
     else {
         // If DateFilter is present we have to move index by 1 because index of filter is calculated just for AttributeFilers array
         const attributeFilterIndex = isDateFilterPresent ? index + 1 : index;
-        activeTab.filterContext.filterContextDefinition.filters.splice(attributeFilterIndex, 0, filter);
+        filters.splice(attributeFilterIndex, 0, filter);
     }
 };
 const setAttributeFilterParents = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { filterLocalId, parentFilters } = action.payload;
-    const currentFilterIndex = activeTab.filterContext.filterContextDefinition.filters.findIndex((item) => isDashboardAttributeFilterItem(item) &&
-        dashboardAttributeFilterItemLocalIdentifier(item) === filterLocalId);
-    invariant(currentFilterIndex >= 0, "Attempt to set parent of a non-existing filter");
+    const filter = findAttributeFilterItem(target.definition, filterLocalId);
+    invariant(filter, "Attempt to set parent of a non-existing filter");
     // silently ignore when targeting match filter, will have no effect
-    const filter = activeTab.filterContext.filterContextDefinition.filters[currentFilterIndex];
     if (isDashboardAttributeFilter(filter)) {
         filter.attributeFilter.filterElementsBy = [...parentFilters];
     }
@@ -619,19 +506,13 @@ const setAttributeFilterParents = (state, action) => {
     }
 };
 const setAttributeFilterDependentDateFilters = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { filterLocalId, dependentDateFilters } = action.payload;
-    const currentFilterIndex = activeTab.filterContext.filterContextDefinition.filters.findIndex((item) => isDashboardAttributeFilterItem(item) &&
-        dashboardAttributeFilterItemLocalIdentifier(item) === filterLocalId);
-    invariant(currentFilterIndex >= 0, "Attempt to set dependent date filter of a non-existing filter");
-    const filter = activeTab.filterContext.filterContextDefinition.filters[currentFilterIndex];
+    const filter = findAttributeFilterItem(target.definition, filterLocalId);
+    invariant(filter, "Attempt to set dependent date filter of a non-existing filter");
     if (isDashboardAttributeFilter(filter)) {
         filter.attributeFilter.filterElementsByDate = [...dependentDateFilters];
     }
@@ -640,64 +521,43 @@ const setAttributeFilterDependentDateFilters = (state, action) => {
     }
     // Match filters do not support filterElementsByDate
 };
+function findAttributeFilterItem(definition, localIdentifier) {
+    return definition.filters.find((item) => isDashboardAttributeFilterItem(item) &&
+        dashboardAttributeFilterItemLocalIdentifier(item) === localIdentifier);
+}
 const clearAttributeFiltersSelection = (state, action) => {
-    const { tabLocalIdentifier, enablePersistentFiltersAcrossTabs, filterLocalIds, crossFilteringLocalIdsByTab, } = action.payload;
-    const tabs = getTabsToMutate(state, tabLocalIdentifier, enablePersistentFiltersAcrossTabs);
-    const source = tabs[0];
-    if (!source) {
+    const { tabLocalIdentifier, filterLocalIds, restoreOriginal } = action.payload;
+    const tab = getTabOrActive(state, tabLocalIdentifier);
+    if (!tab) {
         return;
     }
-    if (!source.filterContext) {
-        source.filterContext = { ...filterContextInitialState };
+    if (!tab.filterContext) {
+        tab.filterContext = { ...filterContextInitialState };
     }
-    const sourceFilters = filterLocalIds.map((filterLocalId) => ({
-        filterLocalId,
-        filter: findAppliedFilterByLocalId(source, filterLocalId),
-    }));
-    filterLocalIds.forEach((filterLocalId) => {
-        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);
+    for (const filterLocalId of filterLocalIds) {
+        if (restoreOriginal) {
+            restoreAttributeFilterSelectionOnTab(tab, filterLocalId);
+        }
+        else {
+            clearAttributeFilterSelectionOnTab(tab, filterLocalId);
         }
     }
 };
-function clearAttributeFilterSelectionOnTab(tab, filterLocalId, isSource) {
-    const filters = tab.filterContext?.filterContextDefinition?.filters;
-    if (!isSource && !filters) {
+function restoreAttributeFilterSelectionOnTab(tab, filterLocalId) {
+    const filter = findAppliedFilterByLocalId(tab, filterLocalId);
+    const original = filter ? findOriginalFilter(tab, filter) : undefined;
+    if (!isDashboardAttributeFilter(original)) {
         return;
     }
+    updateAttributeFilterSelectionOnTab(tab, {
+        filterLocalId,
+        elements: original.attributeFilter.attributeElements,
+        negativeSelection: original.attributeFilter.negativeSelection,
+    });
+}
+function clearAttributeFilterSelectionOnTab(tab, filterLocalId) {
     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 =
@@ -710,17 +570,15 @@ function clearAttributeFilterSelectionOnTab(tab, filterLocalId, isSource) {
  * Changes the display form for the filter given by its local identifier.
  */
 const changeAttributeDisplayForm = (state, action) => {
-    const targetTab = getTabOrActive(state, action.payload.tabLocalIdentifier);
-    if (!targetTab) {
+    const target = getTabFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!targetTab.filterContext) {
-        targetTab.filterContext = { ...filterContextInitialState };
-    }
     const { filterLocalId, displayForm, isWorkingSelectionChange, enableImmediateAttributeFilterDisplayAsLabelMigration, isResultOfMigration, } = action.payload;
+    const { filterContext } = target;
     const filterContextDefinition = isWorkingSelectionChange
-        ? targetTab.filterContext.workingFilterContextDefinition
-        : targetTab.filterContext.filterContextDefinition;
+        ? filterContext.workingFilterContextDefinition
+        : filterContext.filterContextDefinition;
     invariant(filterContextDefinition?.filters, "Attempt to edit uninitialized filter context");
     const currentFilterIndex = filterContextDefinition.filters.findIndex((item) => isDashboardAttributeFilter(item) && item.attributeFilter.localIdentifier === filterLocalId);
     invariant(currentFilterIndex >= 0 || isWorkingSelectionChange, "Attempt to set parent of a non-existing filter");
@@ -738,7 +596,7 @@ const changeAttributeDisplayForm = (state, action) => {
     currentFilter.attributeFilter.displayForm = { ...displayForm };
     // update original filters to not show "reset filters" button, that will revert filter to wrong state
     if (enableImmediateAttributeFilterDisplayAsLabelMigration && isResultOfMigration) {
-        const originalFilter = targetTab.filterContext.originalFilterContextDefinition?.filters.find((item) => isDashboardAttributeFilter(item) && item.attributeFilter.localIdentifier === filterLocalId);
+        const originalFilter = filterContext.originalFilterContextDefinition?.filters.find((item) => isDashboardAttributeFilter(item) && item.attributeFilter.localIdentifier === filterLocalId);
         if (isDashboardAttributeFilter(originalFilter)) {
             originalFilter.attributeFilter.displayForm = { ...displayForm };
         }
@@ -751,21 +609,12 @@ const changeAttributeDisplayForm = (state, action) => {
  */
 const changeTextFilterDisplayForm = (state, action) => {
     const targetTab = getTabOrActive(state, action.payload.tabLocalIdentifier);
-    if (!targetTab?.filterContext) {
-        return;
-    }
-    const { filterLocalId, displayForm } = action.payload;
-    const filterContextDefinition = targetTab.filterContext.filterContextDefinition;
+    const filterContextDefinition = targetTab?.filterContext?.filterContextDefinition;
     if (!filterContextDefinition?.filters) {
         return;
     }
-    const currentFilterIndex = filterContextDefinition.filters.findIndex((item) => isDashboardAttributeFilterItem(item) &&
-        !isDashboardAttributeFilter(item) &&
-        dashboardAttributeFilterItemLocalIdentifier(item) === filterLocalId);
-    if (currentFilterIndex < 0) {
-        return;
-    }
-    const filter = filterContextDefinition.filters[currentFilterIndex];
+    const { filterLocalId, displayForm } = action.payload;
+    const filter = findAttributeFilterItem(filterContextDefinition, filterLocalId);
     if (isDashboardArbitraryAttributeFilter(filter)) {
         filter.arbitraryAttributeFilter.displayForm = { ...displayForm };
     }
@@ -777,17 +626,12 @@ const changeTextFilterDisplayForm = (state, action) => {
  * Changes the title for the filter given by its local identifier.
  */
 const changeAttributeTitle = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { filterLocalId, title } = action.payload;
-    const findFilter = activeTab.filterContext.filterContextDefinition.filters.find((item) => isDashboardAttributeFilterItem(item) &&
-        dashboardAttributeFilterItemLocalIdentifier(item) === filterLocalId);
+    const findFilter = findAttributeFilterItem(target.definition, filterLocalId);
     invariant(findFilter, "Attempt to change title of a non-existing filter");
     if (isDashboardAttributeFilter(findFilter)) {
         findFilter.attributeFilter.title = title;
@@ -803,17 +647,12 @@ const changeAttributeTitle = (state, action) => {
  * Changes the selection mode for the filter given by its local identifier.
  */
 const changeSelectionMode = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { filterLocalId, selectionMode } = action.payload;
-    const findFilter = activeTab.filterContext.filterContextDefinition.filters.find((item) => isDashboardAttributeFilterItem(item) &&
-        dashboardAttributeFilterItemLocalIdentifier(item) === filterLocalId);
+    const findFilter = findAttributeFilterItem(target.definition, filterLocalId);
     invariant(findFilter, "Attempt to change selection mode of a non-existing filter");
     // Text filters (arbitrary, match) do not have selectionMode; no-op for them
     if (isDashboardAttributeFilter(findFilter)) {
@@ -821,15 +660,12 @@ const changeSelectionMode = (state, action) => {
     }
 };
 const addDateFilter = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { index, dateDataset } = action.payload;
+    const { definition } = target;
     const filter = {
         dateFilter: {
             dataSet: dateDataset,
@@ -838,73 +674,58 @@ const addDateFilter = (state, action) => {
         },
     };
     // Only draggable filters are indexed, if DateFilter is present should be always first item
-    const isCommonDateFilterPresent = activeTab.filterContext.filterContextDefinition.filters.findIndex(isDashboardCommonDateFilter) >= 0;
+    const isCommonDateFilterPresent = definition.filters.findIndex(isDashboardCommonDateFilter) >= 0;
     if (index === -1) {
-        activeTab.filterContext.filterContextDefinition.filters.push(filter);
+        definition.filters.push(filter);
     }
     else {
         // If CommonDateFilter is present we have to move index by 1 because index of filter is calculated just for AttributeFilers array
         const newFilterIndex = isCommonDateFilterPresent ? index + 1 : index;
-        activeTab.filterContext.filterContextDefinition.filters.splice(newFilterIndex, 0, filter);
+        definition.filters.splice(newFilterIndex, 0, filter);
     }
 };
-//
-//
-//
 const addMeasureValueFilter = (state, action) => {
-    // 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) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { index, measure, localIdentifier, title } = action.payload;
+    const { definition } = target;
     const filter = {
         dashboardMeasureValueFilter: {
             measure,
-            localIdentifier: localIdentifier ?? generateMeasureValueFilterLocalIdentifier(measure, Math.max(0, index)),
+            localIdentifier: resolveFilterLocalIdentifier(definition, (candidateIndex) => generateMeasureValueFilterLocalIdentifier(measure, candidateIndex), index, localIdentifier),
             title,
         },
     };
-    const isCommonDateFilterPresent = activeTab.filterContext.filterContextDefinition.filters.findIndex(isDashboardCommonDateFilter) >= 0;
+    const isCommonDateFilterPresent = definition.filters.findIndex(isDashboardCommonDateFilter) >= 0;
     if (index === -1) {
-        activeTab.filterContext.filterContextDefinition.filters.push(filter);
+        definition.filters.push(filter);
     }
     else {
         const newFilterIndex = isCommonDateFilterPresent ? index + 1 : index;
-        activeTab.filterContext.filterContextDefinition.filters.splice(newFilterIndex, 0, filter);
+        definition.filters.splice(newFilterIndex, 0, filter);
     }
 };
 const removeMeasureValueFilter = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
-    activeTab.filterContext.filterContextDefinition = {
-        ...activeTab.filterContext.filterContextDefinition,
-        filters: activeTab.filterContext.filterContextDefinition.filters.filter((item) => !(isDashboardMeasureValueFilter(item) &&
-            dashboardFilterLocalIdentifier(item) === action.payload.localIdentifier)),
+    const { localIdentifier } = action.payload;
+    target.filterContext.filterContextDefinition = {
+        ...target.definition,
+        filters: target.definition.filters.filter((item) => !(isDashboardMeasureValueFilter(item) &&
+            dashboardFilterLocalIdentifier(item) === localIdentifier)),
     };
 };
 const moveMeasureValueFilter = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { localIdentifier, index } = action.payload;
-    const filters = activeTab.filterContext.filterContextDefinition.filters;
+    const filters = target.definition.filters;
     const currentFilterIndex = filters.findIndex((item) => isDashboardMeasureValueFilter(item) && dashboardFilterLocalIdentifier(item) === localIdentifier);
     invariant(currentFilterIndex >= 0, "Attempt to move non-existing measure value filter");
     const filter = filters[currentFilterIndex];
@@ -919,61 +740,91 @@ const moveMeasureValueFilter = (state, action) => {
     }
 };
 const removeDateFilter = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { dataSet } = action.payload;
-    const newFilters = activeTab.filterContext.filterContextDefinition.filters.filter((item) => !isDashboardDateFilter(item) || !areObjRefsEqual(item.dateFilter.dataSet, dataSet));
-    activeTab.filterContext.filterContextDefinition = {
-        ...activeTab.filterContext.filterContextDefinition,
-        filters: newFilters,
+    const { filterContext, definition } = target;
+    const removed = definition.filters.find((item) => isDashboardDateFilterWithDimension(item) && areObjRefsEqual(item.dateFilter.dataSet, dataSet));
+    const removedLocalIdentifier = isDashboardDateFilter(removed)
+        ? removed.dateFilter.localIdentifier
+        : undefined;
+    filterContext.filterContextDefinition = {
+        ...definition,
+        filters: definition.filters.filter((item) => !isDashboardDateFilter(item) || !areObjRefsEqual(item.dateFilter.dataSet, dataSet)),
     };
+    removeDimensionDateFilterDependencies(filterContext.filterContextDefinition, dataSet, removedLocalIdentifier);
 };
+/**
+ * Drops attribute-filter dependencies that point at the removed dimension date filter, including
+ * filters that exist only on this tab. Matches both the filter local identifier and the legacy
+ * dataset-identifier form.
+ */
+function removeDimensionDateFilterDependencies(definition, dataSet, removedLocalIdentifier) {
+    const datasetIdentifier = isIdentifierRef(dataSet) ? dataSet.identifier : undefined;
+    for (const item of definition.filters) {
+        if (isDashboardAttributeFilter(item)) {
+            const next = withoutRemovedDateDependency(item.attributeFilter.filterElementsByDate, removedLocalIdentifier, datasetIdentifier);
+            if (next !== item.attributeFilter.filterElementsByDate) {
+                item.attributeFilter.filterElementsByDate = next;
+            }
+        }
+        else if (isDashboardArbitraryAttributeFilter(item)) {
+            const next = withoutRemovedDateDependency(item.arbitraryAttributeFilter.filterElementsByDate, removedLocalIdentifier, datasetIdentifier);
+            if (next !== item.arbitraryAttributeFilter.filterElementsByDate) {
+                item.arbitraryAttributeFilter.filterElementsByDate = next;
+            }
+        }
+    }
+}
+function withoutRemovedDateDependency(dependencies, removedLocalIdentifier, datasetIdentifier) {
+    if (!dependencies?.length) {
+        return dependencies;
+    }
+    const remaining = dependencies.filter((dependency) => {
+        if (dependency.isCommonDate) {
+            return true;
+        }
+        const matchesLocalIdentifier = removedLocalIdentifier !== undefined &&
+            dependency.filterLocalIdentifier === removedLocalIdentifier;
+        const matchesDatasetIdentifier = datasetIdentifier !== undefined && dependency.filterLocalIdentifier === datasetIdentifier;
+        return !matchesLocalIdentifier && !matchesDatasetIdentifier;
+    });
+    return remaining.length === dependencies.length ? dependencies : remaining;
+}
 const moveDateFilter = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { dataSet, index } = action.payload;
-    const currentFilterIndex = activeTab.filterContext.filterContextDefinition.filters.findIndex((item) => isDashboardDateFilter(item) && areObjRefsEqual(item.dateFilter.dataSet, dataSet));
+    const filters = target.definition.filters;
+    const currentFilterIndex = filters.findIndex((item) => isDashboardDateFilter(item) && areObjRefsEqual(item.dateFilter.dataSet, dataSet));
     invariant(currentFilterIndex >= 0, "Attempt to move non-existing filter");
-    const filter = activeTab.filterContext.filterContextDefinition.filters[currentFilterIndex];
-    activeTab.filterContext.filterContextDefinition.filters.splice(currentFilterIndex, 1);
+    const filter = filters[currentFilterIndex];
+    filters.splice(currentFilterIndex, 1);
     // Filters are indexed just for attribute filters, if DateFilter is present should be always first item
-    const isCommonDateFilterPresent = activeTab.filterContext.filterContextDefinition.filters.findIndex(isDashboardCommonDateFilter) >= 0;
+    const isCommonDateFilterPresent = filters.findIndex(isDashboardCommonDateFilter) >= 0;
     if (index === -1) {
-        activeTab.filterContext.filterContextDefinition.filters.push(filter);
+        filters.push(filter);
     }
     else {
         // If DateFilter is present we have to move index by 1 because index of filter is calculated just for DraggableFilters array
         const dateFilterIndex = isCommonDateFilterPresent ? index + 1 : index;
-        activeTab.filterContext.filterContextDefinition.filters.splice(dateFilterIndex, 0, filter);
+        filters.splice(dateFilterIndex, 0, filter);
     }
 };
 /**
  * Changes the element limiting items for the filter given by its local identifier.
  */
 const changeLimitingItems = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const target = getEditableFilterContext(state, action.payload.tabLocalIdentifier);
+    if (!target) {
         return;
     }
-    if (!activeTab.filterContext) {
-        activeTab.filterContext = { ...filterContextInitialState };
-    }
-    invariant(activeTab.filterContext.filterContextDefinition, "Attempt to edit uninitialized filter context");
     const { filterLocalId, limitingItems } = action.payload;
-    const findFilter = activeTab.filterContext.filterContextDefinition.filters.find((item) => isDashboardAttributeFilterItem(item) &&
-        dashboardAttributeFilterItemLocalIdentifier(item) === filterLocalId);
+    const findFilter = findAttributeFilterItem(target.definition, filterLocalId);
     invariant(findFilter, "Attempt to change limiting items of a non-existing filter");
     if (isDashboardAttributeFilter(findFilter)) {
         findFilter.attributeFilter.validateElementsBy = limitingItems;
@@ -1012,8 +863,9 @@ export function clearFilterContextWorkingValues(tab) {
     tab.filterContext.workingFilterContextDefinition = { filters: [] };
 }
 const resetWorkingFilterSelection = (state) => {
-    for (const tab of getTabsToMutate(state)) {
-        clearFilterContextWorkingValues(tab);
+    const activeTab = getActiveTab(state);
+    if (activeTab) {
+        clearFilterContextWorkingValues(activeTab);
     }
 };
 //
@@ -1030,59 +882,24 @@ const setDefaultFilterOverrides = (state, action) => {
     activeTab.filterContext.defaultFilterOverrides = action.payload;
 };
 const changeMeasureValueFilterCondition = (state, action) => {
-    const { localIdentifier, isWorkingSelectionChange, enablePersistentFiltersAcrossTabs } = action.payload;
-    const tabs = getTabsToMutate(state, undefined, enablePersistentFiltersAcrossTabs, isWorkingSelectionChange);
-    const source = tabs[0];
-    if (!source) {
-        return;
-    }
-    const sourceFilter = findAppliedFilterByLocalId(source, localIdentifier);
-    changeMeasureValueFilterConditionOnTab(source, action.payload, localIdentifier, true);
-    if (!sourceFilter || !isDashboardMeasureValueFilter(sourceFilter)) {
+    const tab = getTabOrActive(state, action.payload.tabLocalIdentifier);
+    if (!tab) {
         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);
-    }
+    changeMeasureValueFilterConditionOnTab(tab, action.payload);
 };
-function changeMeasureValueFilterConditionOnTab(tab, payload, localIdentifier, isSource) {
+function changeMeasureValueFilterConditionOnTab(tab, payload) {
     if (!tab.filterContext) {
-        if (!isSource) {
-            return;
-        }
         tab.filterContext = { ...filterContextInitialState };
     }
-    const { conditions, isWorkingSelectionChange } = payload;
+    const { localIdentifier, conditions, isWorkingSelectionChange } = payload;
     const filterContextDefinition = isWorkingSelectionChange
         ? 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 = {
@@ -1103,48 +920,17 @@ function changeMeasureValueFilterConditionOnTab(tab, payload, localIdentifier, i
     };
 }
 const setMeasureValueFilterDimensionality = (state, action) => {
-    const { localIdentifier, restoreTargetOriginal, enablePersistentFiltersAcrossTabs } = action.payload;
-    const tabs = getTabsToMutate(state, undefined, enablePersistentFiltersAcrossTabs);
-    const source = tabs[0];
-    if (!source) {
-        return;
-    }
-    const sourceFilter = findAppliedFilterByLocalId(source, localIdentifier);
-    setMeasureValueFilterDimensionalityOnTab(source, action.payload, localIdentifier, true);
-    if (!sourceFilter || !isDashboardMeasureValueFilter(sourceFilter)) {
+    const tab = getTabOrActive(state, action.payload.tabLocalIdentifier);
+    if (!tab) {
         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);
-    }
+    setMeasureValueFilterDimensionalityOnTab(tab, action.payload);
 };
-function setMeasureValueFilterDimensionalityOnTab(tab, payload, localIdentifier, isSource) {
+function setMeasureValueFilterDimensionalityOnTab(tab, payload) {
+    const { localIdentifier } = payload;
     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 = payload.dimensionality && payload.dimensionality.length > 0 ? payload.dimensionality : undefined;
@@ -1156,23 +942,96 @@ function setMeasureValueFilterDimensionalityOnTab(tab, payload, localIdentifier,
     };
 }
 const changeMeasureValueFilterTitle = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
+    const { filterLocalId, title, tabLocalIdentifier } = action.payload;
+    const targetTab = getTabOrActive(state, tabLocalIdentifier);
+    if (!targetTab) {
         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.filterLocalId);
-    invariant(index >= 0, `Attempt to change title of measure value filter ${action.payload.filterLocalId} that does not exist`);
+    const filters = targetTab.filterContext?.filterContextDefinition?.filters;
+    invariant(filters, "Attempt to edit uninitialized filter context");
+    const index = filters.findIndex((item) => isDashboardMeasureValueFilter(item) && dashboardFilterLocalIdentifier(item) === filterLocalId);
+    invariant(index >= 0, `Attempt to change title of measure value filter ${filterLocalId} that does not exist`);
     const filter = filters[index];
     filters[index] = {
         dashboardMeasureValueFilter: {
             ...filter.dashboardMeasureValueFilter,
-            title: action.payload.title,
+            title,
         },
     };
 };
+function isWrittenFilter(filter, written) {
+    if (isDashboardDateFilter(filter)) {
+        const { dataSet } = filter.dateFilter;
+        return dataSet
+            ? written.dateDataSets.some((writtenDataSet) => areObjRefsEqual(writtenDataSet, dataSet))
+            : written.commonDateFilter;
+    }
+    const localIdentifier = dashboardFilterLocalIdentifier(filter);
+    return !!localIdentifier && written.filterLocalIds.includes(localIdentifier);
+}
+/**
+ * Makes the applied values of the written filters their initial values. A default filter view that
+ * initializes the shared state is that initial state, so the reset button stays hidden until the user
+ * changes it. Filters the view did not write keep their initial values, so a change the user made
+ * before stays resettable.
+ */
+const adoptAppliedFiltersAsOriginal = (state, action) => {
+    for (const written of action.payload) {
+        const tab = getTabOrActive(state, written.tabLocalIdentifier);
+        const definition = tab?.filterContext?.filterContextDefinition;
+        if (!tab?.filterContext || !definition) {
+            continue;
+        }
+        const originals = tab.filterContext.originalFilterContextDefinition?.filters ?? [];
+        const originalOf = new Map();
+        const matchedOriginals = new Set();
+        const match = (filter, original) => {
+            if (original && !matchedOriginals.has(original)) {
+                originalOf.set(filter, original);
+                matchedOriginals.add(original);
+            }
+        };
+        // Each initial value belongs to one applied filter. Exact localIdentifier matches go first, so a
+        // filter without an initial value, e.g. a cross-filtering one, cannot take the initial value of
+        // another filter with the same display form through identity matching.
+        for (const filter of definition.filters) {
+            const localIdentifier = dashboardFilterLocalIdentifier(filter);
+            match(filter, localIdentifier
+                ? originals.find((original) => dashboardFilterLocalIdentifier(original) === localIdentifier)
+                : undefined);
+        }
+        for (const filter of definition.filters) {
+            if (!originalOf.has(filter)) {
+                match(filter, findOriginalFilter(tab, filter));
+            }
+        }
+        // the reset button compares the lists in order, so the applied order is kept; an unwritten filter
+        // without an initial value, e.g. a cross-filtering one, stays out of the initial values
+        const adopted = definition.filters.flatMap((filter) => {
+            if (isWrittenFilter(filter, written)) {
+                return [cloneDeep(filter)];
+            }
+            const original = originalOf.get(filter);
+            return original ? [cloneDeep(original)] : [];
+        });
+        // an unwritten initial value without an applied filter, e.g. a common date filter set to all time
+        for (const original of originals) {
+            if (matchedOriginals.has(original) || isWrittenFilter(original, written)) {
+                continue;
+            }
+            if (isDashboardCommonDateFilter(original)) {
+                adopted.unshift(cloneDeep(original));
+            }
+            else {
+                adopted.push(cloneDeep(original));
+            }
+        }
+        tab.filterContext.originalFilterContextDefinition = {
+            ...(tab.filterContext.originalFilterContextDefinition ?? definition),
+            filters: adopted,
+        };
+    }
+};
 //
 //
 //
@@ -1209,4 +1068,5 @@ export const filterContextReducers = {
     changeMeasureValueFilterCondition,
     setMeasureValueFilterDimensionality,
     changeMeasureValueFilterTitle,
+    adoptAppliedFiltersAsOriginal,
 };