@gooddata/sdk-ui-dashboard 11.36.0-alpha.1 → 11.36.0-alpha.2

package/esm/model/store/catalog/catalogState.d.ts

@@ -1,4 +1,4 @@
-import { type ICatalogAttribute, type ICatalogAttributeHierarchy, type ICatalogDateDataset, type ICatalogFact, type ICatalogMeasure, type IDateHierarchyTemplate, type IParameterMetadataObject } from "@gooddata/sdk-model";
+import { type ICatalogAttribute, type ICatalogAttributeHierarchy, type ICatalogDateDataset, type ICatalogFact, type ICatalogMeasure, type IDateHierarchyTemplate, type IParameterMetadataObject, type IdentifierRef } from "@gooddata/sdk-model";
 /**
  * Status of catalog parameters loading.
  *
@@ -14,6 +14,23 @@ export interface ICatalogParametersState {
     status: CatalogParametersStatus;
     parameters: IParameterMetadataObject[];
 }
+/**
+ * Status of the dashboard-wide metric → parameter dependency map.
+ *
+ * @alpha
+ */
+export type CatalogMeasureParametersStatus = "uninitialized" | "loading" | "loaded" | "failed";
+/**
+ * Maps each referenced metric (keyed by `objRefToString(metricRef)`) to the parameter refs the
+ * metric depends on, as reported by the workspace references service. Drives runtime parameter
+ * applicability for widget execution.
+ *
+ * @alpha
+ */
+export interface ICatalogMeasureParametersState {
+    status: CatalogMeasureParametersStatus;
+    byMetric: Record<string, IdentifierRef[]>;
+}
 /**
  * @public
  */
@@ -32,5 +49,7 @@ export type CatalogState = {
     dateHierarchyTemplates?: IDateHierarchyTemplate[];
     /** @alpha */
     parameters: ICatalogParametersState;
+    /** @alpha */
+    measureParameters: ICatalogMeasureParametersState;
 };
 export declare const catalogInitialState: CatalogState;

package/esm/model/store/catalog/catalogState.js

@@ -7,4 +7,5 @@ export const catalogInitialState = {
     attributeHierarchies: undefined,
     dateHierarchyTemplates: undefined,
     parameters: { status: "uninitialized", parameters: [] },
+    measureParameters: { status: "uninitialized", byMetric: {} },
 };

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

@@ -11,4 +11,5 @@ export declare const catalogActions: {
     updateAttributeHierarchy: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("@gooddata/sdk-model").ICatalogAttributeHierarchy, "catalog/updateAttributeHierarchy">;
     deleteAttributeHierarchy: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("@gooddata/sdk-model").ICatalogAttributeHierarchy, "catalog/deleteAttributeHierarchy">;
     setCatalogParameters: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./catalogState.js").ICatalogParametersState, "catalog/setCatalogParameters">;
+    setCatalogMeasureParameters: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./catalogState.js").ICatalogMeasureParametersState, "catalog/setCatalogMeasureParameters">;
 };

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

@@ -278,6 +278,12 @@ export declare const tabsActions: import("@reduxjs/toolkit").CaseReducerActions<
         };
         type: string;
     }) => void | import("./tabsState.js").ITabsState | import("immer").WritableDraft<import("./tabsState.js").ITabsState>;
