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

package/esm/model/commandHandlers/filterContext/changeFilterContextSelectionHandler.js

@@ -3,53 +3,100 @@ import { compact, partition, uniqBy } from "lodash-es";
 import { batchActions } from "redux-batched-actions";
 import { all, call, put, select } from "redux-saga/effects";
 import { NotSupported } from "@gooddata/sdk-backend-spi";
-import { areObjRefsEqual, attributeElementsIsEmpty, dashboardAttributeFilterItemDisplayForm, dashboardAttributeFilterItemFilterElementsBy, dashboardAttributeFilterItemFilterElementsByDate, dashboardAttributeFilterItemLocalIdentifier, dashboardAttributeFilterItemValidateElementsBy, dashboardFilterObjRef, dashboardMeasureValueFilterLocalIdentifier, getAttributeElementsItems, isAllTimeDashboardDateFilter, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardMeasureValueFilter, isDashboardTextAttributeFilter, isSingleSelectionFilter, isUriRef, objRefToString, serializeObjRef, updateAttributeElementsItems, } from "@gooddata/sdk-model";
+import { areObjRefsEqual, attributeElementsIsEmpty, dashboardAttributeFilterItemDisplayForm, dashboardAttributeFilterItemFilterElementsBy, dashboardAttributeFilterItemFilterElementsByDate, dashboardAttributeFilterItemLocalIdentifier, dashboardAttributeFilterItemValidateElementsBy, dashboardFilterLocalIdentifier, dashboardFilterObjRef, dashboardMeasureValueFilterLocalIdentifier, getAttributeElementsItems, isAllTimeDashboardDateFilter, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardMeasureValueFilter, isDashboardTextAttributeFilter, isSingleSelectionFilter, isUriRef, objRefToString, serializeObjRef, updateAttributeElementsItems, } from "@gooddata/sdk-model";
 import { dashboardFilterToFilterContextItem } from "../../../_staging/dashboard/dashboardFilterContext.js";
 import { invalidArgumentsProvided } from "../../events/general.js";
 import { dispatchDashboardEvent } from "../../store/_infra/eventDispatcher.js";
-import { isDashboardFilterRestricted } from "../../store/filtering/restrictedFilterUtils.js";
+import { selectCrossFilteringFiltersLocalIdentifiersByTab } from "../../store/drill/drillSelectors.js";
+import { selectRestrictedDashboardFilterLocalIdentifiers, selectRestrictedDashboardFilterLocalIdentifiersForTab, } from "../../store/filtering/dashboardFilterSelectors.js";
+import { isDashboardFilterUsingRestrictedObject } from "../../store/filtering/restrictedFilterUtils.js";
+import { selectEnablePersistentFiltersAcrossTabs } from "../../store/meta/metaSelectors.js";
 import { selectAttributeFilterConfigsOverrides, selectAttributeFilterConfigsOverridesByTab, selectAttributeFilterConfigsSelectionTypeMap, selectAttributeFilterConfigsSelectionTypeMapByTab, } from "../../store/tabs/attributeFilterConfigs/attributeFilterConfigsSelectors.js";
-import { selectAttributeFilterDisplayFormsMap, selectFilterContextAttributeFilterByDisplayForm, selectFilterContextAttributeFilterByDisplayFormForTab, selectFilterContextAttributeFilterByLocalId, selectFilterContextAttributeFilterByLocalIdForTab, selectFilterContextAttributeFilterItemByDisplayForm, selectFilterContextAttributeFilterItemByDisplayFormForTab, selectFilterContextAttributeFilterItemByLocalId, selectFilterContextAttributeFilterItemByLocalIdForTab, selectFilterContextAttributeFilterItems, selectFilterContextAttributeFilterItemsForTab, selectFilterContextAttributeFilters, selectFilterContextAttributeFiltersForTab, selectFilterContextDateFilterByDataSet, selectFilterContextDateFilterByDataSetForTab, selectFilterContextDateFiltersWithDimension, selectFilterContextDateFiltersWithDimensionForTab, selectFilterContextMeasureValueFilters, } from "../../store/tabs/filterContext/filterContextSelectors.js";
+import { isDisplayFormRefOf, selectAttributeFilterDisplayFormsMap, selectFilterContextAttributeFilterItems, selectFilterContextAttributeFilterItemsForTab, selectFilterContextDateFilterByDataSet, selectFilterContextDateFilterByDataSetForTab, selectFilterContextDateFiltersWithDimension, selectFilterContextDateFiltersWithDimensionForTab, selectFilterContextFilters, selectFilterContextMeasureValueFilters, selectFiltersForTab, } from "../../store/tabs/filterContext/filterContextSelectors.js";
 import { tabsActions } from "../../store/tabs/index.js";
 import { selectTabs } from "../../store/tabs/tabsSelectors.js";
 import { selectUnavailableObjects } from "../../store/unavailableObjects/unavailableObjectsSelectors.js";
+import { canApplyFilterTypeToTarget } from "../../utils/attributeFilterSelectionTypeCompatibility.js";
 import { resolveAttributeMetadata } from "../../utils/attributeResolver.js";
 import { resolveDisplayFormMetadata, } from "../../utils/displayFormResolver.js";
-import { canApplyFilterTypeToTarget } from "../dashboard/common/attributeFilterSelectionTypeCompatibility.js";
 import { resolveAndRegisterDisplayFormMetadata } from "./attributeFilter/resolveDisplayFormMetadata.js";
 import { computedAttributesDisabledMessage, findDisabledComputedAttributeRef, } from "./attributeFilter/validation/computedAttributesEnabledValidation.js";
