@gooddata/sdk-ui-dashboard 11.62.0-alpha.1 → 11.62.0-alpha.3

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

@@ -0,0 +1,361 @@
+// (C) 2026 GoodData Corporation
+import { areObjRefsEqual, dashboardAttributeFilterItemFilterElementsBy, dashboardAttributeFilterItemFilterElementsByDate, dashboardAttributeFilterItemLocalIdentifier, dashboardAttributeFilterItemValidateElementsBy, dashboardFilterLocalIdentifier, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardMatchAttributeFilter, isDashboardMeasureValueFilter, } from "@gooddata/sdk-model";
+import { findAttributeFilterCounterpart } from "../../../utils/attributeFilterMatching.js";
+/**
+ * True when `localIdentifier` belongs to a cross-filtering virtual filter on `tab`.
+ * Those filters are applied on their own tab only and are not mirrored to or from other tabs.
+ *
+ * @internal
+ */
+export function isCrossFilteringVirtualFilter(tab, localIdentifier, crossFilteringLocalIdsByTab) {
+    if (!localIdentifier) {
+        return false;
+    }
+    return crossFilteringLocalIdsByTab?.[tab.localIdentifier]?.includes(localIdentifier) ?? false;
+}
+/**
+ * Finds the filter on `targetTab` that is the same logical filter as `sourceFilter`.
+ * Same-type matches take precedence over list/text migrations. A missing or incompatible
+ * counterpart is a no-op for the caller.
+ *
+ * Assumes at most one filter per display form, date data set, and measure with a given
+ * dimensionality on a tab.
+ *
+ * @internal
+ */
+export function findCounterpartFilter(sourceTab, sourceFilter, targetTab, attributesWithReferences, options) {
+    const targets = appliedFilters(targetTab).filter((filter) => !isCrossFilteringVirtualFilter(targetTab, dashboardFilterLocalIdentifier(filter), options?.crossFilteringLocalIdsByTab));
+    if (targets.length === 0) {
+        return undefined;
+    }
+    const displayForms = collectDisplayForms(sourceTab, targetTab, attributesWithReferences);
+    if (isDashboardAttributeFilterItem(sourceFilter)) {
+        const result = findAttributeFilterCounterpart(sourceFilter, targets.filter(isDashboardAttributeFilterItem), {
+            sourceFilterConfigs: sourceTab.attributeFilterConfigs?.attributeFilterConfigs,
+            targetFilterConfigs: targetTab.attributeFilterConfigs?.attributeFilterConfigs,
+            displayForms,
+            attributesWithReferences,
+            allowListToText: options?.allowListToText ?? true,
+        });
+        return result.status === "matched" ? result.counterpart : undefined;
+    }
+    if (isDashboardDateFilter(sourceFilter)) {
+        return findDateCounterpart(sourceFilter, targets);
+    }
+    if (isDashboardMeasureValueFilter(sourceFilter)) {
+        return findMeasureValueCounterpart(sourceFilter, targets);
+    }
+    return undefined;
+}
+/**
+ * The saved initial filter on `tab` that corresponds to `appliedFilter`.
+ * Same-tab `localIdentifier` wins; identity matching is the fallback.
+ * Returns undefined when this tab has no saved counterpart.
+ *
+ * @internal
+ */
+export function findOriginalFilter(tab, appliedFilter) {
+    const originals = tab.filterContext?.originalFilterContextDefinition?.filters;
+    if (!originals?.length) {
+        return undefined;
+    }
+    const localIdentifier = dashboardFilterLocalIdentifier(appliedFilter);
+    if (localIdentifier) {
+        const byLocalId = originals.find((filter) => dashboardFilterLocalIdentifier(filter) === localIdentifier);
+        if (byLocalId) {
+            return byLocalId;
+        }
+    }
+    if (!tab.filterContext?.originalFilterContextDefinition) {
+        return undefined;
+    }
+    const originalTab = {
+        ...tab,
+        filterContext: {
+            ...tab.filterContext,
+            filterContextDefinition: tab.filterContext.originalFilterContextDefinition,
+        },
+    };
+    return findCounterpartFilter(tab, appliedFilter, originalTab);
+}
+/**
+ * Rewrites an attribute filter item so it keeps `localIdentifier` (the target tab's id).
+ *
+ * @internal
+ */
+export function retargetAttributeFilterItem(filter, localIdentifier) {
+    if (isDashboardAttributeFilter(filter)) {
+        return { attributeFilter: { ...filter.attributeFilter, localIdentifier } };
+    }
+    if (isDashboardArbitraryAttributeFilter(filter)) {
+        return { arbitraryAttributeFilter: { ...filter.arbitraryAttributeFilter, localIdentifier } };
+    }
+    if (isDashboardMatchAttributeFilter(filter)) {
+        return { matchAttributeFilter: { ...filter.matchAttributeFilter, localIdentifier } };
+    }
+    return filter;
+}
+/**
+ * Carries over parent-filter dependencies from the filter being replaced.
+ *
+ * @internal
+ */
+export 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 } };
+    }
+    return replacement;
+}
+/**
+ * Copies an applied source filter onto an existing target filter, keeping the target's
+ * local identifier, parent dependencies, and measure-value dimensionality. Does not create a filter.
+ *
+ * @internal
+ */
+export function applyMirroredFilterValue(source, target) {
+    if (isDashboardAttributeFilter(source) && isDashboardAttributeFilter(target)) {
+        return {
+            attributeFilter: {
+                ...target.attributeFilter,
+                attributeElements: source.attributeFilter.attributeElements,
+                negativeSelection: source.attributeFilter.negativeSelection,
+            },
+        };
+    }
+    if (isDashboardDateFilter(source) && isDashboardDateFilter(target)) {
+        const dateFilter = {
+            ...source.dateFilter,
+        };
+        if (target.dateFilter.localIdentifier) {
+            dateFilter.localIdentifier = target.dateFilter.localIdentifier;
+        }
+        else {
+            delete dateFilter.localIdentifier;
+        }
+        if (target.dateFilter.dataSet) {
+            dateFilter.dataSet = target.dateFilter.dataSet;
+        }
+        else {
+            delete dateFilter.dataSet;
+        }
+        return { dateFilter };
+    }
+    if (isDashboardMeasureValueFilter(source) && isDashboardMeasureValueFilter(target)) {
+        const { measure, localIdentifier, title, dimensionality } = target.dashboardMeasureValueFilter;
+        return {
+            dashboardMeasureValueFilter: {
+                measure,
+                localIdentifier,
+                ...(title === undefined ? {} : { title }),
+                conditions: source.dashboardMeasureValueFilter.conditions,
+                ...(dimensionality?.length ? { dimensionality } : {}),
+            },
+        };
+    }
+    if (isDashboardAttributeFilterItem(source) && isDashboardAttributeFilterItem(target)) {
+        const targetLocalId = dashboardAttributeFilterItemLocalIdentifier(target);
+        if (!targetLocalId) {
+            return target;
+        }
+        return preserveFilterDependencies(target, retargetAttributeFilterItem(source, targetLocalId));
+    }
+    return target;
+}
+/**
+ * After the active tab commits staged filters and parameters, copy those applied values
+ * onto matching filters and parameters on the other tabs. Working overlays are not copied.
+ * A target tab's own staged value for a mirrored filter or parameter is dropped, so it cannot
+ * shadow the mirrored value; staged values of other filters on that tab are kept.
+ *
+ * @internal
+ */
+export function mirrorCommittedWorkingSelection(state, sourceTab, stagedFilters, stagedParameterRefs, crossFilteringLocalIdsByTab, enablePersistentFiltersAcrossTabs) {
+    if (!enablePersistentFiltersAcrossTabs) {
+        return;
+    }
+    const others = (state.tabs ?? []).filter((tab) => tab.localIdentifier !== sourceTab.localIdentifier);
+    if (others.length === 0) {
+        return;
+    }
+    for (const staged of stagedFilters ?? []) {
+        const applied = findAppliedFilterForStaged(sourceTab, staged);
+        if (!applied) {
+            continue;
+        }
+        if (isCrossFilteringVirtualFilter(sourceTab, dashboardFilterLocalIdentifier(applied), crossFilteringLocalIdsByTab)) {
+            continue;
+        }
+        for (const tab of others) {
+            const match = findCounterpartFilter(sourceTab, applied, tab, state.attributesWithReferences, {
+                allowListToText: false,
+                crossFilteringLocalIdsByTab,
+            });
+            if (!match) {
+                continue;
+            }
+            writeFilter(tab, match, applyMirroredFilterValue(applied, match));
+            dropStagedOverlay(tab, match);
+        }
+    }
+    for (const ref of stagedParameterRefs) {
+        const sourceEntry = sourceTab.parameters?.parameters.find((entry) => areObjRefsEqual(entry.parameter.ref, ref));
+        if (!sourceEntry) {
+            continue;
+        }
+        for (const tab of others) {
+            const entry = tab.parameters?.parameters.find((candidate) => areObjRefsEqual(candidate.parameter.ref, ref));
+            if (!entry) {
+                continue;
+            }
+            delete entry.workingOverride;
+            entry.runtimeOverride = sourceEntry.runtimeOverride;
+        }
+    }
+}
+/**
+ * Seeds a new tab with the applied filters of `sourceTab` and the configs that belong to them,
+ * so every synced filter has a counterpart on the new tab. Cross-filtering virtual filters stay
+ * on their own tab. `base` provides the title and description of the new filter context.
+ *
+ * @internal
+ */
+export function seedSyncedTabFilters(sourceTab, base, crossFilteringLocalIdsByTab) {
+    const filters = appliedFilters(sourceTab).filter((filter) => !isCrossFilteringVirtualFilter(sourceTab, dashboardFilterLocalIdentifier(filter), crossFilteringLocalIdsByTab));
+    const localIds = new Set(filters.map(dashboardFilterLocalIdentifier).filter((id) => id !== undefined));
+    const dateDataSets = filters
+        .filter(isDashboardDateFilter)
+        .map((filter) => filter.dateFilter.dataSet)
+        .filter((ref) => ref !== undefined);
+    const groups = (sourceTab.filterGroupsConfig?.groups ?? [])
+        .map((group) => ({
+        ...group,
+        filters: group.filters.filter((item) => localIds.has(item.filterLocalIdentifier)),
+    }))
+        .filter((group) => group.filters.length > 0);
+    return {
+        filterContextDefinition: { ...base, filters },
+        attributeFilterDisplayForms: sourceTab.filterContext?.attributeFilterDisplayForms ?? [],
+        attributeFilterConfigs: (sourceTab.attributeFilterConfigs?.attributeFilterConfigs ?? []).filter((config) => localIds.has(config.localIdentifier)),
+        dateFilterConfigs: (sourceTab.dateFilterConfigs?.dateFilterConfigs ?? []).filter((config) => dateDataSets.some((ref) => areObjRefsEqual(ref, config.dateDataSet))),
+        measureValueFilterConfigs: (sourceTab.measureValueFilterConfigs?.measureValueFilterConfigs ?? []).filter((config) => localIds.has(config.localIdentifier)),
+        filterGroupsConfig: groups.length > 0 ? { groups } : undefined,
+    };
+}
+function writeFilter(tab, current, next) {
+    const filters = tab.filterContext?.filterContextDefinition?.filters;
+    if (!filters) {
+        return;
+    }
+    const index = filters.indexOf(current);
+    if (index < 0) {
+        return;
+    }
+    filters[index] = next;
+}
+/**
+ * Removes the working entries that `applyFilterContext` would overlay on `applied`.
+ */
+function dropStagedOverlay(tab, applied) {
+    const filterContext = tab.filterContext;
+    const working = filterContext?.workingFilterContextDefinition;
+    if (!filterContext || !working?.filters.length) {
+        return;
+    }
+    const overlays = isDashboardDateFilter(applied)
+        ? (item) => "dateFilter" in item &&
+            !!item.dateFilter &&
+            (areObjRefsEqual(item.dateFilter.dataSet, applied.dateFilter.dataSet) ||
+                (!item.dateFilter.dataSet && !applied.dateFilter.dataSet))
+        : (item) => !("dateFilter" in item) &&
+            stagedLocalIdentifier(item) !== undefined &&
+            stagedLocalIdentifier(item) === dashboardFilterLocalIdentifier(applied);
+    const remaining = working.filters.filter((item) => !overlays(item));
+    if (remaining.length !== working.filters.length) {
+        filterContext.workingFilterContextDefinition = { filters: remaining };
+    }
+}
+function findAppliedFilterForStaged(tab, staged) {
+    const filters = appliedFilters(tab);
+    if ("dateFilter" in staged && staged.dateFilter) {
+        if (!staged.dateFilter.dataSet) {
+            return filters.find(isDashboardCommonDateFilter);
+        }
+        return filters.find((filter) => isDashboardDateFilter(filter) &&
+            areObjRefsEqual(filter.dateFilter.dataSet, staged.dateFilter.dataSet));
+    }
+    const localIdentifier = stagedLocalIdentifier(staged);
+    if (!localIdentifier) {
+        return undefined;
+    }
+    return filters.find((filter) => dashboardFilterLocalIdentifier(filter) === localIdentifier);
+}
+function stagedLocalIdentifier(item) {
+    if ("attributeFilter" in item && item.attributeFilter) {
+        return item.attributeFilter.localIdentifier;
+    }
+    if ("arbitraryAttributeFilter" in item && item.arbitraryAttributeFilter) {
+        return item.arbitraryAttributeFilter.localIdentifier;
+    }
+    if ("matchAttributeFilter" in item && item.matchAttributeFilter) {
+        return item.matchAttributeFilter.localIdentifier;
+    }
+    if ("dateFilter" in item && item.dateFilter) {
+        return item.dateFilter.localIdentifier;
+    }
+    if ("dashboardMeasureValueFilter" in item && item.dashboardMeasureValueFilter) {
+        return item.dashboardMeasureValueFilter.localIdentifier;
+    }
+    return undefined;
+}
+function appliedFilters(tab) {
+    return tab.filterContext?.filterContextDefinition?.filters ?? [];
+}
+function collectDisplayForms(sourceTab, targetTab, attributesWithReferences) {
+    return [
+        ...(sourceTab.filterContext?.attributeFilterDisplayForms ?? []),
+        ...(targetTab.filterContext?.attributeFilterDisplayForms ?? []),
+        ...(attributesWithReferences ?? []).flatMap((entry) => entry.attribute.displayForms ?? []),
+    ];
+}
+function findDateCounterpart(sourceFilter, targets) {
+    // Check the data set directly. `isDashboardCommonDateFilter` is typed as
+    // `obj is IDashboardDateFilter`, so using it as a guard would narrow the
+    // remaining source to `never`.
+    const dataSet = sourceFilter.dateFilter.dataSet;
+    if (!dataSet) {
+        return targets.find(isDashboardCommonDateFilter);
+    }
+    return targets.find((filter) => isDashboardDateFilter(filter) && areObjRefsEqual(filter.dateFilter.dataSet, dataSet));
+}
+function findMeasureValueCounterpart(sourceFilter, targets) {
+    return targets
+        .filter(isDashboardMeasureValueFilter)
+        .find((filter) => areObjRefsEqual(filter.dashboardMeasureValueFilter.measure, sourceFilter.dashboardMeasureValueFilter.measure) &&
+        dimensionalityCompatible(filter.dashboardMeasureValueFilter.dimensionality, sourceFilter.dashboardMeasureValueFilter.dimensionality));
+}
+/**
+ * A measure value filter syncs only with a filter on the same measure and the same dimensionality.
+ * Missing dimensionality matches only another missing dimensionality.
+ */
+function dimensionalityCompatible(left, right) {
+    const leftRefs = left ?? [];
+    const rightRefs = right ?? [];
+    if (leftRefs.length !== rightRefs.length) {
+        return false;
+    }
+    return leftRefs.every((ref, index) => areObjRefsEqual(ref, rightRefs[index]));
+}

