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

package/esm/model/commandHandlers/filterContext/measureValueFilter/changeMeasureValueFilterConditionHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"changeMeasureValueFilterConditionHandler.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/filterContext/measureValueFilter/changeMeasureValueFilterConditionHandler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,OAAO,EAAE,KAAK,kCAAkC,EAAE,MAAM,8BAA8B,CAAC;AAUvF,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAQtE,wBAAiB,wCAAwC,CACrD,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,kCAAkC,GACxC,YAAY,CAAC,IAAI,CAAC,CAmDpB"}
+{"version":3,"file":"changeMeasureValueFilterConditionHandler.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/filterContext/measureValueFilter/changeMeasureValueFilterConditionHandler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,OAAO,EAAE,KAAK,kCAAkC,EAAE,MAAM,8BAA8B,CAAC;AASvF,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,wBAAiB,wCAAwC,CACrD,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,kCAAkC,GACxC,YAAY,CAAC,IAAI,CAAC,CA2CpB"}

package/esm/model/commandHandlers/filterContext/measureValueFilter/changeMeasureValueFilterConditionHandler.js

@@ -1,37 +1,31 @@
 // (C) 2026 GoodData Corporation
-import { call, put, select } from "redux-saga/effects";
+import { call, select } from "redux-saga/effects";
 import { invariant } from "ts-invariant";
 import { measureValueFilterConditionChanged } from "../../../events/filters.js";
 import { invalidArgumentsProvided } from "../../../events/general.js";
 import { dispatchDashboardEvent } from "../../../store/_infra/eventDispatcher.js";
-import { selectEnablePersistentFiltersAcrossTabs } from "../../../store/meta/metaSelectors.js";
 import { selectFilterContextMeasureValueFilterByLocalId, selectWorkingFilterContextMeasureValueFilterByLocalId, } from "../../../store/tabs/filterContext/filterContextSelectors.js";
 import { tabsActions } from "../../../store/tabs/index.js";
-import { captureFilterContextByTabSnapshot, dispatchFilterContextChanged, dispatchFilterContextChangedForMutatedTabs, } from "../common.js";
+import { beginTabSync, endTabSync, putTabSynced } from "../tabSync/tabSyncSaga.js";
 export function* changeMeasureValueFilterConditionHandler(ctx, cmd) {
     const { localIdentifier, conditions, isWorkingSelectionChange } = cmd.payload;
     const existingFilter = yield select(selectFilterContextMeasureValueFilterByLocalId(localIdentifier));
-    const enablePersistentFiltersAcrossTabs = yield select(selectEnablePersistentFiltersAcrossTabs);
-    const filterContextSnapshot = yield call(captureFilterContextByTabSnapshot);
+    const session = yield call(beginTabSync);
     if (!existingFilter) {
         throw invalidArgumentsProvided(ctx, cmd, `Attempting to change condition of measure value filter ${localIdentifier} that does not exist on the dashboard.`);
     }
-    yield put(tabsActions.changeMeasureValueFilterCondition({
-        localIdentifier,
-        conditions,
-        ...(isWorkingSelectionChange === undefined ? {} : { isWorkingSelectionChange }),
-        enablePersistentFiltersAcrossTabs,
-    }));
+    yield call(putTabSynced, session, [
+        tabsActions.changeMeasureValueFilterCondition({
+            localIdentifier,
+            conditions,
+            ...(isWorkingSelectionChange === undefined ? {} : { isWorkingSelectionChange }),
+        }),
+    ]);
     const updatedFilterSelector = isWorkingSelectionChange
         ? selectWorkingFilterContextMeasureValueFilterByLocalId(localIdentifier)
         : selectFilterContextMeasureValueFilterByLocalId(localIdentifier);
     const updatedFilter = yield select(updatedFilterSelector);
     invariant(updatedFilter, "Inconsistent state in changeMeasureValueFilterConditionHandler");
     yield dispatchDashboardEvent(measureValueFilterConditionChanged(ctx, localIdentifier, updatedFilter, conditions, cmd.correlationId));
-    if (enablePersistentFiltersAcrossTabs) {
-        yield call(dispatchFilterContextChangedForMutatedTabs, ctx, cmd, filterContextSnapshot);
-    }
-    else {
-        yield call(dispatchFilterContextChanged, ctx, cmd);
-    }
+    yield call(endTabSync, ctx, cmd, session);
 }