-import { canApplyDateFilter, dispatchFilterContextChanged } from "./common.js";
+import { canApplyDateFilter, captureFilterContextByTabSnapshot, dispatchFilterContextChanged, dispatchFilterContextChangedForMutatedTabs, } from "./common.js";
+function classifyRestore(type, restoresOriginal) {
+    // A computed key is not inferred as a single-property mapped type.
+    return { [type]: restoresOriginal };
+}
+const RESTORE_TARGET_ORIGINAL = {
+    ...classifyRestore(tabsActions.updateAttributeFilterSelection.type, true),
+    ...classifyRestore(tabsActions.replaceAttributeFilterItem.type, true),
+    ...classifyRestore(tabsActions.clearAttributeFiltersSelection.type, true),
+    ...classifyRestore(tabsActions.upsertDateFilter.type, true),
+    ...classifyRestore(tabsActions.changeMeasureValueFilterCondition.type, true),
+    ...classifyRestore(tabsActions.setMeasureValueFilterDimensionality.type, true),
+    ...classifyRestore(tabsActions.addAttributeFilterDisplayForm.type, false),
+    ...classifyRestore(tabsActions.changeAttributeDisplayForm.type, false),
+    ...classifyRestore(tabsActions.changeDisplayAsLabel.type, false),
+};
+/**
+ * Reset persists one payload (the active tab's saved values). Mark the value-writing actions so
+ * other tabs restore their own originals instead of receiving that payload.
+ */
+function markRestoreTargetOriginal(actions, enabled) {
+    if (!enabled) {
+        return actions;
+    }
+    for (const action of actions) {
+        if (RESTORE_TARGET_ORIGINAL[action.type]) {
+            action.payload.restoreTargetOriginal = true;
+        }
+    }
+    return actions;
+}
 // Tab-aware select helpers — encapsulate the "if tab select ForTab else select" pattern.
 // Named after the base selector they wrap.