+    readonly removeIgnoredMeasureValueFilter: (state: import("immer").WritableDraft<import("./tabsState.js").ITabsState>, action: {
+        payload: {
+            measureRefs: import("@gooddata/sdk-model").ObjRef[];
+        };
+        type: string;
+    }) => void | import("./tabsState.js").ITabsState | import("immer").WritableDraft<import("./tabsState.js").ITabsState>;
     readonly addSection: (state: import("immer").WritableDraft<import("./tabsState.js").ITabsState>, action: {
         payload: import("../_infra/undoEnhancer.js").IUndoPayload<import("../../commands/base.js").IDashboardCommand> & {
             section: import("../../types/layoutTypes.js").ExtendedDashboardLayoutSection;

package/esm/model/store/tabs/layout/layoutReducers.d.ts

@@ -129,6 +129,9 @@ type ReplaceWidgetDateDataset = {
 type RemoveIgnoredDateFilter = {
     dateDataSets: ObjRef[];
 };
+type RemoveIgnoredMeasureValueFilter = {
+    measureRefs: ObjRef[];
+};
 type ReplaceKpiWidgetMeasure = {
     ref: ObjRef;
     measureRef: ObjRef;
@@ -177,6 +180,7 @@ export declare const layoutReducers: {
     updateWidgetIdentitiesForTab: LayoutReducer<UpdateWidgetIdentitiesForTabPayload>;
     removeIgnoredAttributeFilter: LayoutReducer<RemoveIgnoredAttributeFilter>;
     removeIgnoredDateFilter: LayoutReducer<RemoveIgnoredDateFilter>;
+    removeIgnoredMeasureValueFilter: LayoutReducer<RemoveIgnoredMeasureValueFilter>;
     addSection: AdaptedLayoutReducer<import("../../_infra/undoEnhancer.js").IUndoPayload<import("../../../commands/base.js").IDashboardCommand> & AddSectionActionPayload>;
     removeSection: AdaptedLayoutReducer<import("../../_infra/undoEnhancer.js").IUndoPayload<import("../../../commands/base.js").IDashboardCommand> & RemoveSectionActionPayload>;
     moveSection: AdaptedLayoutReducer<import("../../_infra/undoEnhancer.js").IUndoPayload<import("../../../commands/base.js").IDashboardCommand> & MoveSectionActionPayload>;

package/esm/model/store/tabs/layout/layoutReducers.js

@@ -523,6 +523,30 @@ const removeIgnoredDateFilter = (state, action) => {
     invariant(layoutState?.layout);
     removeIgnoredDateFilterFromLayout(layoutState.layout, action.payload.dateDataSets);
 };
+const removeIgnoredMeasureValueFilterFromLayout = (layout, measureRefs) => {
+    layout.sections.forEach((section) => {
+        section.items.forEach((item) => {
+            const widget = item.widget;
+            if (isInsightWidget(widget) || isKpiWidget(widget)) {
+                widget.ignoreDashboardFilters = widget.ignoreDashboardFilters.filter((filter) => {
+                    if (isDashboardAttributeFilterReference(filter) ||
+                        isDashboardDateFilterReference(filter)) {
+                        return true;
+                    }
+                    return (measureRefs.find((removed) => areObjRefsEqual(removed, filter.measure)) === undefined);
+                });
+            }
+            else if (isDashboardLayout(widget)) {
+                removeIgnoredMeasureValueFilterFromLayout(widget, measureRefs);
+            }
+        });
+    });
+};
+const removeIgnoredMeasureValueFilter = (state, action) => {
+    const layoutState = getActiveTabLayout(state);
+    invariant(layoutState?.layout);
+    removeIgnoredMeasureValueFilterFromLayout(layoutState.layout, action.payload.measureRefs);
+};
 const replaceKpiWidgetMeasureCore = (state, action) => {
     invariant(state.layout);
     const { ref, measureRef } = action.payload;
@@ -628,6 +652,7 @@ export const layoutReducers = {
     updateWidgetIdentitiesForTab,
     removeIgnoredAttributeFilter,
     removeIgnoredDateFilter,
+    removeIgnoredMeasureValueFilter,
     addSection,
     removeSection,
     moveSection,

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

@@ -34,6 +34,15 @@ export declare const selectDashboardParameterEntryByRef: (ref: ObjRef) => Dashbo
  * @alpha
  */
 export declare const selectParameterRuntimeOverrideByRef: (ref: ObjRef) => DashboardSelector<number | undefined>;
+/**
+ * Reset value for a parameter chip's dropdown, bound to the kit dropdown's `resetValue` prop.
+ *
+ * Returns `undefined` (Reset hidden) in edit mode when `parameter.value` is unset or already
+ * equals the workspace default — both would be unpin no-ops on next save.
+ *
+ * @alpha
+ */
+export declare const selectParameterResetValueByRef: (ref: ObjRef) => DashboardSelector<number | undefined>;
 /**
  * Computes the dashboard parameters keyed by tab `localIdentifier` in the shape that would be
  * persisted on save right now.
@@ -60,12 +69,16 @@ export declare const selectIsParametersChanged: DashboardSelector<boolean>;
  * Returns the parameter values to inject into the widget's `IExecutionConfig.parameterValues`.
  *
  * @remarks
- * The widget's owning tab is resolved from layout, then the result is the intersection of that
- * tab's parameter entries and the parameters referenced by the widget's insight (per
- * `insightParameters`). Dashboard parameters not referenced by the widget's insight are excluded
- * so that adding/removing unrelated parameters does not invalidate the widget's `defFingerprint`.
- * Returns an empty array when `enableParameters` is off so persisted parameter values cannot
- * silently affect execution while the UI is hidden.
+ * For each parameter referenced by the widget's metrics (via the dashboard-wide MAQL
+ * metric → parameter dependency map), the value is resolved in this order:
+ *
+ * 1. dashboard chip on the widget's tab with `runtimeOverride !== undefined`,
+ * 2. else `insight.parameters` entry for that ref (AD-authored per-insight override),
+ * 3. else nothing (backend uses workspace default).
+ *
+ * Parameters not referenced by the widget's metrics are excluded so that adding/removing
+ * unrelated parameters does not invalidate the widget's `defFingerprint`. Returns `[]` when
+ * `enableParameters` is off or while the dependency map has not been loaded.
  *
  * @alpha
  */

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

@@ -1,15 +1,17 @@
 // (C) 2026 GoodData Corporation
 import { createSelector } from "@reduxjs/toolkit";
 import { isEqual } from "lodash-es";
-import { areObjRefsEqual, insightParameters, isDashboardLayout, isInsightWidget, isNumberParameterDefinition, isVisualizationSwitcherWidget, objRefToString, } from "@gooddata/sdk-model";
+import { areObjRefsEqual, insightMeasures, insightParameters, isDashboardLayout, isInsightWidget, isMeasureDefinition, isNumberParameterDefinition, isVisualizationSwitcherWidget, objRefToString, } from "@gooddata/sdk-model";
 import { createMemoizedSelector } from "../../_infra/selectors.js";
-import { selectCatalogParameters, selectCatalogParametersIsLoaded } from "../../catalog/catalogSelectors.js";
+import { selectCatalogMeasureParameters, selectCatalogMeasureParametersStatus, selectCatalogParameterByRef, selectCatalogParameters, selectCatalogParametersIsLoaded, } from "../../catalog/catalogSelectors.js";
 import { selectEnableParameters } from "../../config/configSelectors.js";
 import { selectInsightsMap } from "../../insights/insightsSelectors.js";
+import { selectIsInEditMode } from "../../renderMode/renderModeSelectors.js";
 import { selectActiveTab, selectTabs } from "../tabsSelectors.js";
 import { DEFAULT_TAB_ID } from "../tabsState.js";
 import { parametersInitialState, pickTabParametersSource, } from "./parametersState.js";
 const EMPTY_PARAMETERS = [];
+const EMPTY_PARAMETER_VALUES = [];
 const EMPTY_TABS = [];
 const selectParametersState = createSelector(selectActiveTab, (activeTab) => activeTab?.parameters ?? parametersInitialState);
 const selectPersistedParametersFromMeta = (state) => state.meta?.persistedDashboard?.parameters ?? EMPTY_PARAMETERS;
@@ -47,6 +49,31 @@ export const selectDashboardParameterEntryByRef = createMemoizedSelector((ref) =
  * @alpha
  */
 export const selectParameterRuntimeOverrideByRef = createMemoizedSelector((ref) => createSelector(selectDashboardParameterEntryByRef(ref), (entry) => entry?.runtimeOverride));
+/**
+ * Reset value for a parameter chip's dropdown, bound to the kit dropdown's `resetValue` prop.
+ *
+ * Returns `undefined` (Reset hidden) in edit mode when `parameter.value` is unset or already
+ * equals the workspace default — both would be unpin no-ops on next save.
+ *
+ * @alpha
+ */
+export const selectParameterResetValueByRef = createMemoizedSelector((ref) => createSelector(selectDashboardParameterEntryByRef(ref), selectCatalogParameterByRef(ref), selectIsInEditMode, (entry, workspaceParameter, isInEditMode) => {
+    if (!entry) {
+        return undefined;
+    }
+    if (!workspaceParameter || !isNumberParameterDefinition(workspaceParameter.definition)) {
+        return undefined;
+    }
+    const workspaceDefault = workspaceParameter.definition.defaultValue;
+    const dashboardOverride = entry.parameter.value;
+    if (isInEditMode) {
+        if (dashboardOverride === undefined || dashboardOverride === workspaceDefault) {
+            return undefined;
+        }
+        return workspaceDefault;
+    }
+    return dashboardOverride ?? workspaceDefault;
+}));
 /**
  * Computes the dashboard parameters keyed by tab `localIdentifier` in the shape that would be
  * persisted on save right now.
@@ -124,35 +151,61 @@ export const selectIsParametersChanged = createSelector(selectSmartPersistedTabs
  * Returns the parameter values to inject into the widget's `IExecutionConfig.parameterValues`.
  *
  * @remarks
- * The widget's owning tab is resolved from layout, then the result is the intersection of that
- * tab's parameter entries and the parameters referenced by the widget's insight (per
- * `insightParameters`). Dashboard parameters not referenced by the widget's insight are excluded
- * so that adding/removing unrelated parameters does not invalidate the widget's `defFingerprint`.
- * Returns an empty array when `enableParameters` is off so persisted parameter values cannot
- * silently affect execution while the UI is hidden.
+ * For each parameter referenced by the widget's metrics (via the dashboard-wide MAQL
+ * metric → parameter dependency map), the value is resolved in this order:
+ *
+ * 1. dashboard chip on the widget's tab with `runtimeOverride !== undefined`,
+ * 2. else `insight.parameters` entry for that ref (AD-authored per-insight override),
+ * 3. else nothing (backend uses workspace default).
+ *
+ * Parameters not referenced by the widget's metrics are excluded so that adding/removing
+ * unrelated parameters does not invalidate the widget's `defFingerprint`. Returns `[]` when
+ * `enableParameters` is off or while the dependency map has not been loaded.
  *
  * @alpha
  */
-export const selectEffectiveParameterValuesForWidget = createMemoizedSelector((ref) => createSelector(selectParameterExecutionContextByWidgetRef(ref), selectInsightsMap, selectEnableParameters, (context, insights, isEnabled) => {
-    if (!isEnabled || !context) {
-        return [];
+export const selectEffectiveParameterValuesForWidget = createMemoizedSelector((ref) => createSelector(selectParameterExecutionContextByWidgetRef(ref), selectInsightsMap, selectEnableParameters, selectCatalogMeasureParameters, selectCatalogMeasureParametersStatus, (context, insights, isEnabled, measureParameters, measureParametersStatus) => {
+    if (!isEnabled || !context || measureParametersStatus !== "loaded") {
+        return EMPTY_PARAMETER_VALUES;
     }
     const insight = insights.get(context.widget.insight);
     if (!insight) {
-        return [];
+        return EMPTY_PARAMETER_VALUES;
+    }
+    const referencedRefs = new Set();
+    for (const measure of insightMeasures(insight)) {
+        const def = measure.measure.definition;
+        if (!isMeasureDefinition(def)) {
+            continue;
+        }
+        const parameterRefs = measureParameters[objRefToString(def.measureDefinition.item)] ?? [];
+        for (const parameterRef of parameterRefs) {
+            referencedRefs.add(objRefToString(parameterRef));
+        }
     }
     const entries = context.tab.parameters?.parameters ?? parametersInitialState.parameters;
-    const referencedRefs = new Set(insightParameters(insight).map((parameter) => objRefToString(parameter.ref)));
     const result = [];
+    const seen = new Set();
     for (const entry of entries) {
         if (entry.runtimeOverride === undefined) {
             continue;
         }
-        if (referencedRefs.has(objRefToString(entry.parameter.ref))) {
-            result.push({ ref: entry.parameter.ref, value: entry.runtimeOverride });
+        const refKey = objRefToString(entry.parameter.ref);
+        if (!referencedRefs.has(refKey)) {
+            continue;
         }
+        result.push({ ref: entry.parameter.ref, value: entry.runtimeOverride });
+        seen.add(refKey);
     }
-    return result;
+    for (const insightParameter of insightParameters(insight)) {
+        const refKey = objRefToString(insightParameter.ref);
+        if (!referencedRefs.has(refKey) || seen.has(refKey)) {
+            continue;
+        }
+        result.push(insightParameter);
+        seen.add(refKey);
+    }
+    return result.length === 0 ? EMPTY_PARAMETER_VALUES : result;
 }));
 const selectParameterExecutionContextByWidgetRef = createMemoizedSelector((ref) => createSelector(selectTabs, (tabs) => findParameterExecutionContext(tabs, ref)));
 function findParameterExecutionContext(tabs, ref) {

package/esm/presentation/filterBar/parameterFilter/DashboardParameterFilter.js

@@ -5,7 +5,7 @@ import { useDashboardDispatch, useDashboardSelector } from "../../../model/react
 import { selectCatalogParameterByRef } from "../../../model/store/catalog/catalogSelectors.js";
 import { selectIsInEditMode } from "../../../model/store/renderMode/renderModeSelectors.js";
 import { tabsActions } from "../../../model/store/tabs/index.js";
-import { selectParameterRuntimeOverrideByRef } from "../../../model/store/tabs/parameters/parametersSelectors.js";
+import { selectParameterResetValueByRef, selectParameterRuntimeOverrideByRef, } from "../../../model/store/tabs/parameters/parametersSelectors.js";
 import { DraggableChipSource } from "../../dragAndDrop/DraggableChipSource.js";
 /**
  * Renders a chip for a single dashboard parameter.
@@ -16,6 +16,7 @@ export function DashboardParameterFilter({ parameter }) {
     const dispatch = useDashboardDispatch();
     const workspaceParameter = useDashboardSelector(selectCatalogParameterByRef(parameter.ref));
     const runtimeOverride = useDashboardSelector(selectParameterRuntimeOverrideByRef(parameter.ref));
+    const resetValue = useDashboardSelector(selectParameterResetValueByRef(parameter.ref));
     const isInEditMode = useDashboardSelector(selectIsInEditMode);
     if (parameter.mode === DashboardParameterModeValues.HIDDEN || runtimeOverride === undefined) {
         return null;
@@ -29,7 +30,7 @@ export function DashboardParameterFilter({ parameter }) {
     if (parameter.mode === DashboardParameterModeValues.READONLY) {
         return (_jsx(DraggableChipSource, { dragItem: dragItem, canDrag: isInEditMode, children: _jsx(ParameterControlButton, { name: name, value: runtimeOverride, isActive: false, isDraggable: isInEditMode, "data-testid": `dashboard-parameter-${objRefToString(parameter.ref)}` }) }));
     }
-    return (_jsx(DraggableChipSource, { dragItem: dragItem, canDrag: isInEditMode, children: _jsx(Dropdown, { renderButton: ({ isOpen, toggleDropdown }) => (_jsx(ParameterControlButton, { name: name, value: runtimeOverride, isActive: isOpen, isDraggable: isInEditMode, onClick: () => toggleDropdown(), "data-testid": `dashboard-parameter-${objRefToString(parameter.ref)}` })), renderBody: ({ closeDropdown }) => (_jsx(ParameterControlDropdown, { name: name, value: runtimeOverride, constraints: constraints, onApply: (value) => {
+    return (_jsx(DraggableChipSource, { dragItem: dragItem, canDrag: isInEditMode, children: _jsx(Dropdown, { renderButton: ({ isOpen, toggleDropdown }) => (_jsx(ParameterControlButton, { name: name, value: runtimeOverride, isActive: isOpen, isDraggable: isInEditMode, onClick: () => toggleDropdown(), "data-testid": `dashboard-parameter-${objRefToString(parameter.ref)}` })), renderBody: ({ closeDropdown }) => (_jsx(ParameterControlDropdown, { name: name, value: runtimeOverride, resetValue: resetValue, constraints: constraints, onApply: (value) => {
                     dispatch(tabsActions.setParameterRuntimeValue({ ref: parameter.ref, value }));
                     closeDropdown();
                 }, onCancel: closeDropdown })) }) }));

package/esm/presentation/localization/bundles/en-US.localization-bundle.d.ts

@@ -1931,6 +1931,14 @@ export declare const en_US: {
         text: string;
         crowdinContext: string;
     };
+    "configurationPanel.drillConfig.filterSelection.drillToDashboardDuplicateMetricFilter.tooltip": {
+        text: string;
+        crowdinContext: string;
+    };
+    "configurationPanel.drillConfig.filterSelection.drillToInsightMeasureValueFilter.tooltip": {
+        text: string;
+        crowdinContext: string;
+    };
     "configurationPanel.drillConfig.filterSelection.drillToDashboardRankingFilter.tooltip": {
         text: string;
         crowdinContext: string;

package/esm/presentation/localization/bundles/en-US.localization-bundle.js

@@ -1933,6 +1933,14 @@ export const en_US = {
         "text": "Metric filters cannot be passed to the target dashboard.",
         "crowdinContext": "Tooltip shown for disabled metric value filters in drill-to-dashboard configuration because metric filters are not supported on the target dashboard"
     },
+    "configurationPanel.drillConfig.filterSelection.drillToDashboardDuplicateMetricFilter.tooltip": {
+        "text": "Another filter for this metric is already being passed.",
+        "crowdinContext": "Tooltip shown for a disabled dashboard or visualization metric filter in drill-to-dashboard configuration when another filter for the same metric is already selected"
+    },
+    "configurationPanel.drillConfig.filterSelection.drillToInsightMeasureValueFilter.tooltip": {
+        "text": "Filter is not applicable to the drill destination.",
+        "crowdinContext": "Tooltip shown for disabled measure value filters in drill-to-insight configuration because measure value filters are not supported on the target dashboard"
+    },
     "configurationPanel.drillConfig.filterSelection.drillToDashboardRankingFilter.tooltip": {
         "text": "Top/bottom filters can’t be passed to the target dashboard.",
         "crowdinContext": "Tooltip shown for disabled ranking filters in drill-to-dashboard configuration because top and bottom filters are not transferred to the target dashboard"

package/esm/presentation/widget/common/configuration/FilterConfiguration.js

@@ -2,11 +2,12 @@ import { jsx as _jsx } from "react/jsx-runtime";
 // (C) 2022-2026 GoodData Corporation
 import { useMemo } from "react";
 import { invariant } from "ts-invariant";
-import { dashboardAttributeFilterItemDisplayForm, dashboardAttributeFilterItemLocalIdentifier, dashboardAttributeFilterItemTitle, isAttributeMetadataObject, isDashboardAttributeFilterItem, isDashboardDateFilterWithDimension, isDashboardMeasureValueFilter, objRefToString, } from "@gooddata/sdk-model";
+import { dashboardAttributeFilterItemDisplayForm, dashboardAttributeFilterItemLocalIdentifier, dashboardAttributeFilterItemTitle, isAttributeMetadataObject, isDashboardAttributeFilterItem, isDashboardDateFilterWithDimension, isDashboardMeasureValueFilter, isInsightWidget, objRefToString, } from "@gooddata/sdk-model";
 import { useAttributeFilterDisplayFormFromMap } from "../../../../_staging/sharedHooks/useAttributeFilterDisplayFormFromMap.js";
 import { useAttributes } from "../../../../_staging/sharedHooks/useAttributes.js";
 import { useDashboardSelector } from "../../../../model/react/DashboardStoreProvider.js";
 import { selectAllCatalogAttributesMap, selectAllCatalogDateDatasetsMap, selectAllCatalogMeasuresMap, } from "../../../../model/store/catalog/catalogSelectors.js";
+import { selectInsightByRef } from "../../../../model/store/insights/insightsSelectors.js";
 import { selectAttributeFilterConfigsDisplayAsLabelMap } from "../../../../model/store/tabs/attributeFilterConfigs/attributeFilterConfigsSelectors.js";
 import { selectFilterContextFilters } from "../../../../model/store/tabs/filterContext/filterContextSelectors.js";
 import { AttributeFilterConfigurationItem } from "./AttributeFilterConfigurationItem.js";
@@ -34,7 +35,8 @@ export function FilterConfiguration({ widget }) {
     }, [attributeFilters]);
     const { attributes, attributesLoading } = useAttributes(displayForms);
     const measureValueFilters = useMemo(() => draggableFilters.filter(isDashboardMeasureValueFilter), [draggableFilters]);
-    const { isCompatible } = useMeasureValueFilterCompatibility(widget, measureValueFilters);
+    const insight = useDashboardSelector(selectInsightByRef(isInsightWidget(widget) ? widget.insight : undefined));
+    const { isCompatible } = useMeasureValueFilterCompatibility(insight, measureValueFilters);
     if (attributesLoading) {
         return _jsx("span", { className: "gd-spinner small s-attribute-filter-configuration-loading" });
     }

package/esm/presentation/widget/common/configuration/useMeasureValueFilterCompatibility.d.ts

@@ -1,5 +1,9 @@
-import { type IDashboardMeasureValueFilter, type IWidget, type ObjRef } from "@gooddata/sdk-model";
-export declare function useMeasureValueFilterCompatibility(widget: IWidget, filters: IDashboardMeasureValueFilter[]): {
+import { type IDashboardMeasureValueFilter, type IInsight, type IInsightDefinition, type ObjRef } from "@gooddata/sdk-model";
+import { useBackendStrict } from "@gooddata/sdk-ui";
+export declare function useMeasureValueFilterCompatibility(insight: IInsight | undefined, filters: IDashboardMeasureValueFilter[]): {
     status: "error" | "loading" | "pending" | "success";
     isCompatible: (measureRef: ObjRef) => boolean;
+    compatibleMeasureRefs: ObjRef[] | undefined;
+    compatibleMeasureValueFilters: IDashboardMeasureValueFilter[];
 };
+export declare function loadCompatibleMeasureRefs(backend: ReturnType<typeof useBackendStrict>, workspace: string, insight: IInsightDefinition, measureRefs: ObjRef[]): Promise<ObjRef[]>;

package/esm/presentation/widget/common/configuration/useMeasureValueFilterCompatibility.js

@@ -1,40 +1,78 @@
 // (C) 2026 GoodData Corporation
 import { useMemo } from "react";
-import { areObjRefsEqual, insightMeasures, isInsightWidget, measureItem, objRefToString, } from "@gooddata/sdk-model";
+import { areObjRefsEqual, insightBuckets, insightFilters, insightMeasures, isObjRef, measureItem, objRefToString, } from "@gooddata/sdk-model";
 import { useBackendStrict, useCancelablePromise, useWorkspaceStrict } from "@gooddata/sdk-ui";
-import { safeSerializeObjRef } from "../../../../_staging/metadata/safeSerializeObjRef.js";
-import { useDashboardSelector } from "../../../../model/react/DashboardStoreProvider.js";
-import { selectInsightByRef } from "../../../../model/store/insights/insightsSelectors.js";
-export function useMeasureValueFilterCompatibility(widget, filters) {
+const COMPATIBLE_MEASURE_REFS_CACHE_SIZE = 50;
+const compatibleMeasureRefsCache = new Map();
+const compatibleMeasureRefsPromises = new Map();
+export function useMeasureValueFilterCompatibility(insight, filters) {
     const backend = useBackendStrict();
     const workspace = useWorkspaceStrict();
-    const insight = useDashboardSelector(selectInsightByRef(isInsightWidget(widget) ? widget.insight : undefined));
     const measureRefs = useMemo(() => filters.map((filter) => filter.dashboardMeasureValueFilter.measure), [filters]);
     const measureRefsDigest = useMemo(() => measureRefs.map(objRefToString).join("|"), [measureRefs]);
-    const { result: compatibleMeasureRefs, status } = useCancelablePromise({
-        promise: async () => {
-            if (!measureRefs.length) {
-                return [];
-            }
-            if (!isInsightWidget(widget) || !insight) {
-                return measureRefs;
-            }
-            return loadCompatibleMeasureRefs(backend, workspace, insight, measureRefs);
-        },
+    const insightIdentifier = getInsightIdentifier(insight);
+    const cacheKey = useMemo(() => insight && measureRefs.length
+        ? getCompatibleMeasureRefsCacheKey(workspace, insight, measureRefsDigest)
+        : undefined, [insight, measureRefs.length, measureRefsDigest, workspace]);
+    const cachedCompatibleMeasureRefs = useMemo(() => {
+        if (!measureRefs.length) {
+            return [];
+        }
+        if (!insight) {
+            return measureRefs;
+        }
+        return cacheKey ? getCachedValue(compatibleMeasureRefsCache, cacheKey) : undefined;
+    }, [cacheKey, insight, measureRefs]);
+    const insightToLoadCompatibleMeasureRefsFor = cachedCompatibleMeasureRefs ? undefined : insight;
+    const { result: loadedCompatibleMeasureRefs, status } = useCancelablePromise({
+        promise: insightToLoadCompatibleMeasureRefsFor
+            ? async () => loadCompatibleMeasureRefs(backend, workspace, insightToLoadCompatibleMeasureRefsFor, measureRefs)
+            : undefined,
     }, [
         backend,
         workspace,
         measureRefsDigest,
-        safeSerializeObjRef(isInsightWidget(widget) ? widget.insight : undefined),
-        insight,
+        insightIdentifier,
+        cachedCompatibleMeasureRefs,
+        insightToLoadCompatibleMeasureRefsFor,
     ]);
+    const compatibleMeasureRefs = cachedCompatibleMeasureRefs ?? loadedCompatibleMeasureRefs;
+    const compatibleMeasureValueFilters = useMemo(() => compatibleMeasureRefs
+        ? filters.filter((filter) => isMeasureRefCompatible(filter.dashboardMeasureValueFilter.measure, compatibleMeasureRefs))
+        : filters, [compatibleMeasureRefs, filters]);
     return {
-        status,
-        isCompatible: (measureRef) => !compatibleMeasureRefs ||
-            compatibleMeasureRefs.some((compatibleMeasureRef) => areObjRefsEqual(compatibleMeasureRef, measureRef)),
+        status: cachedCompatibleMeasureRefs ? "success" : status,
+        isCompatible: (measureRef) => isMeasureRefCompatible(measureRef, compatibleMeasureRefs),
+        compatibleMeasureRefs,
+        compatibleMeasureValueFilters,
     };
 }
-async function loadCompatibleMeasureRefs(backend, workspace, insight, measureRefs) {
+function isMeasureRefCompatible(measureRef, compatibleMeasureRefs) {
+    return (!compatibleMeasureRefs ||
+        compatibleMeasureRefs.some((compatibleMeasureRef) => areObjRefsEqual(compatibleMeasureRef, measureRef)));
+}
+export async function loadCompatibleMeasureRefs(backend, workspace, insight, measureRefs) {
+    const cacheKey = getCompatibleMeasureRefsCacheKey(workspace, insight, measureRefs.map(objRefToString).join("|"));
+    const cachedCompatibleMeasureRefs = getCachedValue(compatibleMeasureRefsCache, cacheKey);
+    if (cachedCompatibleMeasureRefs) {
+        return cachedCompatibleMeasureRefs;
+    }
+    const pendingCompatibleMeasureRefs = getCachedValue(compatibleMeasureRefsPromises, cacheKey);
+    if (pendingCompatibleMeasureRefs) {
+        return pendingCompatibleMeasureRefs;
+    }
+    const compatibleMeasureRefsPromise = loadCompatibleMeasureRefsFromBackend(backend, workspace, insight, measureRefs)
+        .then((compatibleMeasureRefs) => {
+        setCachedValue(compatibleMeasureRefsCache, cacheKey, compatibleMeasureRefs);
+        return compatibleMeasureRefs;
+    })
+        .finally(() => {
+        compatibleMeasureRefsPromises.delete(cacheKey);
+    });
+    setCachedValue(compatibleMeasureRefsPromises, cacheKey, compatibleMeasureRefsPromise);
+    return compatibleMeasureRefsPromise;
+}
+async function loadCompatibleMeasureRefsFromBackend(backend, workspace, insight, measureRefs) {
     const catalog = await backend
         .workspace(workspace)
         .catalog()
@@ -49,3 +87,38 @@ async function loadCompatibleMeasureRefs(backend, workspace, insight, measureRef
     const validMeasureRefs = [...availableMeasureRefs, ...insightMeasureRefs];
     return measureRefs.filter((measureRef) => validMeasureRefs.some((validMeasureRef) => areObjRefsEqual(validMeasureRef, measureRef)));
 }
+function getCompatibleMeasureRefsCacheKey(workspace, insight, measureRefsDigest) {
+    return JSON.stringify([
+        workspace,
+        getInsightIdentifier(insight),
+        insightBuckets(insight),
+        insightFilters(insight),
+        measureRefsDigest,
+    ]);
+}
+function getInsightIdentifier(insight) {
+    if (!insight) {
+        return undefined;
+    }
+    if ("identifier" in insight.insight && typeof insight.insight.identifier === "string") {
+        return insight.insight.identifier;
+    }
+    if ("ref" in insight.insight && isObjRef(insight.insight.ref)) {
+        return objRefToString(insight.insight.ref);
+    }
+    return undefined;
+}
+function getCachedValue(cache, key) {
+    return cache.get(key);
+}
+function setCachedValue(cache, key, value) {
+    cache.delete(key);
+    cache.set(key, value);
+    while (cache.size > COMPATIBLE_MEASURE_REFS_CACHE_SIZE) {
+        const oldestKey = cache.keys().next().value;
+        if (oldestKey === undefined) {
+            return;
+        }
+        cache.delete(oldestKey);
+    }
+}

package/esm/presentation/widget/insight/ViewModeDashboardInsight/InsightDrillDialog/useExcludedDrillDefinitionFilters.js

@@ -1,6 +1,6 @@
 // (C) 2020-2026 GoodData Corporation
 import { useMemo } from "react";
-import { filterLocalIdentifier, isAttributeFilter, isDateFilter, isDrillToInsight, } from "@gooddata/sdk-model";
+import { filterLocalIdentifier, isAttributeFilter, isDateFilter, isDrillToInsight, isMeasureValueFilter, } from "@gooddata/sdk-model";
 export function useExcludedDrillDefinitionFilters(filtersForInsight, drillStep) {
     const ignoredDashboardFilterIds = useMemo(() => {
         if (!drillStep || !isDrillToInsight(drillStep.drillDefinition)) {
@@ -9,7 +9,7 @@ export function useExcludedDrillDefinitionFilters(filtersForInsight, drillStep)
         return new Set(drillStep.drillDefinition.ignoredDashboardFilters ?? []);
     }, [drillStep]);
     return useMemo(() => filtersForInsight?.filter((filter) => {
-        if (!isAttributeFilter(filter) && !isDateFilter(filter)) {
+        if (!isAttributeFilter(filter) && !isDateFilter(filter) && !isMeasureValueFilter(filter)) {
             return true;
         }
         const localIdentifier = filterLocalIdentifier(filter);

package/esm/presentation/widget/insight/configuration/DrillFilters/TargetDashboardFiltersContext.d.ts

@@ -1,11 +1,12 @@
 import { type ReactNode } from "react";
-import { type DashboardTextAttributeFilter, type FilterContextItem, type IDashboardAttributeFilter, type IDashboardAttributeFilterConfig, type ObjRef } from "@gooddata/sdk-model";
+import { type DashboardTextAttributeFilter, type FilterContextItem, type IDashboardAttributeFilter, type IDashboardAttributeFilterConfig, type IDashboardMeasureValueFilter, type ObjRef } from "@gooddata/sdk-model";
 type TTargetDashboardFiltersCacheStatus = "loading" | "success" | "error";
 interface ITargetDashboardFiltersCacheEntry {
     status: TTargetDashboardFiltersCacheStatus;
     targetDashboardFilters: FilterContextItem[];
     targetDashboardAttributeFilters: IDashboardAttributeFilter[];
     targetDashboardTextAttributeFilters: DashboardTextAttributeFilter[];
+    targetDashboardMeasureValueFilters: IDashboardMeasureValueFilter[];
     targetDashboardAttributeFilterConfigs: IDashboardAttributeFilterConfig[];
 }
 interface ITargetDashboardFiltersContextValue {

package/esm/presentation/widget/insight/configuration/DrillFilters/TargetDashboardFiltersContext.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 // (C) 2020-2026 GoodData Corporation
 import { createContext, useCallback, useContext, useMemo, useRef, useState } from "react";
-import { isDashboardAttributeFilter, isDashboardTextAttributeFilter, } from "@gooddata/sdk-model";
+import { isDashboardAttributeFilter, isDashboardMeasureValueFilter, isDashboardTextAttributeFilter, } from "@gooddata/sdk-model";
 import { useBackendStrict, useWorkspaceStrict } from "@gooddata/sdk-ui";
 import { dashboardFilterContextDefinition } from "../../../../../_staging/dashboard/dashboardFilterContext.js";
 import { defaultDateFilterConfig } from "../../../../../_staging/dateFilterConfig/defaultConfig.js";
@@ -24,6 +24,7 @@ function getTargetDashboardFilterData(dashboard, targetTabLocalIdentifier) {
         targetDashboardFilters,
         targetDashboardAttributeFilters: targetDashboardFilters.filter(isDashboardAttributeFilter),
         targetDashboardTextAttributeFilters: targetDashboardFilters.filter(isDashboardTextAttributeFilter),
+        targetDashboardMeasureValueFilters: targetDashboardFilters.filter(isDashboardMeasureValueFilter),
         targetDashboardAttributeFilterConfigs: targetDashboard.attributeFilterConfigs ?? [],
     };
 }
@@ -33,6 +34,7 @@ function createEmptyCacheEntry(status) {
         targetDashboardFilters: [],
         targetDashboardAttributeFilters: [],
         targetDashboardTextAttributeFilters: [],
+        targetDashboardMeasureValueFilters: [],
         targetDashboardAttributeFilterConfigs: [],
     };
 }

package/esm/presentation/widget/insight/configuration/DrillFilters/drillFiltersConfigUtils.d.ts

@@ -1,5 +1,5 @@
 import { type IntlShape } from "react-intl";
-import { type DashboardTextAttributeFilter, type FilterContextItem, type IAttributeDisplayFormMetadataObject, type ICatalogMeasure, type IDashboardAttributeFilter, type IDashboardAttributeFilterConfig, type IDashboardDateFilterConfigItem, type IMeasure, type ObjRef, type ObjRefInScope, type SourceInsightFilterObjRef } from "@gooddata/sdk-model";
+import { type DashboardTextAttributeFilter, type FilterContextItem, type IAttributeDisplayFormMetadataObject, type ICatalogMeasure, type IDashboardAttributeFilter, type IDashboardAttributeFilterConfig, type IDashboardDateFilterConfigItem, type IDashboardMeasureValueFilter, type IMeasure, type ObjRef, type ObjRefInScope, type SourceInsightFilterObjRef } from "@gooddata/sdk-model";
 import { type ObjRefMap } from "../../../../../_staging/metadata/objRefMap.js";
 import { type IDrillFiltersConfigOption } from "./types.js";
 export declare function getMeasureTitleFromSourceInsightMeasures(sourceInsightMeasures: IMeasure[], measureRef: ObjRefInScope | undefined, allCatalogMeasures: ICatalogMeasure[], intl: IntlShape): string | undefined;
@@ -23,9 +23,12 @@ export declare function getDashboardDateFilterCustomTitle({ datasetRef, allDateF
     datasetRef: ObjRefInScope;
     allDateFilterConfigsOverrides: IDashboardDateFilterConfigItem[];
 }): string | undefined;
+export declare function getCatalogMeasureTitle(measureRef: ObjRef, allCatalogMeasures: ICatalogMeasure[]): string;
 export declare function hasMatchingTargetDashboardAttributeFilterDisplayForm(displayFormRef: ObjRef, targetDashboardAttributeFilters: IDashboardAttributeFilter[]): boolean;
 export declare function hasMatchingTargetDashboardAttributeFilter(dashboardFilter: IDashboardAttributeFilter, sourceDashboardAttributeFilterConfigs: IDashboardAttributeFilterConfig[], targetDashboardAttributeFilters: IDashboardAttributeFilter[], targetDashboardAttributeFilterConfigs: IDashboardAttributeFilterConfig[], allCatalogDisplayFormsMap: ObjRefMap<IAttributeDisplayFormMetadataObject>): boolean;
 export declare function hasMatchingTargetDashboardDateFilter(datasetRef: ObjRef, targetDashboardFilters: FilterContextItem[]): boolean;
+export declare function hasMatchingTargetDashboardMeasureValueFilter(measureRef: ObjRefInScope | undefined, targetDashboardFilters: FilterContextItem[]): boolean;
+export declare function hasCompatibleTargetInsightMeasureValueFilter(measureRef: ObjRef, targetInsightCompatibleMeasureValueFilters: IDashboardMeasureValueFilter[]): boolean;
 export declare function isDateIntersectionAttribute(displayFormRef: ObjRef, allCatalogDateAttributeDisplayForms: Array<{
     ref: ObjRef;
     title?: string;