package/esm/model/commandHandlers/filterContext/measureValueFilter/changeMeasureValueFilterDimensionalityHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"changeMeasureValueFilterDimensionalityHandler.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/filterContext/measureValueFilter/changeMeasureValueFilterDimensionalityHandler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,OAAO,EAAE,KAAK,oCAAoC,EAAE,MAAM,8BAA8B,CAAC;AAOzF,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,wBAAiB,6CAA6C,CAC1D,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,oCAAoC,GAC1C,YAAY,CAAC,IAAI,CAAC,CAwCpB"}
+{"version":3,"file":"changeMeasureValueFilterDimensionalityHandler.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/filterContext/measureValueFilter/changeMeasureValueFilterDimensionalityHandler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,OAAO,EAAE,KAAK,oCAAoC,EAAE,MAAM,8BAA8B,CAAC;AAMzF,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,wBAAiB,6CAA6C,CAC1D,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,oCAAoC,GAC1C,YAAY,CAAC,IAAI,CAAC,CAmCpB"}

package/esm/model/commandHandlers/filterContext/measureValueFilter/changeMeasureValueFilterDimensionalityHandler.js

@@ -1,27 +1,24 @@
 // (C) 2026 GoodData Corporation
-import { call, put, select } from "redux-saga/effects";
+import { call, select } from "redux-saga/effects";
 import { invariant } from "ts-invariant";
 import { measureValueFilterDimensionalityChanged } from "../../../events/filters.js";
 import { invalidArgumentsProvided } from "../../../events/general.js";
 import { dispatchDashboardEvent } from "../../../store/_infra/eventDispatcher.js";
-import { selectEnablePersistentFiltersAcrossTabs } from "../../../store/meta/metaSelectors.js";
 import { selectFilterContextMeasureValueFilterByLocalId } from "../../../store/tabs/filterContext/filterContextSelectors.js";
 import { tabsActions } from "../../../store/tabs/index.js";
-import { dispatchFilterContextChanged } from "../common.js";
+import { beginTabSync, endTabSync, putTabSynced } from "../tabSync/tabSyncSaga.js";
 export function* changeMeasureValueFilterDimensionalityHandler(ctx, cmd) {
     const { localIdentifier, dimensionality } = cmd.payload;
     const existingFilter = yield select(selectFilterContextMeasureValueFilterByLocalId(localIdentifier));
-    const enablePersistentFiltersAcrossTabs = yield select(selectEnablePersistentFiltersAcrossTabs);
+    const session = yield call(beginTabSync);
     if (!existingFilter) {
         throw invalidArgumentsProvided(ctx, cmd, `Attempting to change dimensionality of measure value filter ${localIdentifier} that does not exist on the dashboard.`);
     }
-    yield put(tabsActions.setMeasureValueFilterDimensionality({
-        localIdentifier,
-        dimensionality,
-        enablePersistentFiltersAcrossTabs,
-    }));
+    yield call(putTabSynced, session, [
+        tabsActions.setMeasureValueFilterDimensionality({ localIdentifier, dimensionality }),
+    ]);
     const updatedFilter = yield select(selectFilterContextMeasureValueFilterByLocalId(localIdentifier));
     invariant(updatedFilter, "Inconsistent state in changeMeasureValueFilterDimensionalityHandler");
     yield dispatchDashboardEvent(measureValueFilterDimensionalityChanged(ctx, localIdentifier, updatedFilter, dimensionality, cmd.correlationId));
-    yield call(dispatchFilterContextChanged, ctx, cmd);
+    yield call(endTabSync, ctx, cmd, session);
 }

package/esm/model/commandHandlers/filterContext/tabSync/expandActionsForTabSync.d.ts

@@ -0,0 +1,15 @@
+import { type Action } from "@reduxjs/toolkit";
+import { type ITabsState } from "../../../store/tabs/tabsState.js";
+import { type ITabSyncScope } from "./tabSyncScope.js";
+/**
+ * Returns `actions` followed, after each one, by its copies for the other tabs.
+ *
+ * Every action is planned against the state that the preceding actions and their copies produce,
+ * so e.g. removing an ignore-list entry after removing the filter sees which tabs still use it.
+ * Actions with a sync rule but without a tab are addressed to the scope source tab, so that they
+ * are applied to the tab they are planned for. Nothing is mirrored when the scope is disabled.
+ *
+ * @internal
+ */
+export declare function expandActionsForTabSync(state: ITabsState, actions: readonly Action[], scope: ITabSyncScope): Action[];
+//# sourceMappingURL=expandActionsForTabSync.d.ts.map

