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

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

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

@@ -0,0 +1,60 @@
+// (C) 2026 GoodData Corporation
+import { batchActions } from "redux-batched-actions";
+import { call, put, select } from "redux-saga/effects";
+import { selectCrossFilteringFiltersLocalIdentifiersByTab } from "../../../store/drill/drillSelectors.js";
+import { selectEnablePersistentFiltersAcrossTabs, selectPersistedDashboardAttributeFilterConfigsByTab, } from "../../../store/meta/metaSelectors.js";
+import { selectActiveTabLocalIdentifier, selectTabsState } from "../../../store/tabs/tabsSelectors.js";
+import { captureFilterContextByTabSnapshot, dispatchFilterContextChanged, dispatchFilterContextChangedForMutatedTabs, } from "../common.js";
+import { expandActionsForTabSync } from "./expandActionsForTabSync.js";
+/**
+ * Starts tab sync for a command. Call before reading the state that the command changes.
+ *
+ * @internal
+ */
+export function* beginTabSync(options = {}) {
+    const enablePersistentFiltersAcrossTabs = yield select(selectEnablePersistentFiltersAcrossTabs);
+    const activeTabLocalIdentifier = yield select(selectActiveTabLocalIdentifier);
+    const enabled = !!enablePersistentFiltersAcrossTabs && (options.enabled ?? true);
+    const sourceTabLocalIdentifier = options.tabLocalIdentifier ?? activeTabLocalIdentifier;
+    const crossFilteringLocalIdsByTab = enabled ? yield select(selectCrossFilteringFiltersLocalIdentifiersByTab) : {};
+    const persistedAttributeFilterConfigsByTab = enabled ? yield select(selectPersistedDashboardAttributeFilterConfigsByTab) : {};
+    const snapshot = enabled
+        ? yield call(captureFilterContextByTabSnapshot)
+        : undefined;
+    return {
+        scope: {
+            enabled,
+            sourceTabLocalIdentifier,
+            crossFilteringLocalIdsByTab,
+            persistedAttributeFilterConfigsByTab,
+        },
+        snapshot,
+    };
+}
+/**
+ * Dispatches `actions` together with their copies for the other tabs, as one batch.
+ *
+ * @returns every dispatched action, copies included
+ * @internal
+ */
+export function* putTabSynced(session, actions) {
+    if (actions.length === 0) {
+        return [];
+    }
+    const tabsState = yield select(selectTabsState);
+    const expanded = expandActionsForTabSync(tabsState, actions, session.scope);
+    yield put(expanded.length === 1 ? expanded[0] : batchActions(expanded));
+    return expanded;
+}
+/**
+ * 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 function* endTabSync(ctx, cmd, session, tabLocalIdentifier) {
+    yield call(dispatchFilterContextChanged, ctx, cmd, tabLocalIdentifier);
+    if (session.snapshot) {
+        yield call(dispatchFilterContextChangedForMutatedTabs, ctx, cmd, session.snapshot, session.scope.sourceTabLocalIdentifier);
+    }
+}

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

@@ -0,0 +1,69 @@
+import { type PayloadAction } from "@reduxjs/toolkit";
+import { type IDashboardAttributeFilterConfig } from "@gooddata/sdk-model";
+import { type CrossFilteringLocalIdsByTab } from "../../../store/tabs/filterContext/filterSync.js";
+import { type ITabState, type ITabsState } from "../../../store/tabs/tabsState.js";
+/**
+ * Everything the tab sync planner needs to know about the command being handled.
+ * Built once per command by {@link beginTabSync}.
+ *
+ * @internal
+ */
+export interface ITabSyncScope {
+    /**
+     * False when filters are not persisted across tabs, or when the handler opts out
+     * for this command (e.g. cross-filtering virtual filters). Nothing is mirrored then.
+     */
+    readonly enabled: boolean;
+    /**
+     * Tab the command was issued on. Synced actions without `tabLocalIdentifier` in their payload
+     * are addressed to this tab; the active tab is used when undefined.
+     */
+    readonly sourceTabLocalIdentifier: string | undefined;
+    /**
+     * Cross-filtering virtual filters, which are never mirrored to or from other tabs.
+     */
+    readonly crossFilteringLocalIdsByTab: CrossFilteringLocalIdsByTab;
+    /**
+     * Attribute filter configs of the saved dashboard keyed by tab local identifier. A tab that is
+     * missing has no saved configs, so a reset leaves its display-as labels unchanged.
+     */
+    readonly persistedAttributeFilterConfigsByTab?: Readonly<Record<string, readonly IDashboardAttributeFilterConfig[]>>;
+}
+/**
+ * Input of a single tab sync rule.
+ *
+ * @internal
+ */
+export interface ITabSyncRuleContext {
+    readonly scope: ITabSyncScope;
+    /**
+     * Tabs state before the source action is applied. Mirrored actions of previous
+     * actions in the same batch are already applied.
+     */
+    readonly state: ITabsState;
+    /**
+     * Source tab before the source action is applied.
+     */
+    readonly source: ITabState;
+    /**
+     * Source tab after the source action is applied.
+     */
+    readonly sourceAfter: ITabState;
+}
+/**
+ * Translates the payload of an action applied on the source tab into the payload
+ * of the same action for `target`. Returns undefined when `target` is left untouched.
+ * The planner sets `tabLocalIdentifier` of the returned payload.
+ *
+ * @internal
+ */
+export type TabSyncRule<P> = (payload: P, target: ITabState, ctx: ITabSyncRuleContext) => P | undefined;
+/**
+ * Translates the payload of an action applied on the source tab into the actions that apply it
+ * to `target`. Returns an empty array when `target` is left untouched.
+ * The planner sets `tabLocalIdentifier` of every returned payload.
+ *
+ * @internal
+ */
+export type TabSyncActionsRule<P> = (payload: P, target: ITabState, ctx: ITabSyncRuleContext) => PayloadAction<object>[];
+//# sourceMappingURL=tabSyncScope.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tabSyncScope.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/filterContext/tabSync/tabSyncScope.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,qBAAqB,CAAC;AAE3E,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,iDAAiD,CAAC;AACnG,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAEnF;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC1B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,wBAAwB,EAAE,MAAM,GAAG,SAAS,CAAC;IACtD;;OAEG;IACH,QAAQ,CAAC,2BAA2B,EAAE,2BAA2B,CAAC;IAClE;;;OAGG;IACH,QAAQ,CAAC,oCAAoC,CAAC,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,+BAA+B,EAAE,CAAC,CAC7D,CAAC;CACL;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAChC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC;CACnC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,mBAAmB,KAAK,CAAC,GAAG,SAAS,CAAC;AAExG;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,CAChC,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,SAAS,EACjB,GAAG,EAAE,mBAAmB,KACvB,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC"}

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