package/esm/model/store/tabs/index.d.ts

@@ -137,6 +137,8 @@ export declare const tabsActions: import("@reduxjs/toolkit").CaseReducerActions<
         payload: {
             readonly localIdentifier: string;
             readonly dimensionality?: import("@gooddata/sdk-model").ObjRef[];
+            readonly restoreTargetOriginal?: boolean;
+            readonly enablePersistentFiltersAcrossTabs?: boolean;
         };
         type: string;
     }) => void | import("./tabsState.js").ITabsState | import("immer").WritableDraft<import("./tabsState.js").ITabsState>;

package/esm/model/store/tabs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/model/store/tabs/index.ts"],"names":[],"mappings":"AA+BA,eAAO,MAAM,gBAAgB,8DAAoB,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/model/store/tabs/index.ts"],"names":[],"mappings":"AA+BA,eAAO,MAAM,gBAAgB,8DAAoB,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAoB,CAAC"}

package/esm/model/store/tabs/parameters/parametersReducers.d.ts

@@ -20,8 +20,13 @@ export interface ISetParameterRuntimeValuesPayload {
     values: IParameterValueChange[];
     /**
      * Target tab. When omitted, the active tab is used.
+     * With `enablePersistentFiltersAcrossTabs`, this tab is the source and every other tab is written too.
      */
     tabLocalIdentifier?: string;
+    /**
+     * When true, write the values onto every tab. A tab that does not define the parameter is unchanged.
+     */
+    enablePersistentFiltersAcrossTabs?: boolean;
 }
 /**
  * Stage a parameter value under the apply-all-at-once mode. The value is always concrete: the

package/esm/model/store/tabs/parameters/parametersReducers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametersReducers.d.ts","sourceRoot":"","sources":["../../../../../src/model/store/tabs/parameters/parametersReducers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAsB,MAAM,kBAAkB,CAAC;AAErF,OAAO,EACH,KAAK,mBAAmB,EACxB,KAAK,MAAM,EACX,KAAK,cAAc,EAEtB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC7E,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAgC,MAAM,iBAAiB,CAAC;AAIhG,KAAK,iBAAiB,CAAC,CAAC,SAAS,MAAM,IAAI,WAAW,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACjC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,gBAAgB,EAAE,cAAc,CAAC;CACpC;AAoBD;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAC9C,MAAM,EAAE,qBAAqB,EAAE,CAAC;IAChC;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAWD;;;;;;GAMG;AACH,MAAM,WAAW,gCAAgC;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,cAAc,CAAC;CACzB;AAkBD;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC,GAAG,EAAE,MAAM,CAAC;CACf;AAsCD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAOjE;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAIhE;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;CAK9B,CAAC"}
+{"version":3,"file":"parametersReducers.d.ts","sourceRoot":"","sources":["../../../../../src/model/store/tabs/parameters/parametersReducers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAsB,MAAM,kBAAkB,CAAC;AAErF,OAAO,EACH,KAAK,mBAAmB,EACxB,KAAK,MAAM,EACX,KAAK,cAAc,EAEtB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC7E,OAAO,EACH,KAAK,SAAS,EACd,KAAK,UAAU,EAIlB,MAAM,iBAAiB,CAAC;AAIzB,KAAK,iBAAiB,CAAC,CAAC,SAAS,MAAM,IAAI,WAAW,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACjC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,gBAAgB,EAAE,cAAc,CAAC;CACpC;AAoBD;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAC9C,MAAM,EAAE,qBAAqB,EAAE,CAAC;IAChC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;OAEG;IACH,iCAAiC,CAAC,EAAE,OAAO,CAAC;CAC/C;AAmBD;;;;;;GAMG;AACH,MAAM,WAAW,gCAAgC;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,cAAc,CAAC;CACzB;AAkBD;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC,GAAG,EAAE,MAAM,CAAC;CACf;AAoCD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAOjE;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAIhE;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;CAK9B,CAAC"}

package/esm/model/store/tabs/parameters/parametersReducers.js

@@ -1,6 +1,6 @@
 // (C) 2026 GoodData Corporation
 import { areObjRefsEqual, } from "@gooddata/sdk-model";
-import { getActiveTab, getTabOrActive } from "../tabsState.js";
+import { getActiveTab, getTabOrActive, getTabsToMutate, } from "../tabsState.js";
 import { parametersInitialState } from "./parametersState.js";
 const addParameter = (state, action) => {
     const activeTab = getActiveTab(state);
@@ -20,8 +20,12 @@ const addParameter = (state, action) => {
     };
 };
 const setParameterRuntimeValues = (state, action) => {
-    for (const entry of action.payload.values) {
-        setRuntimeOverride(state, entry, action.payload.tabLocalIdentifier);
+    // Parameter values sync by parameter ref. A tab that does not define the parameter is a no-op.
+    // Working overrides are not written here.
+    for (const tab of getTabsToMutate(state, action.payload.tabLocalIdentifier, action.payload.enablePersistentFiltersAcrossTabs)) {
+        for (const entry of action.payload.values) {
+            setRuntimeOverrideOnTab(tab, entry);
+        }
     }
 };
 const setParameterWorkingValue = (state, action) => {
@@ -46,8 +50,8 @@ const removeParameter = (state, action) => {
         parameters: activeTab.parameters.parameters.filter((entry) => !areObjRefsEqual(entry.parameter.ref, action.payload.ref)),
     };
 };
-function setRuntimeOverride(state, { ref, value }, tabLocalIdentifier) {
-    const entry = findParameterEntry(state, ref, tabLocalIdentifier);
+function setRuntimeOverrideOnTab(tab, { ref, value }) {
+    const entry = tab.parameters?.parameters.find((candidate) => areObjRefsEqual(candidate.parameter.ref, ref));
     if (!entry) {
         return;
     }

package/esm/model/store/tabs/tabsReducers.d.ts

@@ -1,5 +1,6 @@
 import { type Action, type CaseReducer } from "@reduxjs/toolkit";
 import { type ObjRef } from "@gooddata/sdk-model";
+import { type CrossFilteringLocalIdsByTab } from "./filterContext/filterSync.js";
 import { type ITabState, type ITabsState } from "./tabsState.js";
 /**
  * @alpha
@@ -34,6 +35,11 @@ export interface ISetDashboardAttributeFilterConfigDisplayAsLabelPayload {
  */
 export interface IApplyWorkingSelectionPayload {
     readonly enableImmediateAttributeFilterDisplayAsLabelMigration?: boolean;
+    /**
+     * Cross-filtering virtual filters per tab. They are not mirrored to or from other tabs.
+     */
+    readonly crossFilteringLocalIdsByTab?: CrossFilteringLocalIdsByTab;
+    readonly enablePersistentFiltersAcrossTabs?: boolean;
 }
 export declare const tabsReducers: {
     setTabs: TabsReducer<{

package/esm/model/store/tabs/tabsReducers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tabsReducers.d.ts","sourceRoot":"","sources":["../../../../src/model/store/tabs/tabsReducers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAsB,MAAM,kBAAkB,CAAC;AAErF,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAWlD,OAAO,EAAkB,KAAK,SAAS,EAAE,KAAK,UAAU,EAAgB,MAAM,gBAAgB,CAAC;AAE/F;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,IAAI,WAAW,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;AAEvE,KAAK,cAAc,GAAG;IAClB;;OAEG;IACH,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;IAEnB;;OAEG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACrC,CAAC;AA0FF;;;GAGG;AACH,MAAM,WAAW,uDAAuD;IACpE;;OAEG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB;;OAEG;IACH,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAkDD;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC1C,QAAQ,CAAC,qDAAqD,CAAC,EAAE,OAAO,CAAC;CAC5E;AAyBD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;mBA1EkC,MAAM;wBAAc,OAAO;;;;;;mBAkBlC,MAAM;mBAAS,MAAM;;;;;;gCAeA,MAAM;;;;;;;;;;;;CAoD9E,CAAC"}
+{"version":3,"file":"tabsReducers.d.ts","sourceRoot":"","sources":["../../../../src/model/store/tabs/tabsReducers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAA+B,MAAM,kBAAkB,CAAC;AAE9F,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAOlD,OAAO,EACH,KAAK,2BAA2B,EAEnC,MAAM,+BAA+B,CAAC;AAKvC,OAAO,EAEH,KAAK,SAAS,EACd,KAAK,UAAU,EAGlB,MAAM,gBAAgB,CAAC;AAExB;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,IAAI,WAAW,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;AAEvE,KAAK,cAAc,GAAG;IAClB;;OAEG;IACH,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;IAEnB;;OAEG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACrC,CAAC;AA0FF;;;GAGG;AACH,MAAM,WAAW,uDAAuD;IACpE;;OAEG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB;;OAEG;IACH,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAkDD;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC1C,QAAQ,CAAC,qDAAqD,CAAC,EAAE,OAAO,CAAC;IACzE;;OAEG;IACH,QAAQ,CAAC,2BAA2B,CAAC,EAAE,2BAA2B,CAAC;IACnE,QAAQ,CAAC,iCAAiC,CAAC,EAAE,OAAO,CAAC;CACxD;AAsCD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;mBA5FkC,MAAM;wBAAc,OAAO;;;;;;mBAkBlC,MAAM;mBAAS,MAAM;;;;;;gCAeA,MAAM;;;;;;;;;;;;CAsE9E,CAAC"}

package/esm/model/store/tabs/tabsReducers.js

@@ -1,8 +1,10 @@
 // (C) 2021-2026 GoodData Corporation
+import { current } from "@reduxjs/toolkit";
 import { clearFilterContextWorkingValues, commitFilterContextWorkingValues, } from "./filterContext/filterContextReducers.js";
 import { initializeFilterContext } from "./filterContext/filterContextUtils.js";
+import { mirrorCommittedWorkingSelection, } from "./filterContext/filterSync.js";
 import { clearParameterWorkingValues, commitParameterWorkingValues, } from "./parameters/parametersReducers.js";
-import { DEFAULT_TAB_ID, getActiveTab } from "./tabsState.js";
+import { DEFAULT_TAB_ID, getActiveTab, getTabsToMutate, } from "./tabsState.js";
 /**
  * Applies initialization logic to a tab's filterContext if present.
  * Ensures filters have local identifiers and proper ordering.
@@ -119,16 +121,22 @@ const applyWorkingSelection = (state, action) => {
     if (!activeTab) {
         return;
     }
+    const stagedFilters = activeTab.filterContext?.workingFilterContextDefinition
+        ? current(activeTab.filterContext.workingFilterContextDefinition).filters
+        : undefined;
+    const stagedParameterRefs = (activeTab.parameters?.parameters ?? [])
+        .filter((entry) => entry.workingOverride !== undefined)
+        .map((entry) => entry.parameter.ref);
     commitFilterContextWorkingValues(activeTab, action.payload.enableImmediateAttributeFilterDisplayAsLabelMigration);
     commitParameterWorkingValues(activeTab);
+    // Mirror the committed applied values, not the working overlay.
+    mirrorCommittedWorkingSelection(state, activeTab, stagedFilters, stagedParameterRefs, action.payload.crossFilteringLocalIdsByTab, action.payload.enablePersistentFiltersAcrossTabs);
 };
 const resetWorkingSelection = (state) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab) {
-        return;
+    for (const tab of getTabsToMutate(state)) {
+        clearFilterContextWorkingValues(tab);
+        clearParameterWorkingValues(tab);
     }
-    clearFilterContextWorkingValues(activeTab);
-    clearParameterWorkingValues(activeTab);
 };
 export const tabsReducers = {
     setTabs,

package/esm/model/store/tabs/tabsState.d.ts

@@ -24,6 +24,16 @@ export declare const getActiveTab: (state: ITabsState) => ITabState | undefined;
  * @internal
  */
 export declare const getTabOrActive: (state: ITabsState, tabLocalIdentifier?: string) => ITabState | undefined;
+/**
+ * Tabs a filter or parameter mutation should write.
+ *
+ * With `persistFiltersAcrossTabs` off, that is the tab addressed by `tabLocalIdentifier`
+ * or the active tab. With the flag on, that is every tab, source first. Working-selection
+ * edits stay on the source tab so half-applied values are not mirrored.
+ *
+ * @internal
+ */
+export declare const getTabsToMutate: (state: ITabsState, tabLocalIdentifier?: string, enablePersistentFiltersAcrossTabs?: boolean, isWorkingSelectionChange?: boolean) => ITabState[];
 /**
  * @alpha
  */

package/esm/model/store/tabs/tabsState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tabsState.d.ts","sourceRoot":"","sources":["../../../../src/model/store/tabs/tabsState.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAExE,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,0DAA0D,CAAC;AAC7G,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AAC1F,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;AAC7F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,+DAA+D,CAAC;AACrH,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAExE;;;;GAIG;AACH,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,eAAO,MAAM,YAAY,UAAW,UAAU,KAAG,SAAS,GAAG,SAK5D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,UAAW,UAAU,uBAAuB,MAAM,KAAG,SAAS,GAAG,SAQ3F,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IAExB,gBAAgB,CAAC,EAAE,sBAAsB,CAAC;IAC1C,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;IAC5C,sBAAsB,CAAC,EAAE,4BAA4B,CAAC;IACtD,yBAAyB,CAAC,EAAE,+BAA+B,CAAC;IAC5D,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC,kBAAkB,CAAC,EAAE,4BAA4B,CAAC;IAClD,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAE9B;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB;;OAEG;IACH,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;IACnB;;OAEG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC;;;OAGG;IACH,wBAAwB,CAAC,EAAE,wBAAwB,EAAE,CAAC;CACzD;AAED,eAAO,MAAM,gBAAgB,EAAE,UAI9B,CAAC"}
+{"version":3,"file":"tabsState.d.ts","sourceRoot":"","sources":["../../../../src/model/store/tabs/tabsState.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAExE,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,0DAA0D,CAAC;AAC7G,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AAC1F,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;AAC7F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,+DAA+D,CAAC;AACrH,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAExE;;;;GAIG;AACH,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,eAAO,MAAM,YAAY,UAAW,UAAU,KAAG,SAAS,GAAG,SAK5D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,UAAW,UAAU,uBAAuB,MAAM,KAAG,SAAS,GAAG,SAQ3F,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,UACjB,UAAU,uBACI,MAAM,sCACS,OAAO,6BAChB,OAAO,KACnC,SAAS,EAUX,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IAExB,gBAAgB,CAAC,EAAE,sBAAsB,CAAC;IAC1C,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;IAC5C,sBAAsB,CAAC,EAAE,4BAA4B,CAAC;IACtD,yBAAyB,CAAC,EAAE,+BAA+B,CAAC;IAC5D,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC,kBAAkB,CAAC,EAAE,4BAA4B,CAAC;IAClD,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAE9B;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB;;OAEG;IACH,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;IACnB;;OAEG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC;;;OAGG;IACH,wBAAwB,CAAC,EAAE,wBAAwB,EAAE,CAAC;CACzD;AAED,eAAO,MAAM,gBAAgB,EAAE,UAI9B,CAAC"}

package/esm/model/store/tabs/tabsState.js

@@ -29,6 +29,26 @@ export const getTabOrActive = (state, tabLocalIdentifier) => {
     }
     return getActiveTab(state);
 };
+/**
+ * Tabs a filter or parameter mutation should write.
+ *
+ * With `persistFiltersAcrossTabs` off, that is the tab addressed by `tabLocalIdentifier`
+ * or the active tab. With the flag on, that is every tab, source first. Working-selection
+ * edits stay on the source tab so half-applied values are not mirrored.
+ *
+ * @internal
+ */
+export const getTabsToMutate = (state, tabLocalIdentifier, enablePersistentFiltersAcrossTabs, isWorkingSelectionChange) => {
+    const source = getTabOrActive(state, tabLocalIdentifier);
+    if (!source) {
+        return [];
+    }
+    if (isWorkingSelectionChange || !enablePersistentFiltersAcrossTabs) {
+        return [source];
+    }
+    const others = (state.tabs ?? []).filter((tab) => tab.localIdentifier !== source.localIdentifier);
+    return [source, ...others];
+};
 export const tabsInitialState = {
     tabs: undefined,
     activeTabLocalIdentifier: undefined,

package/esm/model/store/unavailableObjects/copyBlockingReferences.d.ts

@@ -18,9 +18,11 @@ export interface IDashboardCopySourceTab {
  *
  * @remarks
  * The backend accepts a copy that keeps a drill to a dashboard the user cannot open or an ignored
- * drill-down hierarchy, so neither counts. It refuses a copy whose filters use a label, metric or fact
- * the user may not read: an attribute filter's label, a measure value filter's metric, or a metric or
- * fact limiting a filter's values. A merely deleted object does not count.
+ * drill-down hierarchy, so neither counts. It refuses a copy whose filters use a label, attribute, metric
+ * or fact the user may not read: an attribute filter's label, a measure value filter's metric or
+ * "For attribute" item, or a metric, fact or "Count of" attribute limiting a filter's values. A filter
+ * restricted only through its parent filter does not count, as it names the parent by local identifier
+ * only. A merely deleted object does not count.
  *
  * @internal
  */

package/esm/model/store/unavailableObjects/copyBlockingReferences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"copyBlockingReferences.d.ts","sourceRoot":"","sources":["../../../../src/model/store/unavailableObjects/copyBlockingReferences.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EACH,KAAK,iBAAiB,EAEtB,KAAK,+BAA+B,EACpC,KAAK,gBAAgB,EAErB,KAAK,QAAQ,EAkBhB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,KAAK,uBAAuB,EAAmC,MAAM,4BAA4B,CAAC;AAK3G,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAKrD;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACpC,MAAM,CAAC,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IACnD,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B,sBAAsB,EAAE,+BAA+B,EAAE,CAAC;CAC7D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACpC,IAAI,EAAE,uBAAuB,EAAE,EAC/B,QAAQ,EAAE,QAAQ,EAAE,EACpB,kBAAkB,EAAE,8BAA8B,EAAE,GACrD,OAAO,CA8ET;AAED;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,EAAE,iBAAiB,CAAC,OAAO,CAqBtE,CAAC"}
+{"version":3,"file":"copyBlockingReferences.d.ts","sourceRoot":"","sources":["../../../../src/model/store/unavailableObjects/copyBlockingReferences.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EACH,KAAK,iBAAiB,EAEtB,KAAK,+BAA+B,EACpC,KAAK,gBAAgB,EAErB,KAAK,QAAQ,EAchB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,KAAK,uBAAuB,EAAmC,MAAM,4BAA4B,CAAC;AAQ3G,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAKrD;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACpC,MAAM,CAAC,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IACnD,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B,sBAAsB,EAAE,+BAA+B,EAAE,CAAC;CAC7D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CACpC,IAAI,EAAE,uBAAuB,EAAE,EAC/B,QAAQ,EAAE,QAAQ,EAAE,EACpB,kBAAkB,EAAE,8BAA8B,EAAE,GACrD,OAAO,CAgET;AAED;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,EAAE,iBAAiB,CAAC,OAAO,CAqBtE,CAAC"}

package/esm/model/store/unavailableObjects/copyBlockingReferences.js

@@ -1,23 +1,25 @@
 // (C) 2026 GoodData Corporation
 import { createSelector } from "@reduxjs/toolkit";
-import { areObjRefsEqual, dashboardAttributeFilterItemDisplayForm, dashboardAttributeFilterItemValidateElementsBy, insightRef, isComputedAttributeRef, isDashboardAttributeFilterItem, isDashboardAttributeFilterReference, isDashboardMeasureValueFilter, isDashboardMeasureValueFilterReference, isDrillToDashboard, isInsightWidget, isKpiWidget, isRichTextWidget, isVisualizationSwitcherWidget, } from "@gooddata/sdk-model";
+import { areObjRefsEqual, insightRef, isComputedAttributeRef, isDashboardAttributeFilterReference, isDashboardMeasureValueFilterReference, isDrillToDashboard, isInsightWidget, isKpiWidget, isRichTextWidget, isVisualizationSwitcherWidget, } from "@gooddata/sdk-model";
 import { collectReferences } from "@gooddata/sdk-ui-kit";
 import { isExtendedDashboardLayoutWidget } from "../../types/layoutTypes.js";
-import { isDashboardObjectRestricted } from "../filtering/restrictedFilterUtils.js";
+import { isDashboardFilterUsingRestrictedObject, isDashboardObjectRestricted, } from "../filtering/restrictedFilterUtils.js";
 import { selectInsights } from "../insights/insightsSelectors.js";
 import { selectIsInViewMode } from "../renderMode/renderModeSelectors.js";
 import { selectTabs } from "../tabs/tabsSelectors.js";
 import { isDrillRestricted } from "../widgetDrills/drillRestrictionUtils.js";
-import { newRestrictedLimitingItemsMap, selectUnavailableObjects } from "./unavailableObjectsSelectors.js";
+import { selectUnavailableObjects } from "./unavailableObjectsSelectors.js";
 /**
  * Tells whether a copy of the dashboard would reference an object the current user may not read in a
  * place the backend checks when it creates the copy, so it would refuse the copy.
  *
  * @remarks
  * The backend accepts a copy that keeps a drill to a dashboard the user cannot open or an ignored
- * drill-down hierarchy, so neither counts. It refuses a copy whose filters use a label, metric or fact
- * the user may not read: an attribute filter's label, a measure value filter's metric, or a metric or
- * fact limiting a filter's values. A merely deleted object does not count.
+ * drill-down hierarchy, so neither counts. It refuses a copy whose filters use a label, attribute, metric
+ * or fact the user may not read: an attribute filter's label, a measure value filter's metric or
+ * "For attribute" item, or a metric, fact or "Count of" attribute limiting a filter's values. A filter
+ * restricted only through its parent filter does not count, as it names the parent by local identifier
+ * only. A merely deleted object does not count.
  *
  * @internal
  */
@@ -55,20 +57,11 @@ export function hasCopyBlockingReference(tabs, insights, unavailableObjects) {
         }
         return false;
     };
-    const restrictedLimitingItems = newRestrictedLimitingItemsMap(unavailableObjects);
-    const isFilterForbidden = (filter) => {
-        if (isDashboardMeasureValueFilter(filter)) {
-            return isForbidden(filter.dashboardMeasureValueFilter.measure, "measure");
-        }
-        return (isDashboardAttributeFilterItem(filter) &&
-            (isLabelForbidden(dashboardAttributeFilterItemDisplayForm(filter)) ||
-                (dashboardAttributeFilterItemValidateElementsBy(filter) ?? []).some((item) => restrictedLimitingItems.has(item))));
-    };
     const isSectionForbidden = (section) => isTextForbidden(section.header?.description) ||
         section.items.some((item) => item.widget !== undefined && isWidgetForbidden(item.widget));
     return tabs.some((tab) => (tab.layout?.sections ?? []).some(isSectionForbidden) ||
         tab.attributeFilterConfigs.some((config) => isLabelForbidden(config.displayAsLabel)) ||
-        tab.filters.some(isFilterForbidden));
+        tab.filters.some((filter) => isDashboardFilterUsingRestrictedObject(filter, unavailableObjects)));
 }
 /**
  * Selects whether "Save as new" would fail because the dashboard, as it stands now, references objects