package/esm/model/commandHandlers/filterContext/tabSync/expandActionsForTabSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expandActionsForTabSync.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/filterContext/tabSync/expandActionsForTabSync.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAsB,MAAM,kBAAkB,CAAC;AAInE,OAAO,EAAE,KAAK,UAAU,EAAkB,MAAM,kCAAkC,CAAC;AAGnF,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIvD;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACnC,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,KAAK,EAAE,aAAa,GACrB,MAAM,EAAE,CAiBV"}

package/esm/model/commandHandlers/filterContext/tabSync/expandActionsForTabSync.js

@@ -0,0 +1,88 @@
+// (C) 2026 GoodData Corporation
+import { BATCH } from "redux-batched-actions";
+import { tabsActions, tabsSliceReducer } from "../../../store/tabs/index.js";
+import { getTabOrActive } from "../../../store/tabs/tabsState.js";
+import { tabSyncRules } from "./tabSyncRules.js";
+/**
+ * Returns `actions` followed, after each one, by its copies for the other tabs.
+ *
+ * Every action is planned against the state that the preceding actions and their copies produce,
+ * so e.g. removing an ignore-list entry after removing the filter sees which tabs still use it.
+ * Actions with a sync rule but without a tab are addressed to the scope source tab, so that they
+ * are applied to the tab they are planned for. Nothing is mirrored when the scope is disabled.
+ *
+ * @internal
+ */
+export function expandActionsForTabSync(state, actions, scope) {
+    const sourceActions = actions
+        .flatMap(unbatched)
+        .map((action) => addressedToSourceTab(action, scope.sourceTabLocalIdentifier));
+    if (!scope.enabled) {
+        return sourceActions;
+    }
+    const result = [];
+    let current = state;
+    for (const action of sourceActions) {
+        const after = tabsSliceReducer(current, action);
+        const mirrored = mirrorAction(current, after, action, scope);
+        result.push(action, ...mirrored);
+        current = mirrored.reduce(tabsSliceReducer, after);
+    }
+    return result;
+}
+function mirrorAction(state, after, action, scope) {
+    const rule = tabSyncRules.get(action.type);
+    if (!rule) {
+        return [];
+    }
+    const payload = action.payload;
+    const sourceTabLocalIdentifier = payload?.tabLocalIdentifier ?? scope.sourceTabLocalIdentifier;
+    const source = getTabOrActive(state, sourceTabLocalIdentifier);
+    const sourceAfter = getTabOrActive(after, sourceTabLocalIdentifier);
+    if (!source || !sourceAfter) {
+        return [];
+    }
+    const ctx = { scope, state, source, sourceAfter };
+    return (state.tabs ?? []).flatMap((target) => {
+        if (target.localIdentifier === source.localIdentifier) {
+            return [];
+        }
+        return rule(payload, target, ctx).map((targetAction) => ({
+            ...targetAction,
+            payload: { ...targetAction.payload, tabLocalIdentifier: target.localIdentifier },
+        }));
+    });
+}
+/**
+ * Reducers of actions without a tab apply them to the active tab, which is not the source tab
+ * when a handler works on another tab.
+ */
+function addressedToSourceTab(action, sourceTabLocalIdentifier) {
+    if (!sourceTabLocalIdentifier || !tabSyncRules.has(action.type)) {
+        return action;
+    }
+    if (tabsActions.addAttributeFilterDisplayForm.match(action)) {
+        const { payload } = action;
+        return "displayForm" in payload
+            ? tabsActions.addAttributeFilterDisplayForm({
+                ...payload,
+                tabLocalIdentifier: payload.tabLocalIdentifier ?? sourceTabLocalIdentifier,
+            })
+            : tabsActions.addAttributeFilterDisplayForm({
+                displayForm: payload,
+                tabLocalIdentifier: sourceTabLocalIdentifier,
+            });
+    }
+    const payload = action.payload;
+    if (payload?.tabLocalIdentifier) {
+        return action;
+    }
+    return { ...action, payload: { ...payload, tabLocalIdentifier: sourceTabLocalIdentifier } };
+}
+/**
+ * The tabs slice reducer ignores batch actions, which the store unpacks, so planning
+ * works on their inner actions.
+ */
+function unbatched(action) {
+    return action.type === BATCH ? action.payload.flatMap(unbatched) : [action];
+}