@@ -0,0 +1,2 @@
+// (C) 2026 GoodData Corporation
+export {};

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

@@ -0,0 +1,17 @@
+import { type Action } from "@reduxjs/toolkit";
+import { type IWrittenTabFilters } from "../../../store/tabs/filterContext/filterContextReducers.js";
+import { type IWrittenTabParameters } from "../../../store/tabs/parameters/parametersReducers.js";
+/**
+ * The applied filters that `actions` write, per tab. Staged selection changes are not applied, so they
+ * are skipped.
+ *
+ * @internal
+ */
+export declare function writtenFiltersOf(actions: readonly Action[]): IWrittenTabFilters[];
+/**
+ * The parameters that `actions` write, per tab.
+ *
+ * @internal
+ */
+export declare function writtenParametersOf(actions: readonly Action[]): IWrittenTabParameters[];
+//# sourceMappingURL=writtenTargets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writtenTargets.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/filterContext/tabSync/writtenTargets.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAK/C,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,4DAA4D,CAAC;AAErG,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAMlG;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,kBAAkB,EAAE,CA8CjF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,qBAAqB,EAAE,CAgBvF"}

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

@@ -0,0 +1,79 @@
+// (C) 2026 GoodData Corporation
+import { BATCH } from "redux-batched-actions";
+import { areObjRefsEqual } from "@gooddata/sdk-model";
+import { tabsActions } from "../../../store/tabs/index.js";
+/**
+ * The applied filters that `actions` write, per tab. Staged selection changes are not applied, so they
+ * are skipped.
+ *
+ * @internal
+ */
+export function writtenFiltersOf(actions) {
+    const byTab = new Map();
+    const forTab = (tabLocalIdentifier) => {
+        let written = byTab.get(tabLocalIdentifier);
+        if (!written) {
+            written = { tabLocalIdentifier, filterLocalIds: [], dateDataSets: [], commonDateFilter: false };
+            byTab.set(tabLocalIdentifier, written);
+        }
+        return written;
+    };
+    const addFilters = (tabLocalIdentifier, localIdentifiers) => {
+        const written = forTab(tabLocalIdentifier);
+        written.filterLocalIds = [...new Set([...written.filterLocalIds, ...localIdentifiers])];
+    };
+    for (const action of actions.flatMap(unbatched)) {
+        if (tabsActions.updateAttributeFilterSelection.match(action) ||
+            tabsActions.replaceAttributeFilterItem.match(action) ||
+            tabsActions.changeAttributeDisplayForm.match(action)) {
+            if (!action.payload.isWorkingSelectionChange) {
+                addFilters(action.payload.tabLocalIdentifier, [action.payload.filterLocalId]);
+            }
+        }
+        else if (tabsActions.clearAttributeFiltersSelection.match(action)) {
+            addFilters(action.payload.tabLocalIdentifier, action.payload.filterLocalIds);
+        }
+        else if (tabsActions.changeMeasureValueFilterCondition.match(action) ||
+            tabsActions.setMeasureValueFilterDimensionality.match(action)) {
+            if (!("isWorkingSelectionChange" in action.payload && action.payload.isWorkingSelectionChange)) {
+                addFilters(action.payload.tabLocalIdentifier, [action.payload.localIdentifier]);
+            }
+        }
+        else if (tabsActions.upsertDateFilter.match(action) && !action.payload.isWorkingSelectionChange) {
+            const written = forTab(action.payload.tabLocalIdentifier);
+            const { dataSet } = action.payload;
+            if (!dataSet) {
+                written.commonDateFilter = true;
+            }
+            else if (!written.dateDataSets.some((writtenDataSet) => areObjRefsEqual(writtenDataSet, dataSet))) {
+                written.dateDataSets = [...written.dateDataSets, dataSet];
+            }
+        }
+    }
+    return [...byTab.values()];
+}
+/**
+ * The parameters that `actions` write, per tab.
+ *
+ * @internal
+ */
+export function writtenParametersOf(actions) {
+    const byTab = new Map();
+    for (const action of actions.flatMap(unbatched)) {
+        if (!tabsActions.setParameterRuntimeValues.match(action)) {
+            continue;
+        }
+        const { tabLocalIdentifier, values } = action.payload;
+        const refs = byTab.get(tabLocalIdentifier) ?? [];
+        for (const { ref } of values) {
+            if (!refs.some((writtenRef) => areObjRefsEqual(writtenRef, ref))) {
+                refs.push(ref);
+            }
+        }
+        byTab.set(tabLocalIdentifier, refs);
+    }
+    return [...byTab.entries()].map(([tabLocalIdentifier, refs]) => ({ tabLocalIdentifier, refs }));
+}
+function unbatched(action) {
+    return action.type === BATCH ? action.payload.flatMap(unbatched) : [action];
+}