-function* selectFilterContextAttributeFilterByDisplayFormTabAware(displayForm, tabLocalIdentifier) {
+//
+// The attribute filter helpers see readable filters only. A restricted filter keeps its stored selection,
+// so matching passes it over to a readable filter with the same label and resetOthers leaves it alone;
+// an entry that addresses it exactly is dropped before matching.
+function* selectRestrictedDashboardFilterLocalIdentifiersTabAware(tabLocalIdentifier) {
     return tabLocalIdentifier
-        ? yield select(selectFilterContextAttributeFilterByDisplayFormForTab(displayForm, tabLocalIdentifier))
-        : yield select(selectFilterContextAttributeFilterByDisplayForm(displayForm));
+        ? yield select(selectRestrictedDashboardFilterLocalIdentifiersForTab(tabLocalIdentifier))
+        : yield select(selectRestrictedDashboardFilterLocalIdentifiers);
 }
-function* selectFilterContextAttributeFilterItemByLocalIdTabAware(localId, tabLocalIdentifier) {
-    return tabLocalIdentifier
-        ? yield select(selectFilterContextAttributeFilterItemByLocalIdForTab(localId, tabLocalIdentifier))
-        : yield select(selectFilterContextAttributeFilterItemByLocalId(localId));
+function* selectFilterContextAttributeFilterItemsTabAware(tabLocalIdentifier) {
+    const items = tabLocalIdentifier
+        ? yield select(selectFilterContextAttributeFilterItemsForTab(tabLocalIdentifier))
+        : yield select(selectFilterContextAttributeFilterItems);
+    const restrictedLocalIdentifiers = yield call(selectRestrictedDashboardFilterLocalIdentifiersTabAware, tabLocalIdentifier);
+    return items.filter((item) => !restrictedLocalIdentifiers.has(dashboardAttributeFilterItemLocalIdentifier(item) ?? ""));
 }
-function* selectFilterContextAttributeFilterItemByDisplayFormTabAware(displayForm, tabLocalIdentifier) {
-    return tabLocalIdentifier
-        ? yield select(selectFilterContextAttributeFilterItemByDisplayFormForTab(displayForm, tabLocalIdentifier))
-        : yield select(selectFilterContextAttributeFilterItemByDisplayForm(displayForm));
+function* selectFilterContextAttributeFiltersTabAware(tabLocalIdentifier) {
+    const items = yield call(selectFilterContextAttributeFilterItemsTabAware, tabLocalIdentifier);
+    return items.filter(isDashboardAttributeFilter);
+}
+function* selectFilterContextAttributeFilterItemByLocalIdTabAware(localId, tabLocalIdentifier) {
+    const items = yield call(selectFilterContextAttributeFilterItemsTabAware, tabLocalIdentifier);
+    return items.find((item) => dashboardAttributeFilterItemLocalIdentifier(item) === localId);
 }
 function* selectFilterContextAttributeFilterByLocalIdTabAware(localId, tabLocalIdentifier) {
-    return tabLocalIdentifier
-        ? yield select(selectFilterContextAttributeFilterByLocalIdForTab(localId, tabLocalIdentifier))
-        : yield select(selectFilterContextAttributeFilterByLocalId(localId));
+    const filters = yield call(selectFilterContextAttributeFiltersTabAware, tabLocalIdentifier);
+    return filters.find((filter) => filter.attributeFilter.localIdentifier === localId);
 }
-function* selectFilterContextAttributeFiltersTabAware(tabLocalIdentifier) {
-    return tabLocalIdentifier
-        ? yield select(selectFilterContextAttributeFiltersForTab(tabLocalIdentifier))
-        : yield select(selectFilterContextAttributeFilters);
+function* selectFilterContextAttributeFilterItemByDisplayFormTabAware(displayForm, tabLocalIdentifier) {
+    const items = yield call(selectFilterContextAttributeFilterItemsTabAware, tabLocalIdentifier);
+    const displayFormsMap = yield select(selectAttributeFilterDisplayFormsMap);
+    const df = displayFormsMap.get(displayForm);
+    return df
+        ? items.find((item) => isDisplayFormRefOf(dashboardAttributeFilterItemDisplayForm(item), df))
+        : undefined;
 }
-function* selectFilterContextAttributeFilterItemsTabAware(tabLocalIdentifier) {
-    return tabLocalIdentifier
-        ? yield select(selectFilterContextAttributeFilterItemsForTab(tabLocalIdentifier))
-        : yield select(selectFilterContextAttributeFilterItems);
+function* selectFilterContextAttributeFilterByDisplayFormTabAware(displayForm, tabLocalIdentifier) {
+    const filters = yield call(selectFilterContextAttributeFiltersTabAware, tabLocalIdentifier);
+    const displayFormsMap = yield select(selectAttributeFilterDisplayFormsMap);
+    const df = displayFormsMap.get(displayForm);
+    return df
+        ? filters.find((filter) => isDisplayFormRefOf(filter.attributeFilter.displayForm, df))
+        : undefined;
 }
 function* selectFilterContextDateFilterByDataSetTabAware(dataSet, tabLocalIdentifier) {
     return tabLocalIdentifier
@@ -69,7 +116,7 @@ function* selectAttributeFilterConfigsSelectionTypeMapTabAware(tabLocalIdentifie
     return yield select(selectAttributeFilterConfigsSelectionTypeMap);
 }
 export function* changeFilterContextSelectionHandler(ctx, cmd) {
-    const { filters, resetOthers, attributeFilterConfigs = [], tabLocalIdentifier, matchByLocalIdentifier = false, } = cmd.payload;
+    const { filters, resetOthers, attributeFilterConfigs = [], tabLocalIdentifier, matchByLocalIdentifier = false, restorePerTabOriginals = false, } = cmd.payload;
     // Validate that the target tab exists if tabLocalIdentifier is provided
     if (tabLocalIdentifier) {
         const tabs = yield select(selectTabs);
@@ -82,8 +129,32 @@ export function* changeFilterContextSelectionHandler(ctx, cmd) {
     // Cross-filtering is always compatible with dashboard tabs now
     // (removed the check that prevented cross-filtering without tabs)
     const unavailableObjects = yield select(selectUnavailableObjects);
-    // A restricted attribute filter keeps its stored selection: its label is never resolved, so the
-    // filter can be neither matched nor changed.
+    // A restricted filter keeps its stored selection. An entry that uses a restricted object is dropped:
+    // a restricted label is never resolved, and a restricted "For attribute" would restrict the measure
+    // value filter it is applied to. With matchByLocalIdentifier, an entry that addresses a restricted
+    // filter exactly is dropped too; a list entry addresses a filter exactly only with an equivalent
+    // display form, as its element values are valid for one display form only.
+    const restrictedLocalIdentifiers = yield call(selectRestrictedDashboardFilterLocalIdentifiersTabAware, tabLocalIdentifier);
+    const tabFilters = tabLocalIdentifier
+        ? yield select(selectFiltersForTab(tabLocalIdentifier))
+        : yield select(selectFilterContextFilters);
+    const displayFormsMap = yield select(selectAttributeFilterDisplayFormsMap);
+    const addressesRestrictedFilter = (entry) => {
+        const localIdentifier = dashboardFilterLocalIdentifier(entry);
+        const target = localIdentifier && restrictedLocalIdentifiers.has(localIdentifier)
+            ? tabFilters.find((filter) => dashboardFilterLocalIdentifier(filter) === localIdentifier)
+            : undefined;
+        if (isDashboardAttributeFilter(entry)) {
+            const df = displayFormsMap.get(entry.attributeFilter.displayForm);
+            return (!!df &&
+                isDashboardAttributeFilter(target) &&
+                isDisplayFormRefOf(target.attributeFilter.displayForm, df));
+        }
+        if (isDashboardAttributeFilterItem(entry)) {
+            return isDashboardAttributeFilterItem(target);
+        }
+        return isDashboardMeasureValueFilter(entry) && isDashboardMeasureValueFilter(target);
+    };
     const normalizedFilters = compact(filters.map((filter) => {
         if (isDashboardAttributeFilterItem(filter) ||
             isDashboardDateFilter(filter) ||
@@ -91,8 +162,8 @@ export function* changeFilterContextSelectionHandler(ctx, cmd) {
             return filter;
         }
         return dashboardFilterToFilterContextItem(filter, !!ctx.backend.capabilities.supportsMultipleDateFilters);
-    })).filter((filter) => !(isDashboardAttributeFilterItem(filter) &&
-        isDashboardFilterRestricted(filter, unavailableObjects)));
+    })).filter((filter) => !((isDashboardAttributeFilterItem(filter) || isDashboardMeasureValueFilter(filter)) &&
+        isDashboardFilterUsingRestrictedObject(filter, unavailableObjects)) && !(matchByLocalIdentifier && addressesRestrictedFilter(filter)));
     const disabledComputedAttributeRef = yield call(findDisabledComputedAttributeRef, [
         ...normalizedFilters
             .filter(isDashboardAttributeFilterItem)
@@ -140,11 +211,13 @@ export function* changeFilterContextSelectionHandler(ctx, cmd) {
     const [[commonDateFilter], dateFiltersWithDimension] = partition(dateFilters, isDashboardCommonDateFilter);
     const selectionTypeMap = yield call(selectAttributeFilterConfigsSelectionTypeMapTabAware, tabLocalIdentifier);
     const [attributeFilterResult, commonDateFilterUpdateActions, dateFiltersUpdateActions, measureValueFilterUpdateActions,] = yield all([
-        call(getAttributeFiltersUpdateActions, [...attributeFilters].reverse(), textAttributeFilters, attributeFilterConfigs, resetOthers, unavailableObjects, ctx, tabLocalIdentifier, selectionTypeMap, matchByLocalIdentifier),
+        call(getAttributeFiltersUpdateActions, [...attributeFilters].reverse(), textAttributeFilters, attributeFilterConfigs, resetOthers, ctx, tabLocalIdentifier, selectionTypeMap, matchByLocalIdentifier),
         call(getDateFilterUpdateActions, commonDateFilter, resetOthers, tabLocalIdentifier),
         call(getDateFiltersUpdateActions, dateFiltersWithDimension, resetOthers, tabLocalIdentifier),
         call(getMeasureValueFiltersUpdateActions, measureValueFilters, resetOthers),
     ]);
+    const enablePersistentFiltersAcrossTabs = yield select(selectEnablePersistentFiltersAcrossTabs);
+    const filterContextSnapshot = yield call(captureFilterContextByTabSnapshot);
     // Ensure display form metadata is loaded for filters that will actually be applied.
     // This handles the case where a default saved view changed filter types (e.g., list→text)
     // and then local storage restores original types whose display forms weren't loaded during init.
@@ -156,13 +229,18 @@ export function* changeFilterContextSelectionHandler(ctx, cmd) {
             }
         }
     }
-    yield put(batchActions([
+    yield put(batchActions(markRestoreTargetOriginal([
         ...attributeFilterResult.actions,
         ...commonDateFilterUpdateActions,
         ...dateFiltersUpdateActions,
         ...measureValueFilterUpdateActions,
-    ]));
-    yield call(dispatchFilterContextChanged, ctx, cmd, tabLocalIdentifier);
+    ], restorePerTabOriginals)));
+    if (enablePersistentFiltersAcrossTabs) {
+        yield call(dispatchFilterContextChangedForMutatedTabs, ctx, cmd, filterContextSnapshot);
+    }
+    else {
+        yield call(dispatchFilterContextChanged, ctx, cmd, tabLocalIdentifier);
+    }
 }
 function* getDashboardFilterByAttributeMatching(filterRef, resolvedDisplayForms, ctx, tabLocalIdentifier, isFilterExcluded, areDisplayFormsEquivalent = areObjRefsEqual) {
     if (isUriRef(filterRef) && !ctx.backend.capabilities.supportsObjectUris) {
@@ -203,11 +281,15 @@ function* getDashboardFilterByDisplayAsLabelMatching(attributeFilter, attributeF
         const dashboardFiltersConfigs = tabLocalIdentifier
             ? dashboardFiltersConfigsByTab[tabLocalIdentifier]
             : dashboardFiltersConfigsForActiveTab;
-        const matchingDashboardFilterConfig = dashboardFiltersConfigs.find((config) => areObjRefsEqual(config.displayAsLabel, filterRef));
-        if (matchingDashboardFilterConfig) {
-            dashboardFilter = yield call(selectFilterContextAttributeFilterByLocalIdTabAware, matchingDashboardFilterConfig?.localIdentifier, tabLocalIdentifier);
-            foundByDashboardFilterDisplayAsLabel = !!dashboardFilter;
+        // the config of a restricted filter may come first, its filter is not found
+        const matchingDashboardFilterConfigs = dashboardFiltersConfigs.filter((config) => areObjRefsEqual(config.displayAsLabel, filterRef));
+        for (const config of matchingDashboardFilterConfigs) {
+            dashboardFilter = yield call(selectFilterContextAttributeFilterByLocalIdTabAware, config.localIdentifier, tabLocalIdentifier);
+            if (dashboardFilter) {
+                break;
+            }
         }
+        foundByDashboardFilterDisplayAsLabel = !!dashboardFilter;
     }
     return { foundByDisplayAsLabel, foundByDashboardFilterDisplayAsLabel, dashboardFilter };
 }
@@ -229,17 +311,24 @@ function* findTargetFilterItemByDisplayForm(displayFormRef, tabLocalIdentifier)
     const dashboardFiltersConfigs = tabLocalIdentifier
         ? dashboardFiltersConfigsByTab[tabLocalIdentifier]
         : dashboardFiltersConfigsForActiveTab;
-    const matchingConfig = dashboardFiltersConfigs?.find((config) => areObjRefsEqual(config.displayAsLabel, displayFormRef));
-    if (matchingConfig) {
-        return yield call(selectFilterContextAttributeFilterItemByLocalIdTabAware, matchingConfig.localIdentifier, tabLocalIdentifier);
+    // the config of a restricted filter may come first, its filter is not found
+    const matchingConfigs = dashboardFiltersConfigs?.filter((config) => areObjRefsEqual(config.displayAsLabel, displayFormRef)) ??
+        [];
+    for (const config of matchingConfigs) {
+        const target = yield call(selectFilterContextAttributeFilterItemByLocalIdTabAware, config.localIdentifier, tabLocalIdentifier);
+        if (target) {
+            return target;
+        }
     }
     return undefined;
 }
-function* getAttributeFiltersUpdateActions(attributeFilters, textAttributeFilters, attributeFilterConfigs, resetOthers, unavailableObjects, ctx, tabLocalIdentifier, selectionTypeMap, matchByLocalIdentifier) {
+function* getAttributeFiltersUpdateActions(attributeFilters, textAttributeFilters, attributeFilterConfigs, resetOthers, ctx, tabLocalIdentifier, selectionTypeMap, matchByLocalIdentifier) {
     const updateActions = [];
     const displayFormsToResolve = [];
     const handledLocalIds = new Set();
+    const crossFilteringLocalIdsByTab = yield select(selectCrossFilteringFiltersLocalIdentifiersByTab);
     const resolvedDisplayForms = yield call(resolveDisplayFormMetadata, ctx, attributeFilters.map((af) => dashboardAttributeFilterItemDisplayForm(af)));
+    const enablePersistentFiltersAcrossTabs = yield select(selectEnablePersistentFiltersAcrossTabs);
     // A payload can give a display form as a URI ref, and the dashboard can store it as an
     // identifier ref. The two refs are equal when they point to the same display form metadata.
     const displayFormsMap = yield select(selectAttributeFilterDisplayFormsMap);
@@ -394,6 +483,8 @@ function* getAttributeFiltersUpdateActions(attributeFilters, textAttributeFilter
             updateActions.push(tabsActions.updateAttributeFilterSelection({
                 ...getAttributeFilterSelectionPayload(attributeFilter, dashboardFilter),
                 tabLocalIdentifier,
+                crossFilteringLocalIdsByTab,
+                enablePersistentFiltersAcrossTabs,
             }));
             handledLocalIds.add(dashboardFilterLocalId);
         }
@@ -431,20 +522,15 @@ function* getAttributeFiltersUpdateActions(attributeFilters, textAttributeFilter
                 if (canApplyFilterTypeToTarget("list", configSelectionType, targetTextFilter)) {
                     // Text → list: set displayAsLabel to the text filter's displayForm
                     // so the list filter visually shows the same label.
-                    // Normalize: use target's localIdentifier so attributeFilterConfigs
-                    // (keyed by localId) keep matching, and strip selectionMode so the
-                    // target's own config determines single/multi presentation.
-                    const normalizedListFilter = {
-                        attributeFilter: {
-                            ...attributeFilter.attributeFilter,
-                            localIdentifier: targetLocalId,
-                            selectionMode: undefined,
-                        },
-                    };
+                    // Strip selectionMode so the target's own config determines single/multi
+                    // presentation.
+                    const normalizedListFilter = fitReplacementToTarget({ attributeFilter: { ...attributeFilter.attributeFilter, selectionMode: undefined } }, targetTextFilter);
                     updateActions.push(tabsActions.replaceAttributeFilterItem({
                         filterLocalId: targetLocalId,
                         filter: normalizedListFilter,
                         tabLocalIdentifier,
+                        crossFilteringLocalIdsByTab,
+                        enablePersistentFiltersAcrossTabs,
                     }), tabsActions.changeDisplayAsLabel({
                         localIdentifier: targetLocalId,
                         displayAsLabel: dashboardAttributeFilterItemDisplayForm(targetTextFilter),
@@ -497,13 +583,13 @@ function* getAttributeFiltersUpdateActions(attributeFilters, textAttributeFilter
                 continue;
             }
         }
-        // Normalize: use target's localIdentifier so attributeFilterConfigs
-        // (keyed by localId) keep matching after the replacement.
-        const normalizedTextFilter = normalizeFilterLocalIdentifier(textFilter, targetLocalId);
+        const normalizedTextFilter = fitReplacementToTarget(textFilter, existingFilter);
         updateActions.push(tabsActions.replaceAttributeFilterItem({
             filterLocalId: targetLocalId,
             filter: normalizedTextFilter,
             tabLocalIdentifier,
+            crossFilteringLocalIdsByTab,
+            enablePersistentFiltersAcrossTabs,
         }));
         const textDisplayForm = dashboardAttributeFilterItemDisplayForm(textFilter);
         // List → text: update displayAsLabel to match the text filter's displayForm
@@ -522,20 +608,20 @@ function* getAttributeFiltersUpdateActions(attributeFilters, textAttributeFilter
     if (resetOthers) {
         const currentAttributeFilters = yield call(selectFilterContextAttributeFiltersTabAware, tabLocalIdentifier);
         // for element-based filters that have not been handled, create clear selection actions
-        const unhandledFilters = currentAttributeFilters.filter((filter) => !handledLocalIds.has(dashboardAttributeFilterItemLocalIdentifier(filter)) &&
-            !isDashboardFilterRestricted(filter, unavailableObjects));
+        const unhandledFilters = currentAttributeFilters.filter((filter) => !handledLocalIds.has(dashboardAttributeFilterItemLocalIdentifier(filter)));
         if (unhandledFilters.length > 0) {
             updateActions.push(tabsActions.clearAttributeFiltersSelection({
                 filterLocalIds: unhandledFilters.map((filter) => dashboardAttributeFilterItemLocalIdentifier(filter)),
                 tabLocalIdentifier,
+                crossFilteringLocalIdsByTab,
+                enablePersistentFiltersAcrossTabs,
             }));
         }
         // for text filters (arbitrary/match) that have not been handled, reset to All state
         // (negative arbitrary filter with empty selection)
         const currentAllFilterItems = yield call(selectFilterContextAttributeFilterItemsTabAware, tabLocalIdentifier);
         const unhandledTextFilters = currentAllFilterItems.filter((filter) => isDashboardTextAttributeFilter(filter) &&
-            !handledLocalIds.has(dashboardAttributeFilterItemLocalIdentifier(filter)) &&
-            !isDashboardFilterRestricted(filter, unavailableObjects));
+            !handledLocalIds.has(dashboardAttributeFilterItemLocalIdentifier(filter)));
         for (const textFilter of unhandledTextFilters) {
             const localId = dashboardAttributeFilterItemLocalIdentifier(textFilter);
             const resetFilter = {
@@ -553,12 +639,15 @@ function* getAttributeFiltersUpdateActions(attributeFilters, textAttributeFilter
                 filterLocalId: localId,
                 filter: resetFilter,
                 tabLocalIdentifier,
+                crossFilteringLocalIdsByTab,
+                enablePersistentFiltersAcrossTabs,
             }));
         }
     }
     return { actions: updateActions, displayFormsToResolve };
 }
 function* getDateFilterUpdateActions(dateFilter, resetOthers, tabLocalIdentifier) {
+    const enablePersistentFiltersAcrossTabs = yield select(selectEnablePersistentFiltersAcrossTabs);
     if (dateFilter) {
         const canApply = yield call(canApplyDateFilter, dateFilter);
         if (!canApply) {
@@ -577,6 +666,7 @@ function* getDateFilterUpdateActions(dateFilter, resetOthers, tabLocalIdentifier
                 ...localIdentifierObj,
                 ...emptyValueHandlingObj,
                 tabLocalIdentifier,
+                enablePersistentFiltersAcrossTabs,
             }
             : {
                 type: dateFilter.dateFilter.type,
@@ -590,19 +680,30 @@ function* getDateFilterUpdateActions(dateFilter, resetOthers, tabLocalIdentifier
                     : {}),
                 ...emptyValueHandlingObj,
                 tabLocalIdentifier,
+                enablePersistentFiltersAcrossTabs,
             };
         return [tabsActions.upsertDateFilter(upsertPayload)];
     }
     else if (resetOthers) {
-        return [tabsActions.upsertDateFilter({ type: "allTime", tabLocalIdentifier })];
+        return [
+            tabsActions.upsertDateFilter({
+                type: "allTime",
+                tabLocalIdentifier,
+                enablePersistentFiltersAcrossTabs,
+            }),
+        ];
     }
     return [];
 }
 function* getMeasureValueFiltersUpdateActions(measureValueFilters, resetOthers) {
     const updateActions = [];
     const handledLocalIds = new Set();
-    const currentMeasureValueFilters = yield select(selectFilterContextMeasureValueFilters);
+    // a restricted filter keeps its stored conditions: it is neither matched nor reset
+    const allMeasureValueFilters = yield select(selectFilterContextMeasureValueFilters);
+    const restrictedLocalIdentifiers = yield select(selectRestrictedDashboardFilterLocalIdentifiers);
+    const currentMeasureValueFilters = allMeasureValueFilters.filter((filter) => !restrictedLocalIdentifiers.has(dashboardMeasureValueFilterLocalIdentifier(filter)));
     const currentByLocalId = new Map(currentMeasureValueFilters.map((f) => [dashboardMeasureValueFilterLocalIdentifier(f), f]));
+    const enablePersistentFiltersAcrossTabs = yield select(selectEnablePersistentFiltersAcrossTabs);
     for (const incoming of measureValueFilters) {
         const incomingLocalIdentifier = dashboardMeasureValueFilterLocalIdentifier(incoming);
         const currentFilter = currentByLocalId.get(incomingLocalIdentifier) ??
@@ -618,11 +719,13 @@ function* getMeasureValueFiltersUpdateActions(measureValueFilters, resetOthers)
         updateActions.push(tabsActions.changeMeasureValueFilterCondition({
             localIdentifier,
             conditions: incoming.dashboardMeasureValueFilter.conditions,
+            enablePersistentFiltersAcrossTabs,
         }));
         if ("dimensionality" in incoming.dashboardMeasureValueFilter) {
             updateActions.push(tabsActions.setMeasureValueFilterDimensionality({
                 localIdentifier,
                 dimensionality: incoming.dashboardMeasureValueFilter.dimensionality,
+                enablePersistentFiltersAcrossTabs,
             }));
         }
     }
@@ -637,6 +740,7 @@ function* getMeasureValueFiltersUpdateActions(measureValueFilters, resetOthers)
             updateActions.push(tabsActions.changeMeasureValueFilterCondition({
                 localIdentifier,
                 conditions: undefined,
+                enablePersistentFiltersAcrossTabs,
             }));
         }
     }
@@ -645,6 +749,7 @@ function* getMeasureValueFiltersUpdateActions(measureValueFilters, resetOthers)
 function* getDateFiltersUpdateActions(dateFilters, resetOthers, tabLocalIdentifier) {
     const updateActions = [];
     const handledDataSets = new Set();
+    const enablePersistentFiltersAcrossTabs = yield select(selectEnablePersistentFiltersAcrossTabs);
     for (const dateFilter of dateFilters) {
         const filterRef = dateFilter.dateFilter.dataSet;
         const dashboardFilter = yield call(selectFilterContextDateFilterByDataSetTabAware, filterRef, tabLocalIdentifier);
@@ -663,6 +768,7 @@ function* getDateFiltersUpdateActions(dateFilters, resetOthers, tabLocalIdentifi
                     ...localIdentifierObj,
                     ...emptyValueHandlingObj,
                     tabLocalIdentifier,
+                    enablePersistentFiltersAcrossTabs,
                 }
                 : {
                     type: dateFilter.dateFilter.type,
@@ -676,6 +782,7 @@ function* getDateFiltersUpdateActions(dateFilters, resetOthers, tabLocalIdentifi
                         : {}),
                     ...emptyValueHandlingObj,
                     tabLocalIdentifier,
+                    enablePersistentFiltersAcrossTabs,
                 };
             updateActions.push(tabsActions.upsertDateFilter(upsertPayload));
         }
@@ -694,6 +801,7 @@ function* getDateFiltersUpdateActions(dateFilters, resetOthers, tabLocalIdentifi
                     dataSet: dateFilter.dateFilter.dataSet,
                     ...localIdentifierObj,
                     tabLocalIdentifier,
+                    enablePersistentFiltersAcrossTabs,
                 }));
             }
         }
@@ -744,20 +852,30 @@ function canMapDashboardFilterFromAnotherDisplayForm(ctx) {
     return ctx.backend.capabilities.supportsElementUris;
 }
 /**
- * Returns a shallow copy of the filter with its localIdentifier replaced.
- * Used when replacing a target filter with an incoming filter from another dashboard
- * to preserve the target's localIdentifier so that attributeFilterConfigs (keyed by localId)
- * continue to match.
+ * Fits a replacement to the dashboard filter it replaces. It takes the target's localIdentifier, so
+ * attributeFilterConfigs (keyed by it) keep matching, and the target's dependencies, also when the target
+ * has none: an entry's parents may name filters of another context, and such a parent could make the
+ * replaced filter restricted.
  */
-function normalizeFilterLocalIdentifier(filter, localIdentifier) {
+function fitReplacementToTarget(filter, target) {
+    const localIdentifier = dashboardAttributeFilterItemLocalIdentifier(target);
+    const dependencies = {
+        filterElementsBy: dashboardAttributeFilterItemFilterElementsBy(target),
+        filterElementsByDate: dashboardAttributeFilterItemFilterElementsByDate(target),
+        validateElementsBy: dashboardAttributeFilterItemValidateElementsBy(target),
+    };
     if (isDashboardAttributeFilter(filter)) {
         return {
-            attributeFilter: { ...filter.attributeFilter, localIdentifier },
+            attributeFilter: { ...filter.attributeFilter, localIdentifier, ...dependencies },
         };
     }
     if (isDashboardArbitraryAttributeFilter(filter)) {
         return {
-            arbitraryAttributeFilter: { ...filter.arbitraryAttributeFilter, localIdentifier },
+            arbitraryAttributeFilter: {
+                ...filter.arbitraryAttributeFilter,
+                localIdentifier,
+                ...dependencies,
+            },
         };
     }
     // IDashboardMatchAttributeFilter

package/esm/model/commandHandlers/filterContext/common.d.ts

@@ -1,14 +1,26 @@
 import { type SagaIterator } from "redux-saga";
-import { type IDashboardDateFilter } from "@gooddata/sdk-model";
+import { type IDashboardAttributeFilterConfig, type IDashboardDateFilter, type IFilterContextDefinition } from "@gooddata/sdk-model";
 import { type IDashboardCommand } from "../../commands/base.js";
+import { type IWorkingFilterContextDefinition } from "../../store/tabs/filterContext/filterContextState.js";
 import { type DashboardContext } from "../../types/commonTypes.js";
+/**
+ * Applied filter context and attribute filter configs of every tab, taken before a write.
+ * Compared with the store afterwards so a mirrored change emits one event per tab updated.
+ */
+export interface IFilterContextByTabSnapshot {
+    readonly filterContexts: Record<string, IFilterContextDefinition | undefined>;
+    readonly workingFilterContexts: Record<string, IWorkingFilterContextDefinition | undefined>;
+    readonly attributeFilterConfigs: Record<string, IDashboardAttributeFilterConfig[]>;
+}
+export declare function captureFilterContextByTabSnapshot(): SagaIterator<IFilterContextByTabSnapshot>;
+export declare function dispatchFilterContextChangedForMutatedTabs(ctx: DashboardContext, cmd: IDashboardCommand, snapshot: IFilterContextByTabSnapshot): SagaIterator<void>;
 export declare function dispatchFilterContextChanged(ctx: DashboardContext, cmd: IDashboardCommand, tabLocalIdentifier?: string): SagaIterator<void>;
 export declare function canApplyDateFilter(dateFilter: IDashboardDateFilter): SagaIterator<boolean>;
 export declare function resetCrossFiltering(cmd: IDashboardCommand): Generator<import("redux-saga/effects").PutEffect<import("../../commands/filters.js").IRemoveAttributeFilters> | import("redux-saga/effects").PutEffect<{
     payload: string | undefined;
     type: "drill/resetCrossFiltering";
 }> | import("redux-saga/effects").SelectEffect, void, string[] & string>;
-export declare function applyWorkingSelectionHandler(ctx: DashboardContext, cmd: IDashboardCommand): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").PutEffect<{
+export declare function applyWorkingSelectionHandler(ctx: DashboardContext, cmd: IDashboardCommand): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<IFilterContextByTabSnapshot> | import("redux-saga/effects").PutEffect<{
     payload: import("../../../index.js").IApplyWorkingSelectionPayload;
     type: "tabs/applyWorkingSelection";
 }> | import("redux-saga/effects").PutEffect<import("../../events/base.js").ICustomDashboardEvent<any> | import("../../events/base.js").IDashboardEvent<any>> | import("redux-saga/effects").SelectEffect, void, never>;

package/esm/model/commandHandlers/filterContext/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/filterContext/common.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGhE,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAuBhE,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAGnE,wBAAiB,4BAA4B,CACzC,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,iBAAiB,EACtB,kBAAkB,CAAC,EAAE,MAAM,GAC5B,YAAY,CAAC,IAAI,CAAC,CAkCpB;AAED,wBAAiB,kBAAkB,CAAC,UAAU,EAAE,oBAAoB,GAAG,YAAY,CAAC,OAAO,CAAC,CAuB3F;AAED,wBAAiB,mBAAmB,CAAC,GAAG,EAAE,iBAAiB;;;yEAU1D;AAED,wBAAiB,4BAA4B,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,iBAAiB;;;uNAuB1F;AAED,wBAAiB,4BAA4B;;;mBAE5C"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/filterContext/common.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,OAAO,EACH,KAAK,+BAA+B,EACpC,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAChC,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAuBhE,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,sDAAsD,CAAC;AAI5G,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAGnE;;;GAGG;AACH,MAAM,WAAW,2BAA2B;IACxC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,GAAG,SAAS,CAAC,CAAC;IAC9E,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,+BAA+B,GAAG,SAAS,CAAC,CAAC;IAC5F,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,+BAA+B,EAAE,CAAC,CAAC;CACtF;AAED,wBAAiB,iCAAiC,IAAI,YAAY,CAAC,2BAA2B,CAAC,CAU9F;AAED,wBAAiB,0CAA0C,CACvD,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,iBAAiB,EACtB,QAAQ,EAAE,2BAA2B,GACtC,YAAY,CAAC,IAAI,CAAC,CAwBpB;AAED,wBAAiB,4BAA4B,CACzC,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,iBAAiB,EACtB,kBAAkB,CAAC,EAAE,MAAM,GAC5B,YAAY,CAAC,IAAI,CAAC,CAkCpB;AAED,wBAAiB,kBAAkB,CAAC,UAAU,EAAE,oBAAoB,GAAG,YAAY,CAAC,OAAO,CAAC,CAuB3F;AAED,wBAAiB,mBAAmB,CAAC,GAAG,EAAE,iBAAiB;;;yEAU1D;AAED,wBAAiB,4BAA4B,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,iBAAiB;;;uNAwC1F;AAED,wBAAiB,4BAA4B;;;mBAE5C"}

package/esm/model/commandHandlers/filterContext/common.js

@@ -1,4 +1,5 @@
 // (C) 2021-2026 GoodData Corporation
+import { isEqual } from "lodash-es";
 import { call, put, select } from "redux-saga/effects";
 import { invariant } from "ts-invariant";
 import { findDateFilterOptionByValue } from "../../../_staging/dateFilterConfig/dateFilterOptionMapping.js";
@@ -6,15 +7,39 @@ import { removeAttributeFilters } from "../../commands/filters.js";
 import { filterContextChanged, filterContextWorkingSelectionApplied } from "../../events/filters.js";
 import { dispatchDashboardEvent } from "../../store/_infra/eventDispatcher.js";
 import { selectEnableImmediateAttributeFilterDisplayAsLabelMigration } from "../../store/config/configSelectors.js";
-import { selectCrossFilteringFiltersLocalIdentifiers, selectIsCrossFiltering, } from "../../store/drill/drillSelectors.js";
+import { selectCrossFilteringFiltersLocalIdentifiers, selectCrossFilteringFiltersLocalIdentifiersByTab, selectIsCrossFiltering, } from "../../store/drill/drillSelectors.js";
 import { drillActions } from "../../store/drill/index.js";
+import { selectEnablePersistentFiltersAcrossTabs } from "../../store/meta/metaSelectors.js";
 import { selectAttributeFilterConfigsOverrides, selectAttributeFilterConfigsOverridesByTab, } from "../../store/tabs/attributeFilterConfigs/attributeFilterConfigsSelectors.js";
 import { selectEffectiveDateFilterOptions } from "../../store/tabs/dateFilterConfig/dateFilterConfigSelectors.js";
-import { selectFilterContextDefinition, selectFilterContextDefinitionsByTab, selectIsWorkingFilterContextChanged, } from "../../store/tabs/filterContext/filterContextSelectors.js";
+import { selectFilterContextDefinition, selectFilterContextDefinitionsByTab, selectIsWorkingFilterContextChanged, selectWorkingFilterContextDefinitionsByTab, } from "../../store/tabs/filterContext/filterContextSelectors.js";
 import { tabsActions } from "../../store/tabs/index.js";
 import { selectParameterValuesByTab } from "../../store/tabs/parameters/parametersSelectors.js";
 import { selectActiveOrDefaultTabLocalIdentifier } from "../../store/tabs/tabsSelectors.js";
-import { dispatchParametersChanged } from "../parameters/changeParameterValuesHandler.js";
+import { dispatchParametersChangedForAffectedTabs } from "../parameters/changeParameterValuesHandler.js";
+export function* captureFilterContextByTabSnapshot() {
+    const filterContexts = yield select(selectFilterContextDefinitionsByTab);
+    const workingFilterContexts = yield select(selectWorkingFilterContextDefinitionsByTab);
+    const attributeFilterConfigs = yield select(selectAttributeFilterConfigsOverridesByTab);
+    return { filterContexts, workingFilterContexts, attributeFilterConfigs };
+}
+export function* dispatchFilterContextChangedForMutatedTabs(ctx, cmd, snapshot) {
+    const filterContexts = yield select(selectFilterContextDefinitionsByTab);
+    const attributeFilterConfigs = yield select(selectAttributeFilterConfigsOverridesByTab);
+    const workingFilterContexts = yield select(selectWorkingFilterContextDefinitionsByTab);
+    for (const tabId of Object.keys(filterContexts)) {
+        if (!filterContexts[tabId]) {
+            continue;
+        }
+        const configs = attributeFilterConfigs[tabId] ?? [];
+        if (isEqual(snapshot.filterContexts[tabId], filterContexts[tabId]) &&
+            isEqual(snapshot.workingFilterContexts[tabId], workingFilterContexts[tabId]) &&
+            isEqual(snapshot.attributeFilterConfigs[tabId] ?? [], configs)) {
+            continue;
+        }
+        yield call(dispatchFilterContextChanged, ctx, cmd, tabId);
+    }
+}
 export function* dispatchFilterContextChanged(ctx, cmd, tabLocalIdentifier) {
     let filterContext;
     let attributeFilterConfigs;
@@ -64,14 +89,26 @@ export function* applyWorkingSelectionHandler(ctx, cmd) {
     const isWorkingFilterContextChanged = yield select(selectIsWorkingFilterContextChanged);
     const tabId = yield select(selectActiveOrDefaultTabLocalIdentifier);
     const valuesBefore = yield select(selectParameterValuesByTab);
-    yield put(tabsActions.applyWorkingSelection({ enableImmediateAttributeFilterDisplayAsLabelMigration }));
+    const crossFilteringLocalIdsByTab = yield select(selectCrossFilteringFiltersLocalIdentifiersByTab);
+    const enablePersistentFiltersAcrossTabs = yield select(selectEnablePersistentFiltersAcrossTabs);
+    const filterContextSnapshot = yield call(captureFilterContextByTabSnapshot);
+    yield put(tabsActions.applyWorkingSelection({
+        enableImmediateAttributeFilterDisplayAsLabelMigration,
+        crossFilteringLocalIdsByTab,
+        enablePersistentFiltersAcrossTabs,
+    }));
     const isCrossFiltering = yield select(selectIsCrossFiltering);
     if (isWorkingFilterContextChanged && isCrossFiltering) {
         yield call(resetCrossFiltering, cmd);
     }
     yield dispatchDashboardEvent(filterContextWorkingSelectionApplied(ctx, cmd.correlationId));
-    yield call(dispatchFilterContextChanged, ctx, cmd);
-    yield call(dispatchParametersChanged, ctx, cmd, tabId, valuesBefore[tabId]);
+    if (enablePersistentFiltersAcrossTabs) {
+        yield call(dispatchFilterContextChangedForMutatedTabs, ctx, cmd, filterContextSnapshot);
+    }
+    else {
+        yield call(dispatchFilterContextChanged, ctx, cmd);
+    }
+    yield call(dispatchParametersChangedForAffectedTabs, ctx, cmd, valuesBefore, tabId);
 }
 export function* resetWorkingSelectionHandler() {
     yield put(tabsActions.resetWorkingSelection());

package/esm/model/commandHandlers/filterContext/dateFilter/changeDateFilterSelectionHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"changeDateFilterSelectionHandler.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/filterContext/dateFilter/changeDateFilterSelectionHandler.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAU/C,OAAO,EAAE,KAAK,yBAAyB,EAA4B,MAAM,8BAA8B,CAAC;AAWxG,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,wBAAiB,gCAAgC,CAC7C,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,yBAAyB,GAC/B,YAAY,CAAC,IAAI,CAAC,CAqEpB"}
+{"version":3,"file":"changeDateFilterSelectionHandler.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/filterContext/dateFilter/changeDateFilterSelectionHandler.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAU/C,OAAO,EAAE,KAAK,yBAAyB,EAA4B,MAAM,8BAA8B,CAAC;AAYxG,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAUtE,wBAAiB,gCAAgC,CAC7C,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,yBAAyB,GAC/B,YAAY,CAAC,IAAI,CAAC,CA8EpB"}