package/esm/model/commandHandlers/filterContext/tabSync/tabSyncRules.d.ts

@@ -0,0 +1,11 @@
+import { type TabSyncActionsRule } from "./tabSyncScope.js";
+type AnyTabSyncRule = TabSyncActionsRule<any>;
+/**
+ * Tabs slice actions that are mirrored to other tabs when filters persist across tabs, keyed by action type.
+ * Actions without a rule apply to their own tab only, which includes every filter configuration change.
+ *
+ * @internal
+ */
+export declare const tabSyncRules: ReadonlyMap<string, AnyTabSyncRule>;
+export {};
+//# sourceMappingURL=tabSyncRules.d.ts.map

package/esm/model/commandHandlers/filterContext/tabSync/tabSyncRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabSyncRules.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/filterContext/tabSync/tabSyncRules.ts"],"names":[],"mappings":"AAoCA,OAAO,EAA4B,KAAK,kBAAkB,EAAoB,MAAM,mBAAmB,CAAC;AAExG,KAAK,cAAc,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC;AAuZ9C;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAG3D,CAAC"}

package/esm/model/commandHandlers/filterContext/tabSync/tabSyncRules.js

@@ -0,0 +1,335 @@
+// (C) 2026 GoodData Corporation
+import { areObjRefsEqual, dashboardAttributeFilterItemLocalIdentifier, dashboardFilterLocalIdentifier, isAllTimeDashboardDateFilter, isDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardDateFilterWithDimension, isDashboardMeasureValueFilter, isNoopAllTimeDashboardDateFilter, } from "@gooddata/sdk-model";
+import { applyMirroredFilterValue, findAppliedFilterForStaged, findCounterpartFilter, findOriginalFilter, isCrossFilteringVirtualFilter, retargetAttributeFilterItem, } from "../../../store/tabs/filterContext/filterSync.js";
+import { tabsActions } from "../../../store/tabs/index.js";
+function defineRule(actionCreator, rule) {
+    return defineActionsRule(actionCreator, (payload, target, ctx) => {
+        const targetPayload = rule(payload, target, ctx);
+        return targetPayload ? [actionCreator(targetPayload)] : [];
+    });
+}
+function defineActionsRule(actionCreator, rule) {
+    return [actionCreator.type, rule];
+}
+//
+// Shared lookups
+//
+function filtersOf(tab) {
+    return tab.filterContext?.filterContextDefinition?.filters ?? [];
+}
+function findFilterByLocalId(tab, localIdentifier) {
+    return filtersOf(tab).find((item) => dashboardFilterLocalIdentifier(item) === localIdentifier);
+}
+function findCounterpartOf(ctx, sourceTab, sourceFilter, target) {
+    const { crossFilteringLocalIdsByTab } = ctx.scope;
+    if (isCrossFilteringVirtualFilter(sourceTab, dashboardFilterLocalIdentifier(sourceFilter), crossFilteringLocalIdsByTab)) {
+        return undefined;
+    }
+    return findCounterpartFilter(sourceTab, sourceFilter, target, ctx.state.attributesWithReferences, {
+        crossFilteringLocalIdsByTab,
+    });
+}
+/**
+ * The filter on `target` that is the same logical filter as the source tab filter `sourceLocalId`.
+ * Cross-filtering virtual filters have no counterpart.
+ */
+function findCounterpart(ctx, target, sourceLocalId) {
+    const sourceFilter = findFilterByLocalId(ctx.source, sourceLocalId);
+    return sourceFilter ? findCounterpartOf(ctx, ctx.source, sourceFilter, target) : undefined;
+}
+function counterpartLocalId(ctx, target, sourceLocalId) {
+    const counterpart = findCounterpart(ctx, target, sourceLocalId);
+    return counterpart ? dashboardFilterLocalIdentifier(counterpart) : undefined;
+}
+function findDimensionDateFilter(tab, dataSet) {
+    return filtersOf(tab).find((item) => isDashboardDateFilterWithDimension(item) && areObjRefsEqual(item.dateFilter.dataSet, dataSet));
+}
+//
+// Selection
+//
+function findSelectionCounterpart(ctx, target, sourceLocalId) {
+    const sourceFilter = findFilterByLocalId(ctx.source, sourceLocalId);
+    if (!isDashboardAttributeFilter(sourceFilter)) {
+        return undefined;
+    }
+    const counterpart = findCounterpartOf(ctx, ctx.source, sourceFilter, target);
+    return isDashboardAttributeFilter(counterpart) && counterpart.attributeFilter.localIdentifier
+        ? counterpart
+        : undefined;
+}
+function findMeasureValueCounterpart(ctx, target, sourceLocalId) {
+    const sourceFilter = findFilterByLocalId(ctx.source, sourceLocalId);
+    if (!isDashboardMeasureValueFilter(sourceFilter)) {
+        return undefined;
+    }
+    const counterpart = findCounterpartOf(ctx, ctx.source, sourceFilter, target);
+    return isDashboardMeasureValueFilter(counterpart) ? counterpart : undefined;
+}
+function findAppliedDateFilter(tab, dataSet) {
+    return dataSet ? findDimensionDateFilter(tab, dataSet) : filtersOf(tab).find(isDashboardCommonDateFilter);
+}
+function toUpsertDateFilterPayload(filter) {
+    const { dataSet, localIdentifier, emptyValueHandling, boundedFilter, type, granularity, from, to } = filter.dateFilter;
+    const shared = {
+        ...(dataSet ? { dataSet } : {}),
+        ...(localIdentifier ? { localIdentifier } : {}),
+        ...(emptyValueHandling ? { emptyValueHandling } : {}),
+    };
+    if (isAllTimeDashboardDateFilter(filter)) {
+        return { type: "allTime", ...shared };
+    }
+    return { type, granularity, from, to, ...(boundedFilter ? { boundedFilter } : {}), ...shared };
+}
+/**
+ * Saved date filter of `target`. A common date filter without a saved original is all time, which is
+ * stored as the absence of the filter. A dimension date filter without a saved original is left unchanged.
+ */
+function savedDateFilterPayload(target, applied, dataSet) {
+    const original = findOriginalFilter(target, applied ?? { dateFilter: { type: "relative", granularity: "GDC.time.date" } });
+    if (isDashboardDateFilter(original)) {
+        return toUpsertDateFilterPayload(original);
+    }
+    return dataSet ? undefined : { type: "allTime" };
+}
+function committedParameterValues(ctx, target) {
+    const stagedRefs = (ctx.source.parameters?.parameters ?? [])
+        .filter((entry) => entry.workingOverride !== undefined)
+        .map((entry) => entry.parameter.ref);
+    return stagedRefs.flatMap((ref) => {
+        const committed = ctx.sourceAfter.parameters?.parameters.find((entry) => areObjRefsEqual(entry.parameter.ref, ref));
+        const definedOnTarget = target.parameters?.parameters.some((entry) => areObjRefsEqual(entry.parameter.ref, ref));
+        return committed && definedOnTarget ? [{ ref, value: committed.runtimeOverride }] : [];
+    });
+}
+function committedFilterValues(ctx, target) {
+    const staged = ctx.source.filterContext?.workingFilterContextDefinition?.filters ?? [];
+    return staged.flatMap((item) => {
+        const committed = findAppliedFilterForStaged(ctx.sourceAfter, item);
+        if (!committed) {
+            return [];
+        }
+        const counterpart = findCounterpartOf(ctx, ctx.sourceAfter, committed, target);
+        if (counterpart) {
+            return [applyMirroredFilterValue(committed, counterpart)];
+        }
+        // A tab without a common date filter is all time, so it receives the committed value
+        // without the local identifier of the source.
+        if (!isDashboardCommonDateFilter(committed) || isNoopAllTimeDashboardDateFilter(committed)) {
+            return [];
+        }
+        const { localIdentifier: _sourceLocalIdentifier, ...dateFilter } = committed.dateFilter;
+        return [{ dateFilter }];
+    });
+}
+//
+// Rules
+//
+const filterContextRules = [
+    defineRule(tabsActions.addAttributeFilterDisplayForm, (payload, target) => {
+        if (!target.filterContext?.attributeFilterDisplayForms) {
+            return undefined;
+        }
+        return { displayForm: "displayForm" in payload ? payload.displayForm : payload };
+    }),
+    // Selection changes swap the display form together with elements expressed in it, so the swap
+    // follows the selection. Filter configuration handlers do not sync these actions.
+    // A tab that shows its display form as its label keeps showing it as its display-as label.
+    // With `restoreTargetOriginal`, every tab restores its own saved labels.
+    defineActionsRule(tabsActions.changeAttributeDisplayForm, (payload, target, ctx) => {
+        // Staged edits stay on their tab until applied; every tab migrates its own filters.
+        if (payload.isWorkingSelectionChange || payload.isResultOfMigration) {
+            return [];
+        }
+        const counterpart = findCounterpart(ctx, target, payload.filterLocalId);
+        if (!isDashboardAttributeFilter(counterpart)) {
+            return [];
+        }
+        const filterLocalId = dashboardFilterLocalIdentifier(counterpart);
+        if (!payload.restoreTargetOriginal) {
+            const changeDisplayForm = tabsActions.changeAttributeDisplayForm({ ...payload, filterLocalId });
+            const currentDisplayForm = counterpart.attributeFilter.displayForm;
+            const hasDisplayAsLabel = target.attributeFilterConfigs?.attributeFilterConfigs?.some((config) => config.localIdentifier === filterLocalId && config.displayAsLabel);
+            if (hasDisplayAsLabel || areObjRefsEqual(currentDisplayForm, payload.displayForm)) {
+                return [changeDisplayForm];
+            }
+            return [
+                changeDisplayForm,
+                tabsActions.changeDisplayAsLabel({
+                    localIdentifier: filterLocalId,
+                    displayAsLabel: currentDisplayForm,
+                }),
+            ];
+        }
+        const original = findOriginalFilter(target, counterpart);
+        if (!isDashboardAttributeFilter(original) ||
+            areObjRefsEqual(original.attributeFilter.displayForm, counterpart.attributeFilter.displayForm)) {
+            return [];
+        }
+        return [
+            tabsActions.changeAttributeDisplayForm({
+                ...payload,
+                filterLocalId,
+                displayForm: original.attributeFilter.displayForm,
+            }),
+        ];
+    }),
+    // A display-as label is filter configuration, which stays on its tab. Only a reset is mirrored,
+    // so that every tab restores its own saved label.
+    defineRule(tabsActions.changeDisplayAsLabel, (payload, target, ctx) => {
+        if (!payload.restoreTargetOriginal) {
+            return undefined;
+        }
+        const localIdentifier = counterpartLocalId(ctx, target, payload.localIdentifier);
+        if (!localIdentifier) {
+            return undefined;
+        }
+        const savedConfigs = ctx.scope.persistedAttributeFilterConfigsByTab?.[target.localIdentifier];
+        if (!savedConfigs) {
+            return undefined;
+        }
+        const displayAsLabel = savedConfigs.find((config) => config.localIdentifier === localIdentifier)?.displayAsLabel;
+        const currentDisplayAsLabel = target.attributeFilterConfigs?.attributeFilterConfigs?.find((config) => config.localIdentifier === localIdentifier)?.displayAsLabel;
+        return areObjRefsEqual(displayAsLabel, currentDisplayAsLabel)
+            ? undefined
+            : { ...payload, localIdentifier, displayAsLabel };
+    }),
+];
+// Staged edits stay on their tab until applied. With `restoreTargetOriginal`, every tab restores its own saved value.
+const selectionRules = [
+    defineRule(tabsActions.updateAttributeFilterSelection, (payload, target, ctx) => {
+        // Every tab migrates its own filters, so a migrated selection stays on its tab.
+        if (payload.isWorkingSelectionChange || payload.isResultOfMigration) {
+            return undefined;
+        }
+        const counterpart = findSelectionCounterpart(ctx, target, payload.filterLocalId);
+        if (!counterpart) {
+            return undefined;
+        }
+        const original = payload.restoreTargetOriginal ? findOriginalFilter(target, counterpart) : undefined;
+        if (payload.restoreTargetOriginal && !isDashboardAttributeFilter(original)) {
+            return undefined;
+        }
+        return {
+            ...payload,
+            filterLocalId: counterpart.attributeFilter.localIdentifier,
+            ...(isDashboardAttributeFilter(original)
+                ? {
+                    elements: original.attributeFilter.attributeElements,
+                    negativeSelection: original.attributeFilter.negativeSelection,
+                }
+                : {}),
+            // Every tab migrates its own filters.
+            enableImmediateAttributeFilterDisplayAsLabelMigration: false,
+        };
+    }),
+    defineRule(tabsActions.replaceAttributeFilterItem, (payload, target, ctx) => {
+        if (payload.isWorkingSelectionChange) {
+            return undefined;
+        }
+        const sourceFilter = findFilterByLocalId(ctx.source, payload.filterLocalId);
+        if (!isDashboardAttributeFilterItem(sourceFilter)) {
+            return undefined;
+        }
+        const counterpart = findCounterpartOf(ctx, ctx.source, sourceFilter, target);
+        if (!isDashboardAttributeFilterItem(counterpart)) {
+            return undefined;
+        }
+        const filterLocalId = dashboardAttributeFilterItemLocalIdentifier(counterpart);
+        if (!filterLocalId) {
+            return undefined;
+        }
+        const original = payload.restoreTargetOriginal ? findOriginalFilter(target, counterpart) : undefined;
+        if (payload.restoreTargetOriginal && !isDashboardAttributeFilterItem(original)) {
+            return undefined;
+        }
+        const replacement = isDashboardAttributeFilterItem(original) ? original : payload.filter;
+        return { ...payload, filterLocalId, filter: retargetAttributeFilterItem(replacement, filterLocalId) };
+    }),
+    defineRule(tabsActions.clearAttributeFiltersSelection, (payload, target, ctx) => {
+        const filterLocalIds = payload.filterLocalIds.flatMap((filterLocalId) => {
+            const counterpart = findSelectionCounterpart(ctx, target, filterLocalId);
+            return counterpart ? [counterpart.attributeFilter.localIdentifier] : [];
+        });
+        if (filterLocalIds.length === 0) {
+            return undefined;
+        }
+        return { filterLocalIds, ...(payload.restoreTargetOriginal ? { restoreOriginal: true } : {}) };
+    }),
+    defineRule(tabsActions.upsertDateFilter, (payload, target) => {
+        if (payload.isWorkingSelectionChange || !target.filterContext?.filterContextDefinition) {
+            return undefined;
+        }
+        const counterpart = findAppliedDateFilter(target, payload.dataSet);
+        // A common date filter always has a counterpart: all time is stored as its absence.
+        if (!counterpart && payload.dataSet) {
+            return undefined;
+        }
+        const value = payload.restoreTargetOriginal
+            ? savedDateFilterPayload(target, counterpart, payload.dataSet)
+            : payload;
+        if (!value) {
+            return undefined;
+        }
+        // A common date filter created on the target does not take the local identifier of the source.
+        const ownValue = payload.restoreTargetOriginal ? value.localIdentifier : undefined;
+        return { ...value, localIdentifier: counterpart?.dateFilter.localIdentifier ?? ownValue };
+    }),
+    defineRule(tabsActions.changeMeasureValueFilterCondition, (payload, target, ctx) => {
+        if (payload.isWorkingSelectionChange) {
+            return undefined;
+        }
+        const counterpart = findMeasureValueCounterpart(ctx, target, payload.localIdentifier);
+        if (!counterpart) {
+            return undefined;
+        }
+        const localIdentifier = counterpart.dashboardMeasureValueFilter.localIdentifier;
+        if (!payload.restoreTargetOriginal) {
+            return { ...payload, localIdentifier };
+        }
+        const original = findOriginalFilter(target, counterpart);
+        return isDashboardMeasureValueFilter(original)
+            ? { ...payload, localIdentifier, conditions: original.dashboardMeasureValueFilter.conditions }
+            : undefined;
+    }),
+    defineRule(tabsActions.setMeasureValueFilterDimensionality, (payload, target, ctx) => {
+        const counterpart = findMeasureValueCounterpart(ctx, target, payload.localIdentifier);
+        if (!counterpart) {
+            return undefined;
+        }
+        const localIdentifier = counterpart.dashboardMeasureValueFilter.localIdentifier;
+        if (!payload.restoreTargetOriginal) {
+            return { ...payload, localIdentifier };
+        }
+        const original = findOriginalFilter(target, counterpart);
+        return isDashboardMeasureValueFilter(original)
+            ? {
+                ...payload,
+                localIdentifier,
+                dimensionality: original.dashboardMeasureValueFilter.dimensionality,
+            }
+            : undefined;
+    }),
+    defineRule(tabsActions.setParameterRuntimeValues, (payload, target) => {
+        const values = payload.values.filter((value) => target.parameters?.parameters.some((entry) => areObjRefsEqual(entry.parameter.ref, value.ref)));
+        return values.length > 0 ? { ...payload, values } : undefined;
+    }),
+    // Other tabs receive the committed values of the source tab, not their own staged values.
+    defineRule(tabsActions.applyWorkingSelection, (_payload, target, ctx) => {
+        const filters = committedFilterValues(ctx, target);
+        const parameters = committedParameterValues(ctx, target);
+        if (filters.length === 0 && parameters.length === 0) {
+            return undefined;
+        }
+        return { mirroredSelection: { filters, parameters } };
+    }),
+];
+/**
+ * Tabs slice actions that are mirrored to other tabs when filters persist across tabs, keyed by action type.
+ * Actions without a rule apply to their own tab only, which includes every filter configuration change.
+ *
+ * @internal
+ */
+export const tabSyncRules = new Map([
+    ...filterContextRules,
+    ...selectionRules,
+]);