package/esm/model/commandHandlers/parameters/changeParameterValuesHandler.d.ts

@@ -5,7 +5,8 @@ import { type IChangeParameterValues } from "../../commands/parameters.js";
 import { type DashboardContext } from "../../types/commonTypes.js";
 /**
  * Parameters not present on a written tab are ignored by the reducer. When persistent filters
- * across tabs are on, the same values are written to every tab. A change event is emitted for
+ * across tabs are on, the same values are written to every tab, or with `restorePerTabOriginals`
+ * every other tab resets them to its own reset values. A change event is emitted for
  * each tab whose applied values differ from the snapshot, source tab first.
  *
  * @internal

package/esm/model/commandHandlers/parameters/changeParameterValuesHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"changeParameterValuesHandler.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/parameters/changeParameterValuesHandler.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAElE,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAQ3E,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE;;;;;;GAMG;AACH,wBAAiB,4BAA4B,CACzC,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,sBAAsB,GAC5B,YAAY,CAAC,IAAI,CAAC,CAsBpB;AAED;;;;;GAKG;AACH,wBAAiB,wCAAwC,CACrD,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,iBAAiB,EACtB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,EAAE,GAAG,SAAS,CAAC,EAClE,WAAW,EAAE,MAAM,GACpB,YAAY,CAAC,IAAI,CAAC,CAOpB;AAED;;;;;GAKG;AACH,wBAAiB,yBAAyB,CACtC,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,iBAAiB,EACtB,kBAAkB,EAAE,MAAM,EAC1B,YAAY,EAAE,sBAAsB,EAAE,GAAG,SAAS,GACnD,YAAY,CAAC,IAAI,CAAC,CASpB"}
+{"version":3,"file":"changeParameterValuesHandler.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/parameters/changeParameterValuesHandler.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAE,KAAK,sBAAsB,EAAmB,MAAM,qBAAqB,CAAC;AAEnF,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAY3E,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAInE;;;;;;;GAOG;AACH,wBAAiB,4BAA4B,CACzC,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,sBAAsB,GAC5B,YAAY,CAAC,IAAI,CAAC,CA2BpB;AAoCD;;;;;GAKG;AACH,wBAAiB,wCAAwC,CACrD,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,iBAAiB,EACtB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,EAAE,GAAG,SAAS,CAAC,EAClE,WAAW,EAAE,MAAM,GACpB,YAAY,CAAC,IAAI,CAAC,CAOpB;AAED;;;;;GAKG;AACH,wBAAiB,yBAAyB,CACtC,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,iBAAiB,EACtB,kBAAkB,EAAE,MAAM,EAC1B,YAAY,EAAE,sBAAsB,EAAE,GAAG,SAAS,GACnD,YAAY,CAAC,IAAI,CAAC,CASpB"}