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

package/esm/__version.d.ts

@@ -1,3 +1,3 @@
-export declare const LIB_VERSION = "11.36.0-alpha.1";
+export declare const LIB_VERSION = "11.36.0-alpha.2";
 export declare const LIB_DESCRIPTION = "GoodData SDK - Dashboard Component";
 export declare const LIB_NAME = "@gooddata/sdk-ui-dashboard";

package/esm/__version.js

@@ -1,5 +1,5 @@
 // (C) 2021 GoodData Corporation
 // DO NOT CHANGE THIS FILE, IT IS RE-GENERATED ON EVERY BUILD
-export const LIB_VERSION = "11.36.0-alpha.1";
+export const LIB_VERSION = "11.36.0-alpha.2";
 export const LIB_DESCRIPTION = "GoodData SDK - Dashboard Component";
 export const LIB_NAME = "@gooddata/sdk-ui-dashboard";

package/esm/_staging/drills/drillingUtils.d.ts

@@ -40,3 +40,12 @@ export declare function isMatchingSourceInsightFilter(filter: IFilter, sourceFil
 export declare function isSourceInsightFilterObjRefEqual(left: SourceInsightFilterObjRef, right: SourceInsightFilterObjRef): boolean;
 export declare function sourceInsightFilterObjRef(filter: IFilter): SourceInsightFilterObjRef | undefined;
 export declare function sourceInsightFilterObjRefValue(sourceFilterObjRef: SourceInsightFilterObjRef): ObjRefInScope;
+/**
+ * Resolves a measure-scoped ref from an insight filter to the underlying catalog measure ref.
+ *
+ * Source insight MVFs usually target a local measure identifier, while dashboard MVFs target
+ * the metric object ref. Use this when comparing or merging source MVFs with dashboard MVFs.
+ *
+ * @internal
+ */
+export declare function resolveSourceMeasureRef(measureRef: ObjRefInScope | undefined, sourceInsightMeasures: IMeasure[]): ObjRef | undefined;

package/esm/_staging/drills/drillingUtils.js

@@ -1,6 +1,6 @@
 // (C) 2020-2026 GoodData Corporation
 import { isEqual } from "lodash-es";
-import { areObjRefsEqual, drillDownReferenceHierarchyRef, filterMeasureRef, filterObjRef, isAttributeFilter, isCrossFiltering, isDateFilter, isDrillFromAttribute, isDrillFromMeasure, isDrillToLegacyDashboard, isIdentifierRef, isKeyDriveAnalysis, isLocalIdRef, isMeasureDescriptor, isMeasureValueFilter, isRankingFilter, measureFilters, measureLocalId, } from "@gooddata/sdk-model";
+import { areObjRefsEqual, drillDownReferenceHierarchyRef, filterMeasureRef, filterObjRef, isAttributeFilter, isCrossFiltering, isDateFilter, isDrillFromAttribute, isDrillFromMeasure, isDrillToLegacyDashboard, isIdentifierRef, isKeyDriveAnalysis, isLocalIdRef, isMeasureDescriptor, isMeasureValueFilter, isRankingFilter, measureFilters, measureItem, measureLocalId, } from "@gooddata/sdk-model";
 import { getMappingHeaderLocalIdentifier, } from "@gooddata/sdk-ui";
 export function getDrillsBySourceLocalIdentifiers(widgetDrillDefinition, drillSourceLocalIdentifiers) {
     return widgetDrillDefinition.filter((d) => isDrillToLegacyDashboard(d) ||
@@ -185,3 +185,21 @@ export function sourceInsightFilterObjRefValue(sourceFilterObjRef) {
     }
     throw new Error("Invalid SourceInsightFilterObjRef");
 }
+/**
+ * Resolves a measure-scoped ref from an insight filter to the underlying catalog measure ref.
+ *
+ * Source insight MVFs usually target a local measure identifier, while dashboard MVFs target
+ * the metric object ref. Use this when comparing or merging source MVFs with dashboard MVFs.
+ *
+ * @internal
+ */
+export function resolveSourceMeasureRef(measureRef, sourceInsightMeasures) {
+    if (!measureRef) {
+        return undefined;
+    }
+    if (!isLocalIdRef(measureRef)) {
+        return measureRef;
+    }
+    const sourceMeasure = sourceInsightMeasures.find((measure) => measureLocalId(measure) === measureRef.localIdentifier);
+    return sourceMeasure ? measureItem(sourceMeasure) : undefined;
+}

package/esm/index.d.ts

@@ -138,8 +138,8 @@ export type { FilterContextState, WorkingDashboardAttributeFilter, WorkingDashbo
 export { selectFilterGroupsConfig } from "./model/store/tabs/filterGroups/filterGroupsSelectors.js";
 export { selectDateFilterConfigsOverrides, selectDateFilterConfigsOverridesByTab, selectDateFilterConfigsModeMap, selectEffectiveDateFiltersModeMap, selectDateFilterConfigsModeMapByTab, } from "./model/store/tabs/dateFilterConfigs/dateFilterConfigsSelectors.js";
 export { selectInsights, selectInsightRefs, selectInsightsMap, selectInsightByRef, selectInsightByWidgetRef, selectRawExportOverridesForInsightByRef, } from "./model/store/insights/insightsSelectors.js";
-export type { CatalogState, CatalogParametersStatus, ICatalogParametersState, } from "./model/store/catalog/catalogState.js";
-export { selectCatalogIsLoaded, selectAttributesWithDrillDown, selectCatalogAttributes, selectCatalogAttributeDisplayForms, selectCatalogDateDatasets, selectCatalogFacts, selectCatalogMeasures, selectAllCatalogAttributesMap, selectAllCatalogDisplayFormsMap, selectAllCatalogDateDatasetsMap, selectAllCatalogMeasuresMap, selectHasCatalogAttributes, selectHasCatalogMeasures, selectHasCatalogDateDatasets, selectHasCatalogFacts, selectCatalogAttributeHierarchies, selectCatalogDateAttributes, selectDateHierarchyTemplates, selectAdhocDateHierarchies, selectAllCatalogAttributeHierarchies, selectCatalogAttributeDisplayFormsById, selectCatalogParameters, selectCatalogParametersStatus, selectCatalogParametersIsLoaded, } from "./model/store/catalog/catalogSelectors.js";
+export type { CatalogState, CatalogParametersStatus, ICatalogParametersState, CatalogMeasureParametersStatus, ICatalogMeasureParametersState, } from "./model/store/catalog/catalogState.js";
+export { selectCatalogIsLoaded, selectAttributesWithDrillDown, selectCatalogAttributes, selectCatalogAttributeDisplayForms, selectCatalogDateDatasets, selectCatalogFacts, selectCatalogMeasures, selectAllCatalogAttributesMap, selectAllCatalogDisplayFormsMap, selectAllCatalogDateDatasetsMap, selectAllCatalogMeasuresMap, selectHasCatalogAttributes, selectHasCatalogMeasures, selectHasCatalogDateDatasets, selectHasCatalogFacts, selectCatalogAttributeHierarchies, selectCatalogDateAttributes, selectDateHierarchyTemplates, selectAdhocDateHierarchies, selectAllCatalogAttributeHierarchies, selectCatalogAttributeDisplayFormsById, selectCatalogParameters, selectCatalogParametersStatus, selectCatalogParametersIsLoaded, selectCatalogMeasureParameters, selectCatalogMeasureParametersStatus, } from "./model/store/catalog/catalogSelectors.js";
 export { catalogActions } from "./model/store/catalog/index.js";
 export type { SetCatalogMeasuresAndFactsPayload, SetCatalogItemsPayload, } from "./model/store/catalog/catalogReducers.js";
 export type { IAddParameterPayload, IRemoveParameterPayload, ISetParameterRuntimeValuePayload, } from "./model/store/tabs/parameters/parametersReducers.js";

package/esm/index.js

@@ -103,7 +103,7 @@ export { DEFAULT_TAB_ID } from "./model/store/tabs/tabsState.js";
 export { selectFilterGroupsConfig } from "./model/store/tabs/filterGroups/filterGroupsSelectors.js";
 export { selectDateFilterConfigsOverrides, selectDateFilterConfigsOverridesByTab, selectDateFilterConfigsModeMap, selectEffectiveDateFiltersModeMap, selectDateFilterConfigsModeMapByTab, } from "./model/store/tabs/dateFilterConfigs/dateFilterConfigsSelectors.js";
 export { selectInsights, selectInsightRefs, selectInsightsMap, selectInsightByRef, selectInsightByWidgetRef, selectRawExportOverridesForInsightByRef, } from "./model/store/insights/insightsSelectors.js";
-export { selectCatalogIsLoaded, selectAttributesWithDrillDown, selectCatalogAttributes, selectCatalogAttributeDisplayForms, selectCatalogDateDatasets, selectCatalogFacts, selectCatalogMeasures, selectAllCatalogAttributesMap, selectAllCatalogDisplayFormsMap, selectAllCatalogDateDatasetsMap, selectAllCatalogMeasuresMap, selectHasCatalogAttributes, selectHasCatalogMeasures, selectHasCatalogDateDatasets, selectHasCatalogFacts, selectCatalogAttributeHierarchies, selectCatalogDateAttributes, selectDateHierarchyTemplates, selectAdhocDateHierarchies, selectAllCatalogAttributeHierarchies, selectCatalogAttributeDisplayFormsById, selectCatalogParameters, selectCatalogParametersStatus, selectCatalogParametersIsLoaded, } from "./model/store/catalog/catalogSelectors.js";
+export { selectCatalogIsLoaded, selectAttributesWithDrillDown, selectCatalogAttributes, selectCatalogAttributeDisplayForms, selectCatalogDateDatasets, selectCatalogFacts, selectCatalogMeasures, selectAllCatalogAttributesMap, selectAllCatalogDisplayFormsMap, selectAllCatalogDateDatasetsMap, selectAllCatalogMeasuresMap, selectHasCatalogAttributes, selectHasCatalogMeasures, selectHasCatalogDateDatasets, selectHasCatalogFacts, selectCatalogAttributeHierarchies, selectCatalogDateAttributes, selectDateHierarchyTemplates, selectAdhocDateHierarchies, selectAllCatalogAttributeHierarchies, selectCatalogAttributeDisplayFormsById, selectCatalogParameters, selectCatalogParametersStatus, selectCatalogParametersIsLoaded, selectCatalogMeasureParameters, selectCatalogMeasureParametersStatus, } from "./model/store/catalog/catalogSelectors.js";
 export { catalogActions } from "./model/store/catalog/index.js";
 export { selectDashboardParameterEntries, selectDashboardParameters, selectEffectiveParameterValuesForWidget, selectIsParametersChanged, selectParameterRuntimeOverrideByRef, } from "./model/store/tabs/parameters/parametersSelectors.js";
 export { drillActions } from "./model/store/drill/index.js";

package/esm/model/commandHandlers/dashboard/initializeDashboardHandler/index.js

@@ -33,6 +33,7 @@ import { loadDashboardParameters } from "./loadDashboardParameters.js";
 import { loadDashboardPermissions } from "./loadDashboardPermissions.js";
 import { loadDateHierarchyTemplates } from "./loadDateHierarchyTemplates.js";
 import { loadFilterViews } from "./loadFilterViews.js";
+import { loadMeasureParameterDependencies } from "./loadMeasureParameterDependencies.js";
 import { loadUser } from "./loadUser.js";
 import { mergeDateFilterConfigWithOverrides } from "./mergeDateFilterConfigs.js";
 import { preloadAttributeFiltersData as preloadAttributeFiltersDataFromBackend } from "./preloadAttributeFiltersData.js";
@@ -180,8 +181,11 @@ function* loadExistingDashboard(ctx, cmd, dashboardRef) {
     // Note: activeTabLocalIdentifier is app state only, NOT persisted to/read from dashboard MD
     const resolvedActiveTabId = resolveActiveTabId(dashboardWithFilterView.tabs, cmd.payload.initialTabId, undefined);
     const dashboard = dashboardWithFilterView;
-    const { tabsAttributeFilterConfigs, tabsDateFilterConfig, tabsDateFilterConfigSource } = yield call(getTabsFilterConfigs, dashboard, config, ctx, cmd);
-    const workspaceParameters = yield call(loadWorkspaceParametersWithStatus, ctx, config.settings?.enableParameters ?? false);
+    const [{ tabsAttributeFilterConfigs, tabsDateFilterConfig, tabsDateFilterConfigSource }, workspaceParameters, measureParameterDependencies,] = yield all([
+        call(getTabsFilterConfigs, dashboard, config, ctx, cmd),
+        call(loadWorkspaceParametersWithStatus, ctx, config.settings?.enableParameters ?? false),
+        call(loadMeasureParameterDependencies, ctx, insights, config.settings?.enableParameters ?? false),
+    ]);
     const workspaceParametersList = Array.isArray(workspaceParameters) ? workspaceParameters : [];
     const initActions = yield call(actionsToInitializeExistingDashboard, ctx, dashboard, insights, config.settings, config.settings.enableImmediateAttributeFilterDisplayAsLabelMigration ?? false, undefined, undefined, tabsAttributeFilterConfigs, tabsDateFilterConfig, tabsDateFilterConfigSource, createDisplayFormMap([], []), cmd.payload.persistedDashboard, resolvedActiveTabId, workspaceParametersList);
     const catalogPayload = {
@@ -195,6 +199,7 @@ function* loadExistingDashboard(ctx, cmd, dashboardRef) {
         permissionsActions.setPermissions(permissions),
         catalogActions.setCatalogItems(catalogPayload),
         catalogActions.setCatalogParameters(makeCatalogParametersPayload(workspaceParameters)),
+        catalogActions.setCatalogMeasureParameters(measureParameterDependencies),
         ...initActions,
         // NOTE: Tab configs (dateFilterConfig, dateFilterConfigs, attributeFilterConfigs, filterContext)
         // are now initialized as part of the tabs state in initActions via setTabs action
@@ -229,6 +234,7 @@ function* initializeNewDashboard(ctx, cmd) {
     const workspaceParameters = yield call(loadWorkspaceParametersWithStatus, ctx, config.settings?.enableParameters ?? false);
     const workspaceParametersList = Array.isArray(workspaceParameters) ? workspaceParameters : [];
     const { initActions, dashboard, insights } = yield call(actionsToInitializeNewDashboard, ctx, config.settings, config.dateFilterConfig, catalog ? createDisplayFormMapFromCatalog(catalog) : createDisplayFormMap([], []), cmd.payload.initialTabId, workspaceParametersList);
+    const measureParameterDependencies = yield call(loadMeasureParameterDependencies, ctx, insights, config.settings?.enableParameters ?? false);
     const batch = batchActions([
         backendCapabilitiesActions.setBackendCapabilities(backend.capabilities),
         configActions.setConfig(config),
@@ -244,6 +250,7 @@ function* initializeNewDashboard(ctx, cmd) {
             dateHierarchyTemplates: dateHierarchyTemplates,
         }),
         catalogActions.setCatalogParameters(makeCatalogParametersPayload(workspaceParameters)),
+        catalogActions.setCatalogMeasureParameters(measureParameterDependencies),
         listedDashboardsActions.setListedDashboards(listedDashboards),
         accessibleDashboardsActions.setAccessibleDashboards(listedDashboards),
         executionResultsActions.clearAllExecutionResults(),

package/esm/model/commandHandlers/dashboard/initializeDashboardHandler/loadMeasureParameterDependencies.d.ts

@@ -0,0 +1,12 @@
+import { type IInsight } from "@gooddata/sdk-model";
+import { type ICatalogMeasureParametersState } from "../../../store/catalog/catalogState.js";
+import { type DashboardContext } from "../../../types/commonTypes.js";
+/**
+ * Loads the dashboard-wide metric -> parameter dependency map from the workspace references service.
+ *
+ * @remarks
+ * Walks the dependency graph in `direction: "down"`, then collects parameter nodes reachable from
+ * each root metric, including transitive metric -> metric -> parameter chains. Disabled parameters
+ * return `uninitialized`; backend errors return `failed`.
+ */
+export declare function loadMeasureParameterDependencies(ctx: DashboardContext, insights: IInsight[], enableParameters: boolean): Promise<ICatalogMeasureParametersState>;

package/esm/model/commandHandlers/dashboard/initializeDashboardHandler/loadMeasureParameterDependencies.js

@@ -0,0 +1,98 @@
+// (C) 2026 GoodData Corporation
+import { insightMeasures, isIdentifierRef, isMeasureDefinition, objRefToString, } from "@gooddata/sdk-model";
+/**
+ * Loads the dashboard-wide metric -> parameter dependency map from the workspace references service.
+ *
+ * @remarks
+ * Walks the dependency graph in `direction: "down"`, then collects parameter nodes reachable from
+ * each root metric, including transitive metric -> metric -> parameter chains. Disabled parameters
+ * return `uninitialized`; backend errors return `failed`.
+ */
+export async function loadMeasureParameterDependencies(ctx, insights, enableParameters) {
+    if (!enableParameters) {
+        return { status: "uninitialized", byMetric: {} };
+    }
+    const metricRefs = collectMetricRefs(insights);
+    if (metricRefs.length === 0) {
+        return { status: "loaded", byMetric: {} };
+    }
+    try {
+        const result = await ctx.backend
+            .workspace(ctx.workspace)
+            .references()
+            .getReferences(metricRefs, { direction: "down" });
+        const byMetric = buildReachableParameterMap(metricRefs, result.edges);
+        return { status: "loaded", byMetric };
+    }
+    catch {
+        return { status: "failed", byMetric: {} };
+    }
+}
+function collectMetricRefs(insights) {
+    const seen = new Set();
+    const refs = [];
+    for (const insight of insights) {
+        for (const measure of insightMeasures(insight)) {
+            const def = measure.measure.definition;
+            if (!isMeasureDefinition(def)) {
+                continue;
+            }
+            const item = def.measureDefinition.item;
+            if (!isIdentifierRef(item)) {
+                continue;
+            }
+            const key = objRefToString(item);
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            refs.push(item);
+        }
+    }
+    return refs;
+}
+function buildReachableParameterMap(roots, edges) {
+    const adjacency = buildAdjacency(edges);
+    const result = {};
+    for (const root of roots) {
+        const reachableParameters = reachableParameterRefs(root, adjacency);
+        result[objRefToString(root)] = reachableParameters;
+    }
+    return result;
+}
+function buildAdjacency(edges) {
+    const adjacency = new Map();
+    for (const edge of edges) {
+        const fromKey = objRefToString(edge.from);
+        const toKey = objRefToString(edge.to);
+        const next = adjacency.get(fromKey) ?? [];
+        next.push({ to: edge.to, key: toKey });
+        adjacency.set(fromKey, next);
+    }
+    return adjacency;
+}
+function reachableParameterRefs(start, adjacency) {
+    const parameters = [];
+    const parametersSeen = new Set();
+    const visited = new Set([objRefToString(start)]);
+    const queue = [start];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        const neighbors = adjacency.get(objRefToString(node)) ?? [];
+        for (const neighbor of neighbors) {
+            if (visited.has(neighbor.key)) {
+                continue;
+            }
+            visited.add(neighbor.key);
+            if (neighbor.to.type === "parameter") {
+                if (!parametersSeen.has(neighbor.key)) {
+                    parametersSeen.add(neighbor.key);
+                    parameters.push(neighbor.to);
+                }
+                continue;
+            }
+            queue.push(neighbor.to);
+        }
+    }
+    return parameters;
+}

package/esm/model/commandHandlers/dashboard/initializeDashboardHandler/resolveDashboardConfig.js

@@ -135,6 +135,7 @@ export function* resolveDashboardConfig(ctx, cmd) {
         maxZoomLevel: config.maxZoomLevel === undefined
             ? settings.settings?.maxZoomLevel
             : config.maxZoomLevel,
+        isWhiteLabeled: config.isWhiteLabeled ?? settings.settings?.whiteLabeling?.enabled ?? false,
     };
 }
 const CONFIG_DEFAULTS = {

package/esm/model/commandHandlers/drill/common/mergeFilters.d.ts

@@ -1,12 +1,12 @@
-import { type FilterContextItem, type IAttributeFilter, type IDateFilter } from "@gooddata/sdk-model";
-type SourceFilter = IAttributeFilter | IDateFilter;
+import { type FilterContextItem, type IAttributeFilter, type IDateFilter, type IMeasureValueFilter } from "@gooddata/sdk-model";
+export type SourceFilter = IAttributeFilter | IDateFilter | IMeasureValueFilter;
 /**
  * Merges dashboard filters with source filters by intersecting attribute element values
  * for filters that target the same attribute (matched by display form ref).
  *
  * - Matching attribute filters: element values are intersected (AND semantics).
+ * - Matching measure value filters: conditions get replaced.
  * - Unmatched filters from either side: passed through as-is.
  * - Date filters: passed through as-is (no intersection).
  */
 export declare function mergeDashboardAndSourceFilters(dashboardFilters: FilterContextItem[], sourceFilters: SourceFilter[]): Array<FilterContextItem | SourceFilter>;
-export {};

package/esm/model/commandHandlers/drill/common/mergeFilters.js

@@ -1,10 +1,11 @@
 // (C) 2026 GoodData Corporation
-import { areObjRefsEqual, filterAttributeElements, filterObjRef, isAttributeFilterWithSelection, isDashboardAttributeFilter, isNegativeAttributeFilter, } from "@gooddata/sdk-model";
+import { areObjRefsEqual, filterAttributeElements, filterMeasureRef, filterObjRef, isAttributeFilterWithSelection, isDashboardAttributeFilter, isDashboardMeasureValueFilter, isMeasureValueFilter, isNegativeAttributeFilter, measureValueFilterConditions, } from "@gooddata/sdk-model";
 /**
  * Merges dashboard filters with source filters by intersecting attribute element values
  * for filters that target the same attribute (matched by display form ref).
  *
  * - Matching attribute filters: element values are intersected (AND semantics).
+ * - Matching measure value filters: conditions get replaced.
  * - Unmatched filters from either side: passed through as-is.
  * - Date filters: passed through as-is (no intersection).
  */
@@ -14,6 +15,22 @@ export function mergeDashboardAndSourceFilters(dashboardFilters, sourceFilters)
     }
     const usedSourceIndices = new Set();
     const mergedDashboardFilters = dashboardFilters.map((dashFilter) => {
+        if (isDashboardMeasureValueFilter(dashFilter)) {
+            const dashRef = dashFilter.dashboardMeasureValueFilter.measure;
+            const sourceIndex = sourceFilters.findIndex((sf, i) => {
+                if (usedSourceIndices.has(i) || !isMeasureValueFilter(sf)) {
+                    return false;
+                }
+                const sourceRef = filterMeasureRef(sf);
+                return sourceRef ? areObjRefsEqual(dashRef, sourceRef) : false;
+            });
+            if (sourceIndex === -1) {
+                return dashFilter;
+            }
+            usedSourceIndices.add(sourceIndex);
+            const sourceFilter = sourceFilters[sourceIndex];
+            return intersectMeasureValueFilters(dashFilter, sourceFilter);
+        }
         if (!isDashboardAttributeFilter(dashFilter)) {
             return dashFilter;
         }
@@ -35,6 +52,14 @@ export function mergeDashboardAndSourceFilters(dashboardFilters, sourceFilters)
     const remainingSourceFilters = sourceFilters.filter((_, i) => !usedSourceIndices.has(i));
     return [...mergedDashboardFilters, ...remainingSourceFilters];
 }
+function intersectMeasureValueFilters(dashFilter, sourceFilter) {
+    return {
+        dashboardMeasureValueFilter: {
+            ...dashFilter.dashboardMeasureValueFilter,
+            conditions: measureValueFilterConditions(sourceFilter),
+        },
+    };
+}
 function intersectAttributeFilters(dashFilter, sourceFilter) {
     const dashElements = dashFilter.attributeFilter.attributeElements;
     const dashNegative = dashFilter.attributeFilter.negativeSelection;

package/esm/model/commandHandlers/drill/common/sourceDrillFilters.d.ts

@@ -1,6 +1,7 @@
 import { type IAttributeFilter, type IDateFilter, type IDrillToDashboard, type IDrillToInsight, type IFilter, type IInsight, type SourceInsightFilterObjRef } from "@gooddata/sdk-model";
+import { type SourceFilter } from "./mergeFilters.js";
 type IDrillDefinitionWithIncludedSourceFilters = Pick<IDrillToDashboard | IDrillToInsight, "origin" | "includedSourceInsightFiltersObjRefs" | "includedSourceMeasureFiltersObjRefs">;
 export declare function getIncludedSourceInsightFilters(sourceInsight: IInsight | null, includedSourceInsightFiltersObjRefs: SourceInsightFilterObjRef[]): IFilter[];
 export declare function getIncludedSourceMeasureFilters(sourceInsight: IInsight | null, drillDefinition: IDrillDefinitionWithIncludedSourceFilters): Array<IAttributeFilter | IDateFilter>;
-export declare function getIncludedSourceFiltersForDashboard(sourceInsight: IInsight | null, drillDefinition: IDrillDefinitionWithIncludedSourceFilters): Array<IAttributeFilter | IDateFilter>;
+export declare function getIncludedSourceFiltersForDashboard(sourceInsight: IInsight | null, drillDefinition: IDrillDefinitionWithIncludedSourceFilters): Array<SourceFilter>;
 export {};

package/esm/model/commandHandlers/drill/common/sourceDrillFilters.js

@@ -1,6 +1,6 @@
 // (C) 2021-2026 GoodData Corporation
-import { insightFilters, insightMeasures, isAttributeFilter, isDateFilter, isMeasureValueFilter, isRankingFilter, } from "@gooddata/sdk-model";
-import { getSourceMeasureFiltersForDrillDefinition, isMatchingSourceInsightFilter, } from "../../../../_staging/drills/drillingUtils.js";
+import { filterMeasureRef, insightFilters, insightMeasures, isAttributeFilter, isDateFilter, isMeasureValueFilter, isRankingFilter, } from "@gooddata/sdk-model";
+import { getSourceMeasureFiltersForDrillDefinition, isMatchingSourceInsightFilter, resolveSourceMeasureRef, } from "../../../../_staging/drills/drillingUtils.js";
 export function getIncludedSourceInsightFilters(sourceInsight, includedSourceInsightFiltersObjRefs) {
     const sourceFilters = sourceInsight
         ? insightFilters(sourceInsight).filter((filter) => isAttributeFilter(filter) ||
@@ -18,13 +18,33 @@ export function getIncludedSourceMeasureFilters(sourceInsight, drillDefinition)
     return includedSourceFilters(sourceMeasureFilters, drillDefinition.includedSourceMeasureFiltersObjRefs ?? []);
 }
 export function getIncludedSourceFiltersForDashboard(sourceInsight, drillDefinition) {
+    const sourceInsightMeasures = sourceInsight ? insightMeasures(sourceInsight) : [];
     const sourceMeasureFilters = getIncludedSourceMeasureFilters(sourceInsight, drillDefinition);
-    const sourceInsightFilters = getIncludedSourceInsightFilters(sourceInsight, drillDefinition.includedSourceInsightFiltersObjRefs ?? []).filter((filter) => {
-        return isAttributeFilter(filter) || isDateFilter(filter);
-    });
+    const sourceInsightFilters = getIncludedSourceInsightFilters(sourceInsight, drillDefinition.includedSourceInsightFiltersObjRefs ?? [])
+        .filter((filter) => {
+        return isAttributeFilter(filter) || isDateFilter(filter) || isMeasureValueFilter(filter);
+    })
+        .flatMap((filter) => normalizeSourceFilterForDashboard(filter, sourceInsightMeasures));
     // Keep the same precedence as drill-to-insight: measure filters win over source insight filters.
     return [...sourceMeasureFilters, ...sourceInsightFilters];
 }
+function normalizeSourceFilterForDashboard(filter, sourceInsightMeasures) {
+    if (!isMeasureValueFilter(filter)) {
+        return [filter];
+    }
+    const measureRef = resolveSourceMeasureRef(filterMeasureRef(filter), sourceInsightMeasures);
+    if (!measureRef) {
+        return [];
+    }
+    return [
+        {
+            measureValueFilter: {
+                ...filter.measureValueFilter,
+                measure: measureRef,
+            },
+        },
+    ];
+}
 function includedSourceFilters(sourceFilters, includedFilterObjRefs) {
     return sourceFilters.filter((sourceFilter) => {
         return includedFilterObjRefs.some((includedFilterObjRef) => isMatchingSourceInsightFilter(sourceFilter, includedFilterObjRef));

package/esm/model/commandHandlers/drill/drillToDashboardHandler.js

@@ -3,7 +3,7 @@ import { compact, isEmpty, isEqual } from "lodash-es";
 import { call, put, select } from "redux-saga/effects";
 import { invariant } from "ts-invariant";
 import { areObjRefsEqual, dashboardFilterLocalIdentifier, insightMeasures, isDashboardAttributeFilter, isDashboardMeasureValueFilter, isDateFilter, isSimpleMeasure, measureFilters, newAllTimeDashboardDateFilter, } from "@gooddata/sdk-model";
-import { dashboardAttributeFilterItemToAttributeFilter, dashboardDateFilterToDateFilterByWidget, } from "../../../converters/filterConverters.js";
+import { dashboardAttributeFilterItemToAttributeFilter, dashboardDateFilterToDateFilterByWidget, dashboardMeasureValueFilterToMeasureValueFilter, } from "../../../converters/filterConverters.js";
 import { switchDashboardTab } from "../../commands/tabs.js";
 import { drillToDashboardRequested, drillToDashboardResolved, } from "../../events/drill.js";
 import { generateFilterLocalIdentifier } from "../../store/_infra/generators.js";
@@ -12,7 +12,7 @@ import { selectCatalogDateAttributes } from "../../store/catalog/catalogSelector
 import { selectEnableMultipleDateFilters } from "../../store/config/configSelectors.js";
 import { selectInsightByRef } from "../../store/insights/insightsSelectors.js";
 import { selectAttributeFilterConfigsDisplayAsLabelMap, selectAttributeFilterConfigsOverrides, } from "../../store/tabs/attributeFilterConfigs/attributeFilterConfigsSelectors.js";
-import { selectFilterContextAttributeFilterItems, selectFilterContextDateFilter, selectFilterContextDraggableFilterItems, } from "../../store/tabs/filterContext/filterContextSelectors.js";
+import { selectFilterContextAttributeFilterItems, selectFilterContextDateFilter, selectFilterContextDraggableFilterItems, selectFilterContextMeasureValueFilters, } from "../../store/tabs/filterContext/filterContextSelectors.js";
 import { selectAnalyticalWidgetByRef } from "../../store/tabs/layout/layoutSelectors.js";
 import { convertIntersectionToAttributeFilters, removeIgnoredValuesFromDrillIntersection, } from "./common/intersectionUtils.js";
 import { mergeDashboardAndSourceFilters } from "./common/mergeFilters.js";
@@ -36,16 +36,17 @@ export function* drillToDashboardHandler(ctx, cmd) {
     const supportsMultipleDateFilters = yield select(selectSupportsMultipleDateFilters);
     const enableMultipleDateFilters = yield select(selectEnableMultipleDateFilters);
     const includeOtherDateFilters = supportsMultipleDateFilters && enableMultipleDateFilters;
-    const allOtherFilters = yield select(selectAllOtherFilters);
+    const allDraggableFilters = yield select(selectAllDraggableFilters);
     const allAttributeFilters = yield select(selectAllAttributeFilters);
+    const allMeasureValueFilters = yield select(selectAllMeasureValueFilters);
+    const allNonDateFilters = [...allAttributeFilters, ...allMeasureValueFilters];
+    const dashboardFiltersToResolve = includeOtherDateFilters ? allDraggableFilters : allNonDateFilters;
     const widgetAwareFilters = isDrillingToSelf
         ? []
-        : yield call(getWidgetAwareDashboardFilters, ctx, widget, includeOtherDateFilters);
+        : yield call(getWidgetAwareDashboardFilters, ctx, widget, dashboardFiltersToResolve);
     const candidateDashboardFilters = isDrillingToSelf
         ? // if drilling to self, just take all filters
-            includeOtherDateFilters
-                ? allOtherFilters
-                : allAttributeFilters
+            dashboardFiltersToResolve
         : // if drilling to other, resolve widget filter ignores
             widgetAwareFilters;
     const dashboardFilters = removeIgnoredDashboardFilters(candidateDashboardFilters, ignoredDashboardFilterIds);
@@ -122,13 +123,19 @@ function selectDrillingDateFilter(state) {
 function selectAllAttributeFilters(state) {
     return selectFilterContextAttributeFilterItems(state);
 }
-function selectAllOtherFilters(state) {
+function selectAllMeasureValueFilters(state) {
+    return selectFilterContextMeasureValueFilters(state);
+}
+function selectAllDraggableFilters(state) {
     return selectFilterContextDraggableFilterItems(state);
 }
 function convertFilterItemsToFilters(filter, widget) {
     if ("dateFilter" in filter) {
         return dashboardDateFilterToDateFilterByWidget(filter, widget);
     }
+    if (isDashboardMeasureValueFilter(filter)) {
+        return dashboardMeasureValueFilterToMeasureValueFilter(filter);
+    }
     return dashboardAttributeFilterItemToAttributeFilter(filter);
 }
 function removeIgnoredDashboardFilters(filters, ignoredDashboardFilterIds) {
@@ -140,15 +147,9 @@ function removeIgnoredDashboardFilters(filters, ignoredDashboardFilterIds) {
         return !localIdentifier || !ignoredDashboardFilterIds.has(localIdentifier);
     });
 }
-function* getWidgetAwareDashboardFilters(ctx, widget, includeOtherDateFilters) {
-    const filtersIncludingDateFilters = yield select(selectFilterContextDraggableFilterItems);
-    const attributeFilters = yield select(selectFilterContextAttributeFilterItems);
-    const filterContextItems = includeOtherDateFilters ? filtersIncludingDateFilters : attributeFilters;
+function* getWidgetAwareDashboardFilters(ctx, widget, filterContextItems) {
     const attributeFilterConfigs = yield select(selectAttributeFilterConfigsOverrides);
-    // Drill-to-dashboard does not transfer measure value filters between dashboards in this iteration.
-    // TODO INE: will be solved in https://gooddata.atlassian.net/browse/CQ-2285
-    const drillTransferableItems = filterContextItems.filter((item) => !isDashboardMeasureValueFilter(item));
-    const filtersPairs = drillTransferableItems.map((filter) => ({
+    const filtersPairs = filterContextItems.map((filter) => ({
         filter: convertFilterItemsToFilters(filter, widget),
         originalFilter: filter,
     }));

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

@@ -3,7 +3,7 @@ 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, 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, 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";
@@ -455,13 +455,16 @@ function* getMeasureValueFiltersUpdateActions(measureValueFilters, resetOthers)
     const currentMeasureValueFilters = yield select(selectFilterContextMeasureValueFilters);
     const currentByLocalId = new Map(currentMeasureValueFilters.map((f) => [dashboardMeasureValueFilterLocalIdentifier(f), f]));
     for (const incoming of measureValueFilters) {
-        const localIdentifier = dashboardMeasureValueFilterLocalIdentifier(incoming);
+        const incomingLocalIdentifier = dashboardMeasureValueFilterLocalIdentifier(incoming);
+        const currentFilter = currentByLocalId.get(incomingLocalIdentifier) ??
+            currentMeasureValueFilters.find((current) => areObjRefsEqual(dashboardFilterObjRef(current), dashboardFilterObjRef(incoming)));
         // Only update filters that already exist on the dashboard. Adding/removing MVFs is an
         // edit-mode operation and is not part of changeFilterContextSelection in view mode.
-        if (!currentByLocalId.has(localIdentifier)) {
-            console.warn(`changeFilterContextSelection: ignoring measure value filter with unknown localIdentifier "${localIdentifier}". The dashboard does not currently have a measure value filter with this id; adding new MVFs is not supported in view mode.`);
+        if (!currentFilter) {
+            console.warn(`changeFilterContextSelection: ignoring measure value filter with unknown localIdentifier "${incomingLocalIdentifier}". The dashboard does not currently have a measure value filter with this id or metric; adding new MVFs is not supported in view mode.`);
             continue;
         }
+        const localIdentifier = dashboardMeasureValueFilterLocalIdentifier(currentFilter);
         handledLocalIds.add(localIdentifier);
         updateActions.push(tabsActions.changeMeasureValueFilterCondition({
             localIdentifier,

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

@@ -1,5 +1,6 @@
 // (C) 2026 GoodData Corporation
 import { call, put, select } from "redux-saga/effects";
+import { dashboardFilterObjRef } from "@gooddata/sdk-model";
 import { measureValueFilterRemoved } from "../../../events/filters.js";
 import { invalidArgumentsProvided } from "../../../events/general.js";
 import { dispatchDashboardEvent } from "../../../store/_infra/eventDispatcher.js";
@@ -12,8 +13,14 @@ export function* removeMeasureValueFilterHandler(ctx, cmd) {
     if (!affectedFilter) {
         throw invalidArgumentsProvided(ctx, cmd, `Filter with localIdentifier ${localIdentifier} not found.`);
     }
+    const removedMeasureRef = dashboardFilterObjRef(affectedFilter);
     yield put(tabsActions.removeMeasureValueFilter({ localIdentifier }));
     yield put(tabsActions.removeMeasureValueFilterConfig(localIdentifier));
+    if (removedMeasureRef) {
+        yield put(tabsActions.removeIgnoredMeasureValueFilter({
+            measureRefs: [removedMeasureRef],
+        }));
+    }
     yield dispatchDashboardEvent(measureValueFilterRemoved(ctx, affectedFilter, cmd.correlationId));
     yield call(dispatchFilterContextChanged, ctx, cmd);
 }

package/esm/model/react/useWidgetFilters.js

@@ -2,7 +2,7 @@
 import { useEffect, useMemo, useState } from "react";
 import stringify from "json-stable-stringify";
 import { isEqual } from "lodash-es";
-import { areObjRefsEqual, dashboardAttributeFilterItemDisplayForm, dashboardAttributeFilterItemLocalIdentifier, filterObjRef, isAllTimeDashboardDateFilter, isAllValuesDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardDateFilter, isDashboardDateFilterWithDimension, } from "@gooddata/sdk-model";
+import { areObjRefsEqual, dashboardAttributeFilterItemDisplayForm, dashboardAttributeFilterItemLocalIdentifier, filterObjRef, isAllTimeDashboardDateFilter, isAllValuesDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardDateFilter, isDashboardDateFilterWithDimension, isDashboardMeasureValueFilter, } from "@gooddata/sdk-model";
 import { usePrevious } from "@gooddata/sdk-ui";
 import { safeSerializeObjRef } from "../../_staging/metadata/safeSerializeObjRef.js";
 import { queryWidgetFilters } from "../queries/widgets.js";
@@ -168,6 +168,9 @@ function useNonIgnoredFilters(widget) {
         else if (isDashboardDateFilterWithDimension(filter)) {
             return nonIgnoredFilterState.nonIgnoredFilterRefs.some((validRef) => areObjRefsEqual(validRef, filter.dateFilter.dataSet));
         }
+        else if (isDashboardMeasureValueFilter(filter)) {
+            return nonIgnoredFilterState.nonIgnoredFilterRefs.some((validRef) => areObjRefsEqual(validRef, filter.dashboardMeasureValueFilter.measure));
+        }
         else {
             // Common date filter: include only when widget does not ignore date filters
             return !widgetIgnoresDateFilter;

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

@@ -1,6 +1,6 @@
 import { type Action, type CaseReducer } from "@reduxjs/toolkit";
 import { type ICatalogAttribute, type ICatalogAttributeHierarchy, type ICatalogDateDataset, type ICatalogFact, type ICatalogMeasure, type IDateHierarchyTemplate } from "@gooddata/sdk-model";
-import { type CatalogState, type ICatalogParametersState } from "./catalogState.js";
+import { type CatalogState, type ICatalogMeasureParametersState, type ICatalogParametersState } from "./catalogState.js";
 type CatalogReducer<A extends Action> = CaseReducer<CatalogState, A>;
 /**
  * @public
@@ -45,5 +45,9 @@ export declare const catalogReducers: {
         payload: ICatalogParametersState;
         type: string;
     }>;
+    setCatalogMeasureParameters: CatalogReducer<{
+        payload: ICatalogMeasureParametersState;
+        type: string;
+    }>;
 };
 export {};

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

@@ -32,6 +32,9 @@ const deleteAttributeHierarchy = (state, action) => {
 const setCatalogParameters = (state, action) => {
     state.parameters = action.payload;
 };
+const setCatalogMeasureParameters = (state, action) => {
+    state.measureParameters = action.payload;
+};
 export const catalogReducers = {
     setCatalogItems,
     setCatalogMeasuresAndFacts,
@@ -39,4 +42,5 @@ export const catalogReducers = {
     updateAttributeHierarchy,
     deleteAttributeHierarchy,
     setCatalogParameters,
+    setCatalogMeasureParameters,
 };

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

@@ -1,8 +1,8 @@
-import { type IAttributeDisplayFormMetadataObject, type ICatalogAttribute, type ICatalogAttributeHierarchy, type ICatalogDateAttribute, type ICatalogDateAttributeHierarchy, type ICatalogDateDataset, type ICatalogFact, type ICatalogMeasure, type IDateHierarchyTemplate, type IParameterMetadataObject, type ObjRef } from "@gooddata/sdk-model";
+import { type IAttributeDisplayFormMetadataObject, type ICatalogAttribute, type ICatalogAttributeHierarchy, type ICatalogDateAttribute, type ICatalogDateAttributeHierarchy, type ICatalogDateDataset, type ICatalogFact, type ICatalogMeasure, type IDateHierarchyTemplate, type IParameterMetadataObject, type IdentifierRef, type ObjRef } from "@gooddata/sdk-model";
 import { type CatalogDateAttributeWithDataset } from "../../../_staging/catalog/dateAttributeWithDatasetMap.js";
 import { type ObjRefMap } from "../../../_staging/metadata/objRefMap.js";
 import { type DashboardSelector } from "../types.js";
-import { type CatalogParametersStatus } from "./catalogState.js";
+import { type CatalogMeasureParametersStatus, type CatalogParametersStatus } from "./catalogState.js";
 /**
  * @public
  */
@@ -32,6 +32,19 @@ export declare const selectCatalogParametersStatus: DashboardSelector<CatalogPar
  * @alpha
  */
 export declare const selectCatalogParametersIsLoaded: DashboardSelector<boolean>;
+/**
+ * Returns the dashboard-wide map from metric ref string to the parameter refs the metric depends on.
+ * The map is populated during dashboard initialization from the workspace references service.
+ *
+ * @alpha
+ */
+export declare const selectCatalogMeasureParameters: DashboardSelector<Record<string, IdentifierRef[]>>;
+/**
+ * Returns the load status of the dashboard-wide metric → parameter dependency map.
+ *
+ * @alpha
+ */
+export declare const selectCatalogMeasureParametersStatus: DashboardSelector<CatalogMeasureParametersStatus>;
 /**
  * @alpha
  */

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

@@ -39,6 +39,19 @@ export const selectCatalogParametersStatus = createSelector(selectSelf, (state)
  * @alpha
  */
 export const selectCatalogParametersIsLoaded = createSelector(selectCatalogParametersStatus, (status) => status === "loaded");
+/**
+ * Returns the dashboard-wide map from metric ref string to the parameter refs the metric depends on.
+ * The map is populated during dashboard initialization from the workspace references service.
+ *
+ * @alpha
+ */
+export const selectCatalogMeasureParameters = createSelector(selectSelf, (state) => state.measureParameters.byMetric);
+/**
+ * Returns the load status of the dashboard-wide metric → parameter dependency map.
+ *
+ * @alpha
+ */
+export const selectCatalogMeasureParametersStatus = createSelector(selectSelf, (state) => state.measureParameters.status);
 /**
  * @alpha
  */