package/esm/model/commandHandlers/filterContext/tabSync/tabSyncSaga.d.ts

@@ -0,0 +1,52 @@
+import { type Action } from "@reduxjs/toolkit";
+import { type SagaIterator } from "redux-saga";
+import { type IDashboardCommand } from "../../../commands/base.js";
+import { type DashboardContext } from "../../../types/commonTypes.js";
+import { type IFilterContextByTabSnapshot } from "../common.js";
+import { type ITabSyncScope } from "./tabSyncScope.js";
+/**
+ * State of tab sync for one command, from {@link beginTabSync} to {@link endTabSync}.
+ *
+ * @internal
+ */
+export interface ITabSyncSession {
+    readonly scope: ITabSyncScope;
+    /**
+     * Filter contexts of every tab before the command, taken only when sync is enabled.
+     */
+    readonly snapshot: IFilterContextByTabSnapshot | undefined;
+}
+/**
+ * @internal
+ */
+export interface IBeginTabSyncOptions {
+    /**
+     * Set to false to keep this command on its own tab even when filters persist across tabs.
+     */
+    readonly enabled?: boolean;
+    /**
+     * Tab the command is issued on. Defaults to the active tab.
+     */
+    readonly tabLocalIdentifier?: string;
+}
+/**
+ * Starts tab sync for a command. Call before reading the state that the command changes.
+ *
+ * @internal
+ */
+export declare function beginTabSync(options?: IBeginTabSyncOptions): SagaIterator<ITabSyncSession>;
+/**
+ * Dispatches `actions` together with their copies for the other tabs, as one batch.
+ *
+ * @returns every dispatched action, copies included
+ * @internal
+ */
+export declare function putTabSynced(session: ITabSyncSession, actions: readonly Action[]): SagaIterator<Action[]>;
+/**
+ * Emits a filter context changed event for the source tab, also when the command changed nothing,
+ * and when sync is enabled one more for every other tab the command changed.
+ *
+ * @internal
+ */
+export declare function endTabSync(ctx: DashboardContext, cmd: IDashboardCommand, session: ITabSyncSession, tabLocalIdentifier?: string): SagaIterator<void>;
+//# sourceMappingURL=tabSyncSaga.d.ts.map

package/esm/model/commandHandlers/filterContext/tabSync/tabSyncSaga.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabSyncSaga.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/filterContext/tabSync/tabSyncSaga.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAQnE,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EACH,KAAK,2BAA2B,EAInC,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC5B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,2BAA2B,GAAG,SAAS,CAAC;CAC9D;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC;;OAEG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;OAEG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACxC;AAED;;;;GAIG;AACH,wBAAiB,YAAY,CAAC,OAAO,GAAE,oBAAyB,GAAG,YAAY,CAAC,eAAe,CAAC,CA2B/F;AAED;;;;;GAKG;AACH,wBAAiB,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,CAQ1G;AAED;;;;;GAKG;AACH,wBAAiB,UAAU,CACvB,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,iBAAiB,EACtB,OAAO,EAAE,eAAe,EACxB,kBAAkB,CAAC,EAAE,MAAM,GAC5B,YAAY,CAAC,IAAI,CAAC,CAWpB"}