@gooddata/sdk-ui-dashboard 11.35.0-alpha.6 → 11.35.0

package/esm/__version.d.ts

@@ -1,3 +1,3 @@
-export declare const LIB_VERSION = "11.35.0-alpha.6";
+export declare const LIB_VERSION = "11.35.0";
 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.35.0-alpha.6";
+export const LIB_VERSION = "11.35.0";
 export const LIB_DESCRIPTION = "GoodData SDK - Dashboard Component";
 export const LIB_NAME = "@gooddata/sdk-ui-dashboard";

package/esm/_staging/dashboard/dashboardFilterContext.js

@@ -1,6 +1,7 @@
 // (C) 2021-2026 GoodData Corporation
+import { v4 as uuidv4 } from "uuid";
 import { NotSupported } from "@gooddata/sdk-backend-spi";
-import { dashboardAttributeFilterItemFilterElementsBy, dashboardFilterLocalIdentifier, filterAttributeElements, filterLocalIdentifier, filterObjRef, isAbsoluteDateFilter, isAllTimeDateFilter, isArbitraryAttributeFilter, isAttributeFilterWithSelection, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardAttributeFilterItem, isMatchAttributeFilter, isNegativeAttributeFilter, isRelativeBoundedDateFilter, isRelativeDateFilter, isTempFilterContext, newAbsoluteDashboardDateFilter, newAllTimeDashboardDateFilter, newRelativeDashboardDateFilter, } from "@gooddata/sdk-model";
+import { dashboardAttributeFilterItemFilterElementsBy, dashboardFilterLocalIdentifier, filterAttributeElements, filterLocalIdentifier, filterObjRef, isAbsoluteDateFilter, isAllTimeDateFilter, isArbitraryAttributeFilter, isAttributeFilterWithSelection, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardAttributeFilterItem, isMatchAttributeFilter, isMeasureValueFilter, isNegativeAttributeFilter, isObjRef, isRelativeBoundedDateFilter, isRelativeDateFilter, isTempFilterContext, measureValueFilterConditions, measureValueFilterMeasure, newAbsoluteDashboardDateFilter, newAllTimeDashboardDateFilter, newRelativeDashboardDateFilter, } from "@gooddata/sdk-model";
 import { createDefaultFilterContext } from "./defaultFilterContext.js";
 /**
  * Given a dashboard, this function will inspect its filter context and always return a valid instance of IFilterContextDefinition to use.
@@ -154,5 +155,21 @@ export function dashboardFilterToFilterContextItem(filter, keepDatasets) {
     else if (isRelativeDateFilter(filter)) {
         return newRelativeDashboardDateFilter(filter.relativeDateFilter.granularity, filter.relativeDateFilter.from, filter.relativeDateFilter.to, keepDatasets ? filter.relativeDateFilter.dataSet : undefined, filter.relativeDateFilter.localIdentifier, isRelativeBoundedDateFilter(filter) ? filter.relativeDateFilter.boundedFilter : undefined, filter.relativeDateFilter.emptyValueHandling);
     }
+    else if (isMeasureValueFilter(filter)) {
+        const measure = measureValueFilterMeasure(filter);
+        // Dashboard MVF requires an ObjRef (catalog metric reference); LocalIdRef cannot
+        // survive the round-trip from execution to filter context.
+        if (!isObjRef(measure)) {
+            throw new NotSupported(`Unsupported filter type! Please provide valid dashboard filter. Filter: ${JSON.stringify(filter)}`);
+        }
+        const conditions = measureValueFilterConditions(filter);
+        return {
+            dashboardMeasureValueFilter: {
+                measure,
+                localIdentifier: filter.measureValueFilter.localIdentifier ?? uuidv4(),
+                ...(conditions ? { conditions } : {}),
+            },
+        };
+    }
     throw new NotSupported(`Unsupported filter type! Please provide valid dashboard filter. Filter: ${JSON.stringify(filter)}`);
 }

package/esm/_staging/sharedHooks/useFiltersNamings.d.ts

@@ -1,6 +1,6 @@
 import { type FilterContextItem, type ObjRef } from "@gooddata/sdk-model";
 export type FilterNaming = {
-    type: "attributeFilter" | "dateFilter";
+    type: "attributeFilter" | "dateFilter" | "measureValueFilter";
     all: boolean;
     id: string;
     title: string;

package/esm/_staging/sharedHooks/useFiltersNamings.js

@@ -1,11 +1,11 @@
 // (C) 2024-2026 GoodData Corporation
 import { useIntl } from "react-intl";
 import { v4 as uuidv4 } from "uuid";
-import { dashboardAttributeFilterItemLocalIdentifier, dashboardAttributeFilterItemTitle, getAttributeElementsItems, isAllTimeDashboardDateFilter, isAllValuesDashboardAttributeFilter, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardDateFilterWithDimension, isDashboardMatchAttributeFilter, serializeObjRef, } from "@gooddata/sdk-model";
-import { DateFilterHelpers, getAttributeFilterSubtitle, getLocalizedIcuDateFormatPattern, getTextFilterStateText, } from "@gooddata/sdk-ui-filters";
+import { areObjRefsEqual, dashboardAttributeFilterItemLocalIdentifier, dashboardAttributeFilterItemTitle, getAttributeElementsItems, isAllDashboardMeasureValueFilter, isAllTimeDashboardDateFilter, isAllValuesDashboardAttributeFilter, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardDateFilterWithDimension, isDashboardMatchAttributeFilter, isDashboardMeasureValueFilter, objRefToString, serializeObjRef, } from "@gooddata/sdk-model";
+import { DateFilterHelpers, getAttributeFilterSubtitle, getLocalizedIcuDateFormatPattern, getMeasureValueFilterConditionLabel, getTextFilterStateText, } from "@gooddata/sdk-ui-filters";
 import { useDashboardSelector } from "../../model/react/DashboardStoreProvider.js";
-import { selectAllCatalogAttributesMap } from "../../model/store/catalog/catalogSelectors.js";
-import { selectLocale, selectSettings } from "../../model/store/config/configSelectors.js";
+import { selectAllCatalogAttributesMap, selectCatalogMeasures, } from "../../model/store/catalog/catalogSelectors.js";
+import { selectLocale, selectSeparators, selectSettings } from "../../model/store/config/configSelectors.js";
 import { convertDateFilterConfigToDateFilterOptions } from "../dateFilterConfig/dateFilterConfigConverters.js";
 import { matchDateFilterToDateFilterOptionWithPreference } from "../dateFilterConfig/dateFilterOptionMapping.js";
 import { defaultDateFilterConfig } from "../dateFilterConfig/defaultConfig.js";
@@ -13,6 +13,10 @@ import { ensureAllTimeFilterForExport } from "../exportUtils/filterUtils.js";
 import { useAttributeFilterDisplayFormFromMap } from "./useAttributeFilterDisplayFormFromMap.js";
 import { useCommonDateFilterTitle } from "./useCommonDateFilterTitle.js";
 import { useDateFiltersTitles } from "./useDateFiltersTitles.js";
+const PERCENT_FORMAT_REGEX = /%/;
+function isPercentageFormat(format) {
+    return !!format && PERCENT_FORMAT_REGEX.test(format);
+}
 /**
  * Hook that gathers all dependencies needed for filter naming transformations.
  * Reusable across different hooks that need to transform filters to namings.
@@ -29,6 +33,8 @@ function useFilterNamingDependencies(filtersForTitles) {
         : settings.responsiveUiDateFormat;
     const getAttributeFilterDisplayFormFromMap = useAttributeFilterDisplayFormFromMap();
     const attrMap = useDashboardSelector(selectAllCatalogAttributesMap);
+    const measures = useDashboardSelector(selectCatalogMeasures);
+    const separators = useDashboardSelector(selectSeparators);
     const dateFiltersForTitles = filtersForTitles.filter(isDashboardDateFilterWithDimension);
     const commonDateFilterTitle = useCommonDateFilterTitle(intl);
     const allDateFiltersTitlesObj = useDateFiltersTitles(dateFiltersForTitles, intl);
@@ -38,6 +44,8 @@ function useFilterNamingDependencies(filtersForTitles) {
         dateFormat,
         getAttributeFilterDisplayFormFromMap,
         attrMap,
+        measures,
+        separators,
         commonDateFilterTitle,
         allDateFiltersTitlesObj,
     };
@@ -47,7 +55,7 @@ function useFilterNamingDependencies(filtersForTitles) {
  * Extracted to avoid code duplication between useFiltersNamings and useFiltersByTabNamings.
  */
 function transformFiltersToNamings(filtersToDisplay, deps) {
-    const { intl, dateFormat, getAttributeFilterDisplayFormFromMap, attrMap, commonDateFilterTitle, allDateFiltersTitlesObj, } = deps;
+    const { intl, dateFormat, getAttributeFilterDisplayFormFromMap, attrMap, measures, separators, commonDateFilterTitle, allDateFiltersTitlesObj, } = deps;
     // we want to show all time filter in the list of filters even if it is not stored
     const extendedFiltersToDisplay = ensureAllTimeFilterForExport(filtersToDisplay);
     return extendedFiltersToDisplay.map((filter) => {
@@ -127,6 +135,25 @@ function transformFiltersToNamings(filtersToDisplay, deps) {
                 subtitle,
             };
         }
+        else if (isDashboardMeasureValueFilter(filter)) {
+            const { measure, localIdentifier, title: customTitle, conditions, } = filter.dashboardMeasureValueFilter;
+            const catalogMetric = measures.find((m) => areObjRefsEqual(m.measure.ref, measure));
+            const defaultTitle = catalogMetric?.measure.title ?? objRefToString(measure);
+            const title = customTitle ?? defaultTitle;
+            const format = catalogMetric?.measure.format;
+            const usePercentage = isPercentageFormat(format);
+            const subtitle = getMeasureValueFilterConditionLabel(intl, conditions, {
+                usePercentage,
+                separators,
+            });
+            return {
+                type: "measureValueFilter",
+                all: isAllDashboardMeasureValueFilter(filter),
+                id: localIdentifier,
+                title,
+                subtitle,
+            };
+        }
         else if (isDashboardMatchAttributeFilter(filter)) {
             const { operator: matchOperator, literal, negativeSelection, displayForm, } = filter.matchAttributeFilter;
             const filterDisplayForm = getAttributeFilterDisplayFormFromMap(displayForm);

package/esm/index.d.ts

@@ -197,7 +197,7 @@ export { newDrillToSameDashboardHandler } from "./model/eventHandlers/drillToSam
 export { type IHeadlessDashboardConfig, type IMonitoredAction, HeadlessDashboard, } from "./model/headlessDashboard/HeadlessDashboard.js";
 export { isTemporaryIdentity, getWidgetTitle } from "./model/utils/dashboardItemUtils.js";
 export { existBlacklistHierarchyPredicate } from "./model/utils/attributeHierarchyUtils.js";
-export { removeDateFilters, removeIgnoredWidgetFilters } from "./model/utils/widgetFilters.js";
+export { getAttributeFilters, removeIgnoredWidgetFilters } from "./model/utils/widgetFilters.js";
 export { getAuthor } from "./model/utils/author.js";
 export type { ICustomComponentBase, IDraggingComponentProps, IDropTargetComponentProps, IAttributeFilterDraggingComponentProps, IDateFilterDraggingComponentProps, IInsightDraggingComponentProps, IKpiDraggingComponentProps, IRichTextDraggingComponentProps, IVisualizationSwitcherDraggingComponentProps, IDashboardLayoutDraggingComponentProps, ICustomDraggingComponentProps, AttributeFilterDraggingComponent, DateFilterDraggingComponent, InsightDraggingComponent, KpiDraggingComponent, RichTextDraggingComponent, VisualizationSwitcherDraggingComponent, DashboardLayoutDraggingComponent, CustomDraggingComponent, AttributeFilterDraggableComponent, DateFilterDraggableComponent, InsightDraggableComponent, KpiDraggableComponent, RichTextDraggableComponent, VisualizationSwitcherDraggableComponent, DashboardLayoutDraggableComponent, CustomDraggableComponent, DraggableComponent, DropTarget, ICreatePanelItemComponentProps, CustomCreatePanelItemComponent, CreatableByDragComponent, CreatablePlaceholderComponent, CustomWidgetConfigPanelComponent, IWidgetConfigPanelProps, ConfigurableWidget, AttributeFilterComponentSet, DateFilterComponentSet, InsightWidgetComponentSet, RichTextWidgetComponentSet, VisualizationSwitcherWidgetComponentSet, DashboardLayoutWidgetComponentSet, CustomWidgetComponentSet, InsightComponentSetProvider, } from "./presentation/componentDefinition/types.js";
 export { renderModeAware } from "./presentation/componentDefinition/renderModeAware.js";

package/esm/index.js

@@ -140,7 +140,7 @@ export { newDrillToSameDashboardHandler } from "./model/eventHandlers/drillToSam
 export { HeadlessDashboard, } from "./model/headlessDashboard/HeadlessDashboard.js";
 export { isTemporaryIdentity, getWidgetTitle } from "./model/utils/dashboardItemUtils.js";
 export { existBlacklistHierarchyPredicate } from "./model/utils/attributeHierarchyUtils.js";
-export { removeDateFilters, removeIgnoredWidgetFilters } from "./model/utils/widgetFilters.js";
+export { getAttributeFilters, removeIgnoredWidgetFilters } from "./model/utils/widgetFilters.js";
 export { getAuthor } from "./model/utils/author.js";
 export { renderModeAware } from "./presentation/componentDefinition/renderModeAware.js";
 export { Dashboard } from "./presentation/dashboard/Dashboard.js";

package/esm/kdaDialog/dialog/hooks/useChangeAnalysis.js

@@ -2,9 +2,9 @@
 import { useEffect, useMemo } from "react";
 import stringify from "json-stable-stringify";
 import { ClientFormatterFacade } from "@gooddata/number-formatter";
-import { isAllValuesDashboardAttributeFilter, newAttribute, } from "@gooddata/sdk-model";
+import { isAllDashboardMeasureValueFilter, isAllValuesDashboardAttributeFilter, newAttribute, } from "@gooddata/sdk-model";
 import { useBackendStrict, useCancelablePromise, useWorkspaceStrict } from "@gooddata/sdk-ui";
-import { dashboardAttributeFilterItemToAttributeFilter } from "../../../converters/filterConverters.js";
+import { dashboardAttributeFilterItemToAttributeFilter, dashboardMeasureValueFilterToMeasureValueFilter, } from "../../../converters/filterConverters.js";
 import { useAttribute } from "../../hooks/useAttribute.js";
 import { useDateAttribute } from "../../hooks/useDateAttribute.js";
 import { useRelevantFilters } from "../../hooks/useRelevantFilters.js";
@@ -18,14 +18,15 @@ export function useChangeAnalysis() {
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [state.selectedUpdated]);
     const filters = useRelevantFilters();
+    const measureValueFilters = state.measureValueFilters;
     const loading = state.relevantStatus === "loading" || state.relevantStatus === "pending";
-    const results = useChangeAnalysisResults(definition, attributes, filters, loading);
+    const results = useChangeAnalysisResults(definition, attributes, filters, measureValueFilters, loading);
     const list = useKdaStateWithList(results, definition);
     useEffect(() => {
         setState(list);
     }, [list, setState]);
 }
-function useChangeAnalysisResults(definition, attrs, attrFilters, loading) {
+function useChangeAnalysisResults(definition, attrs, attrFilters, measureValueFilters, loading) {
     const backend = useBackendStrict();
     const workspace = useWorkspaceStrict();
     const from = definition?.range[0].date;
@@ -38,6 +39,13 @@ function useChangeAnalysisResults(definition, attrs, attrFilters, loading) {
             .map((f) => stringify(f))
             .join();
     }, [attrFilters]);
+    // Use the same fingerprint approach for MVF so cancelable-promise recomputes only when conditions actually change.
+    const measureValueFiltersFingerprint = useMemo(() => {
+        return measureValueFilters
+            .filter((f) => !isAllDashboardMeasureValueFilter(f))
+            .map((f) => stringify(f))
+            .join();
+    }, [measureValueFilters]);
     const dateAttribute = dateAttributeFinder(definition?.dateAttribute);
     const shouldComputeChangeAnalysis = !!definition && !!dateAttribute && !loading;
     const { includeTags, excludeTags } = useTags();
@@ -51,9 +59,16 @@ function useChangeAnalysisResults(definition, attrs, attrFilters, loading) {
                     return attr ? newAttribute(ref) : null;
                 })
                     .filter(Boolean);
-                const filters = attrFilters
+                const attributeExecutionFilters = attrFilters
                     .filter((f) => !isAllValuesDashboardAttributeFilter(f))
                     .map(dashboardAttributeFilterItemToAttributeFilter);
+                const measureValueExecutionFilters = measureValueFilters
+                    .filter((f) => !isAllDashboardMeasureValueFilter(f))
+                    .map(dashboardMeasureValueFilterToMeasureValueFilter);
+                const filters = [
+                    ...attributeExecutionFilters,
+                    ...measureValueExecutionFilters,
+                ];
                 return backend
                     .workspace(workspace)
                     .keyDriverAnalysis()
@@ -83,6 +98,7 @@ function useChangeAnalysisResults(definition, attrs, attrFilters, loading) {
         loading,
         dateAttribute,
         attributeFiltersFingerprint,
+        measureValueFiltersFingerprint,
         includeTags,
         excludeTags,
     ]);

package/esm/kdaDialog/internalTypes.d.ts

@@ -1,4 +1,4 @@
-import { type DashboardAttributeFilterItem, type ICatalogDateAttribute, type ISeparators, type ObjRef } from "@gooddata/sdk-model";
+import { type DashboardAttributeFilterItem, type ICatalogDateAttribute, type IDashboardMeasureValueFilter, type ISeparators, type ObjRef } from "@gooddata/sdk-model";
 import { type IUiListboxInteractiveItem } from "@gooddata/sdk-ui-kit";
 import { type DeepReadonly, type IKdaDataPoint, type IKdaDefinition, type KdaPeriodType } from "./types.js";
 export interface IKdaDateOptions {
@@ -48,6 +48,11 @@ export interface IKdaState {
     selectedStatus: KdaAsyncStatus;
     selectedError: Error | undefined;
     attributeFilters: DashboardAttributeFilterItem[];
+    /**
+     * Dashboard measure value filters propagated to the change analysis computation.
+     * Not editable in the dialog UI — these flow through from the dashboard filter context.
+     */
+    measureValueFilters: IDashboardMeasureValueFilter[];
     items: IUiListboxInteractiveItem<IKdaItem>[];
     itemsStatus: KdaAsyncStatus;
     itemsError: Error | undefined;

package/esm/kdaDialog/providers/Kda.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 // (C) 2025-2026 GoodData Corporation
 import { useMemo } from "react";
-import { isAllValuesDashboardAttributeFilter } from "@gooddata/sdk-model";
+import { isAllDashboardMeasureValueFilter, isAllValuesDashboardAttributeFilter, } from "@gooddata/sdk-model";
 import { KdaStateProvider } from "./KdaState.js";
 export function KdaProvider({ children, definition, separators, includeTags, excludeTags }) {
     const state = useMemo(() => {
@@ -15,6 +15,9 @@ export function KdaProvider({ children, definition, separators, includeTags, exc
             definitionStatus: "success",
             isMinimized: true,
             attributeFilters: (definition.filters?.slice() ?? []).filter((f) => !isAllValuesDashboardAttributeFilter(f)),
+            // MVF flows through from the dashboard filter context; noop "All" MVFs are dropped
+            // so the backend only receives meaningful conditions.
+            measureValueFilters: (definition.measureValueFilters?.slice() ?? []).filter((f) => !isAllDashboardMeasureValueFilter(f)),
         };
     }, [definition, separators, includeTags, excludeTags]);
     return _jsx(KdaStateProvider, { value: state, children: children });

package/esm/kdaDialog/providers/KdaState.js

@@ -22,6 +22,7 @@ const defaultState = {
     selectedError: undefined,
     //root data
     attributeFilters: [],
+    measureValueFilters: [],
     //attributes data
     selectedAttributes: [],
     selectedUpdated: 0,

package/esm/kdaDialog/types.d.ts

@@ -1,4 +1,4 @@
-import { type DashboardAttributeFilterItem, type IAttributeDescriptorBody, type IMeasure, type ObjRef } from "@gooddata/sdk-model";
+import { type DashboardAttributeFilterItem, type IAttributeDescriptorBody, type IDashboardMeasureValueFilter, type IMeasure, type ObjRef } from "@gooddata/sdk-model";
 import { type OverlayController } from "@gooddata/sdk-ui-kit";
 /**
  * @internal
@@ -60,9 +60,20 @@ export interface IKdaDefinition {
      */
     metrics?: IMeasure[];
     /**
-     * Filters to apply
+     * Attribute filters to apply.
+     *
+     * Attribute filters drive both the KDA "segment-by attribute" UI in the dialog and the
+     * scope of the change analysis computation.
      */
     filters?: DashboardAttributeFilterItem[];
+    /**
+     * Measure value filters to apply to the change analysis computation.
+     *
+     * They are not editable in the dialog UI (KDA segments by attribute, not by metric value),
+     * but the dashboard MVFs are propagated to the backend so the computation respects the
+     * same metric-driven scope as the rest of the dashboard.
+     */
+    measureValueFilters?: IDashboardMeasureValueFilter[];
     /**
      * Date attribute
      */

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

@@ -1,12 +1,12 @@
 // (C) 2021-2026 GoodData Corporation
 import { put, select } from "redux-saga/effects";
-import { areObjRefsEqual, dashboardAttributeFilterItemDisplayForm, isAttributeDescriptor, isMeasureDescriptor, } from "@gooddata/sdk-model";
+import { areObjRefsEqual, dashboardAttributeFilterItemDisplayForm, isAttributeDescriptor, isDashboardMeasureValueFilter, isMeasureDescriptor, } from "@gooddata/sdk-model";
 import { keyDriverAnalysisRequested, keyDriverAnalysisResolved, } from "../../events/drill.js";
 import { invalidArgumentsProvided } from "../../events/general.js";
 import { generateFilterLocalIdentifier } from "../../store/_infra/generators.js";
 import { selectCatalogDateAttributes } from "../../store/catalog/catalogSelectors.js";
 import { selectWidgetByRef } from "../../store/tabs/layout/layoutSelectors.js";
-import { removeDateFilters, removeIgnoredWidgetFilters } from "../../utils/widgetFilters.js";
+import { getAttributeFilters, removeIgnoredWidgetFilters } from "../../utils/widgetFilters.js";
 import { convertIntersectionToAttributeFilters } from "./common/intersectionUtils.js";
 export function* keyDriverAnalysisHandler(ctx, cmd) {
     const { drillDefinition, drillEvent, keyDriveItem, filters: availableFilters } = cmd.payload;
@@ -52,7 +52,11 @@ export function* keyDriverAnalysisHandler(ctx, cmd) {
         return dashboardFilter;
     });
     const widget = yield select(selectWidgetByRef(drillEvent.widgetRef));
-    const attributeFilters = removeDateFilters(removeIgnoredWidgetFilters(availableFilters, widget));
+    const widgetFilters = removeIgnoredWidgetFilters(availableFilters, widget);
+    // KDA defines its own date range — drop date filters. Keep attribute and measure value
+    // filters so the change analysis respects the rest of the dashboard filter context.
+    const attributeFilters = getAttributeFilters(widgetFilters);
+    const measureValueFilters = widgetFilters.filter(isDashboardMeasureValueFilter);
     const filters = mergeFilters(intersectionFilters, attributeFilters);
     return keyDriverAnalysisResolved(ctx, cmd.payload.drillDefinition, cmd.payload.drillEvent, {
         metric: {
@@ -65,6 +69,7 @@ export function* keyDriverAnalysisHandler(ctx, cmd) {
         },
         metrics,
         filters,
+        measureValueFilters,
         dateAttribute: dateAttribute.attribute.ref,
         range: [
             {

package/esm/model/store/_infra/generators.d.ts

@@ -1,2 +1,3 @@
 import { type ObjRef } from "@gooddata/sdk-model";
 export declare const generateFilterLocalIdentifier: (ref: ObjRef, index: number) => string;
+export declare const generateMeasureValueFilterLocalIdentifier: (ref: ObjRef, index: number) => string;

package/esm/model/store/_infra/generators.js

@@ -1,5 +1,8 @@
-// (C) 2024 GoodData Corporation
+// (C) 2024-2026 GoodData Corporation
 import { objRefToString } from "@gooddata/sdk-model";
 export const generateFilterLocalIdentifier = (ref, index) => {
     return `${objRefToString(ref)}_${index}_attributeFilter`;
 };
+export const generateMeasureValueFilterLocalIdentifier = (ref, index) => {
+    return `${objRefToString(ref)}_${index}_measureValueFilter`;
+};

package/esm/model/store/filtering/dashboardFilterSelectors.d.ts

@@ -24,7 +24,7 @@ export declare const selectAutomationDefaultSelectedFilters: DashboardSelector<F
  * @alpha
  */
 export declare const selectAutomationCommonDateFilterId: DashboardSelector<string | undefined>;
-export declare function removeEmptyDashboardAttributeFilters(filters?: FilterContextItem[]): FilterContextItem[];
+export declare function removeEmptyDashboardFilters(filters?: FilterContextItem[]): FilterContextItem[];
 export declare const isFilterContextItemHidden: (filter: FilterContextItem, filterConfigurations: {
     commonDateFilterConfig?: IDashboardDateFilterConfig | undefined;
     dateFilterWithDimensionConfigs: IDashboardDateFilterConfigItem[];

package/esm/model/store/filtering/dashboardFilterSelectors.js

@@ -1,7 +1,7 @@
 // (C) 2024-2026 GoodData Corporation
 import { createSelector } from "@reduxjs/toolkit";
 import { generateDateFilterLocalIdentifier } from "@gooddata/sdk-backend-base";
-import { areObjRefsEqual, dashboardAttributeFilterItemLocalIdentifier, isAllValuesDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardDateFilterWithDimension, newAllTimeDashboardDateFilter, } from "@gooddata/sdk-model";
+import { areObjRefsEqual, dashboardAttributeFilterItemLocalIdentifier, isAllDashboardMeasureValueFilter, isAllValuesDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardDateFilterWithDimension, isDashboardMeasureValueFilter, newAllTimeDashboardDateFilter, } from "@gooddata/sdk-model";
 import { selectCrossFilteringItems, selectCrossFilteringItemsByTab } from "../drill/drillSelectors.js";
 import { selectAttributeFilterConfigsOverrides, selectAttributeFilterConfigsOverridesByTab, } from "../tabs/attributeFilterConfigs/attributeFilterConfigsSelectors.js";
 import { selectDateFilterConfigOverrides, selectDateFilterConfigOverridesByTab, } from "../tabs/dateFilterConfig/dateFilterConfigSelectors.js";
@@ -55,7 +55,7 @@ export const selectAutomationAvailableDashboardFilters = createSelector(selectDa
  * @alpha
  */
 export const selectAutomationDefaultSelectedFilters = createSelector(selectAutomationAvailableDashboardFilters, (availableDashboardFilters) => {
-    return removeEmptyDashboardAttributeFilters(availableDashboardFilters);
+    return removeEmptyDashboardFilters(availableDashboardFilters);
 });
 /**
  * @alpha
@@ -79,11 +79,14 @@ const removeCrossFilteringFilters = (filters, crossFilteringItems) => {
         return true;
     });
 };
-export function removeEmptyDashboardAttributeFilters(filters = []) {
+export function removeEmptyDashboardFilters(filters = []) {
     return filters.filter((filter) => {
         if (isDashboardAttributeFilterItem(filter)) {
             return !isAllValuesDashboardAttributeFilter(filter);
         }
+        if (isDashboardMeasureValueFilter(filter)) {
+            return !isAllDashboardMeasureValueFilter(filter);
+        }
         return true;
     });
 }
@@ -166,8 +169,8 @@ export const selectAutomationFiltersByTab = createSelector(selectTabs, selectFil
         const lockedFilters = filtersWithCommonDate.filter((filter) => isFilterContextItemLocked(filter, filterConfigurations));
         // Get hidden filters
         const hiddenFilters = filtersWithCommonDate.filter((filter) => isFilterContextItemHidden(filter, filterConfigurations));
-        // Get default selected filters (empty "All values" attribute filters removed)
-        const defaultSelectedFilters = removeEmptyDashboardAttributeFilters(availableFilters);
+        // Get default selected filters (noop "All" filters removed — attribute and MVF)
+        const defaultSelectedFilters = removeEmptyDashboardFilters(availableFilters);
         return {
             tabId,
             tabTitle,

package/esm/model/store/tabs/filterContext/filterContextReducers.js

@@ -1,7 +1,7 @@
 // (C) 2021-2026 GoodData Corporation
 import { invariant } from "ts-invariant";
 import { areObjRefsEqual, attributeElementsIsEmpty, dashboardAttributeFilterItemFilterElementsBy, dashboardAttributeFilterItemFilterElementsByDate, dashboardAttributeFilterItemLocalIdentifier, dashboardAttributeFilterItemValidateElementsBy, dashboardFilterLocalIdentifier, isAttributeElementsByRef, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardAttributeFilterItem, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardMatchAttributeFilter, isDashboardMeasureValueFilter, newAllTimeDashboardDateFilter, } from "@gooddata/sdk-model";
-import { generateFilterLocalIdentifier } from "../../_infra/generators.js";
+import { generateFilterLocalIdentifier, generateMeasureValueFilterLocalIdentifier, } from "../../_infra/generators.js";
 import { getActiveTab, getTabOrActive } from "../tabsState.js";
 import { filterContextInitialState } from "./filterContextState.js";
 import { applyFilterContext, initializeFilterContext } from "./filterContextUtils.js";
@@ -674,7 +674,7 @@ const addMeasureValueFilter = (state, action) => {
     const filter = {
         dashboardMeasureValueFilter: {
             measure,
-            localIdentifier: localIdentifier ?? generateFilterLocalIdentifier(measure, Math.max(0, index)),
+            localIdentifier: localIdentifier ?? generateMeasureValueFilterLocalIdentifier(measure, Math.max(0, index)),
             title,
         },
     };

package/esm/model/utils/widgetFilters.d.ts

@@ -7,4 +7,4 @@ export declare function removeIgnoredWidgetFilters(filters: FilterContextItem[],
 /**
  * @internal
  */
-export declare function removeDateFilters(filters: FilterContextItem[]): DashboardAttributeFilterItem[];
+export declare function getAttributeFilters(filters: FilterContextItem[]): DashboardAttributeFilterItem[];

package/esm/model/utils/widgetFilters.js

@@ -27,6 +27,6 @@ export function removeIgnoredWidgetFilters(filters, widget) {
 /**
  * @internal
  */
-export function removeDateFilters(filters) {
+export function getAttributeFilters(filters) {
     return filters.filter(isDashboardAttributeFilterItem);
 }

package/esm/presentation/automationFilters/components/AutomationFiltersSelect.js

@@ -9,6 +9,7 @@ import { AttributesDropdown } from "../../filterBar/attributeFilter/addAttribute
 import { useAutomationFilters, useAutomationFiltersByTab } from "../useAutomationFilters.js";
 import { AutomationAttributeFilter } from "./AutomationAttributeFilter.js";
 import { AutomationDateFilter } from "./AutomationDateFilter.js";
+import { AutomationMeasureValueFilter } from "./AutomationMeasureValueFilter.js";
 const COLLAPSED_FILTERS_COUNT = 2;
 function AutomationCheckboxOrNote({ isDashboardAutomation, storeFilters, handleStoreFiltersChange, handleKeyDown, automationFilterSelectTooltipId, }) {
     const intl = useIntl();
@@ -51,6 +52,7 @@ export function AutomationFiltersSelect({ availableFilters = [], selectedFilters
     const filters = shouldRenderByTab ? [] : flatFiltersData.visibleFilters;
     const attributes = shouldRenderByTab ? [] : flatFiltersData.attributes;
     const dateDatasets = shouldRenderByTab ? [] : flatFiltersData.dateDatasets;
+    const measures = shouldRenderByTab ? [] : flatFiltersData.measures;
     const handleChangeFilter = shouldRenderByTab
         ? () => { } // Not used in tab mode
         : flatFiltersData.handleChangeFilter;
@@ -109,7 +111,7 @@ export function AutomationFiltersSelect({ availableFilters = [], selectedFilters
                                         // Add button for each tab section
                                         addFilterButton: _jsx(AttributesDropdown, { id: `${AUTOMATION_FILTERS_DIALOG_ID}-${tab.tabId}`, onClose: () => { }, onSelect: (value) => {
                                                 tabFiltersData.handleTabFilterAdd(tab.tabId, value, tab.attributes, tab.dateDatasets);
-                                            }, attributes: tab.attributes, dateDatasets: tab.dateDatasets, openOnInit: false, overlayPositionType: overlayPositionType, className: "gd-automation-filters__dropdown s-automation-filters-add-filter-dropdown", getCustomItemTitle: (item) => getCatalogItemCustomTitle(item, availableFilters, tab.dateConfigs), accessibilityConfig: {
+                                            }, attributes: tab.attributes, dateDatasets: tab.dateDatasets, measures: tab.measures, openOnInit: false, overlayPositionType: overlayPositionType, className: "gd-automation-filters__dropdown s-automation-filters-add-filter-dropdown", getCustomItemTitle: (item) => getCatalogItemCustomTitle(item, availableFilters, tab.dateConfigs), accessibilityConfig: {
                                                 ariaLabelledBy: AUTOMATION_FILTERS_DIALOG_TITLE_ID,
                                                 searchAriaLabel: searchAriaLabel,
                                             }, DropdownButtonComponent: ({ buttonRef, isOpen, onClick }) => (_jsx(UiTooltip, { arrowPlacement: "left", triggerBy: ["hover", "focus"], content: tabTooltipText, anchor: _jsx(ButtonDisabledFocusableWrapper, { isDisabled: isTabAddButtonDisabled, ariaLabel: tabTooltipText, onRefSet: (element) => setAddFilterButtonRefs(element, buttonRef), children: _jsx(UiIconButton, { icon: "plus", label: tabTooltipText, onClick: onClick, variant: "tertiary", isDisabled: isTabAddButtonDisabled, ref: (element) => {
@@ -136,7 +138,7 @@ export function AutomationFiltersSelect({ availableFilters = [], selectedFilters
                                     }), isExpanded || !isExpandable ? (_jsx(AttributesDropdown, { id: AUTOMATION_FILTERS_DIALOG_ID, onClose: () => { }, onSelect: (value) => {
                                             handleAddFilter(value, attributes, dateDatasets);
                                             setIsExpanded(true);
-                                        }, attributes: attributes, dateDatasets: dateDatasets, openOnInit: false, overlayPositionType: overlayPositionType, className: "gd-automation-filters__dropdown s-automation-filters-add-filter-dropdown", getCustomItemTitle: (item) => getCatalogItemCustomTitle(item, availableFilters, dateConfigs), accessibilityConfig: {
+                                        }, attributes: attributes, dateDatasets: dateDatasets, measures: measures, openOnInit: false, overlayPositionType: overlayPositionType, className: "gd-automation-filters__dropdown s-automation-filters-add-filter-dropdown", getCustomItemTitle: (item) => getCatalogItemCustomTitle(item, availableFilters, dateConfigs), accessibilityConfig: {
                                             ariaLabelledBy: AUTOMATION_FILTERS_DIALOG_TITLE_ID,
                                             searchAriaLabel: searchAriaLabel,
                                         }, DropdownButtonComponent: ({ buttonRef, isOpen, onClick }) => (_jsx(UiTooltip, { arrowPlacement: "left", triggerBy: ["hover", "focus"], content: tooltipText, anchor: _jsx(ButtonDisabledFocusableWrapper, { isDisabled: isAddButtonDisabled, ariaLabel: tooltipText, onRefSet: (element) => setAddFilterButtonRefs(element, buttonRef), children: _jsx(UiIconButton, { icon: "plus", label: tooltipText, onClick: onClick, variant: "tertiary", isDisabled: isAddButtonDisabled, ref: (element) => {
@@ -170,6 +172,10 @@ function AutomationFilter({ filter, attributeConfigs, onChange, onDelete, isComm
         const isLocked = lockedFilters.some((f) => dashboardFilterLocalIdentifier(f) === dashboardFilterLocalIdentifier(filter));
         return (_jsx(AutomationDateFilter, { filter: filter, onChange: onChange, onDelete: onDelete, isLocked: isLocked, isCommonDateFilter: isCommonDateFilter, overlayPositionType: overlayPositionType, readonly: isReadOnly, tabId: tabId }, filter.dateFilter.localIdentifier));
     }
+    else if (isDashboardMeasureValueFilter(filter)) {
+        const isLocked = lockedFilters.some((f) => dashboardFilterLocalIdentifier(f) === dashboardFilterLocalIdentifier(filter));
+        return (_jsx(AutomationMeasureValueFilter, { filter: filter, onChange: onChange, onDelete: onDelete, isLocked: isLocked, overlayPositionType: overlayPositionType, readonly: isReadOnly }, filter.dashboardMeasureValueFilter.localIdentifier));
+    }
     return null;
 }
 /**

package/esm/presentation/automationFilters/components/AutomationMeasureValueFilter.d.ts

@@ -0,0 +1,10 @@
+import { type FilterContextItem, type IDashboardMeasureValueFilter } from "@gooddata/sdk-model";
+import { type OverlayPositionType } from "@gooddata/sdk-ui-kit";
+export declare function AutomationMeasureValueFilter({ filter, onChange, onDelete, isLocked, overlayPositionType, readonly }: {
+    filter: IDashboardMeasureValueFilter;
+    onChange: (filter: FilterContextItem) => void;
+    onDelete: (filter: FilterContextItem) => void;
+    isLocked?: boolean;
+    overlayPositionType?: OverlayPositionType;
+    readonly?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/esm/presentation/automationFilters/components/AutomationMeasureValueFilter.js

@@ -0,0 +1,66 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback } from "react";
+import { useIntl } from "react-intl";
+import { MeasureValueFilter } from "@gooddata/sdk-ui-filters";
+import { UiChip, UiTooltip, isActionKey, useIdPrefixed, } from "@gooddata/sdk-ui-kit";
+import { getSharedDashboardMvfProps, normalizeMeasureValueFilterConditions, useDashboardMeasureValueFilterData, } from "../../filterBar/measureValueFilter/useDashboardMeasureValueFilterData.js";
+import { AutomationMeasureValueFilterProvider, useAutomationMeasureValueFilterContext, } from "./AutomationMeasureValueFilterContext.js";
+export function AutomationMeasureValueFilter({ filter, onChange, onDelete, isLocked, overlayPositionType, readonly, }) {
+    const intl = useIntl();
+    const deleteAriaLabel = intl.formatMessage({ id: "dialogs.automation.filters.deleteAriaLabel" });
+    const deleteTooltipContent = intl.formatMessage({ id: "dialogs.automation.filters.deleteTooltip" });
+    const lockedTooltipContent = intl.formatMessage({ id: "dialogs.automation.filters.lockedTooltip" });
+    // Automation/scheduling has no "Apply together" working filter — just reflect the persisted filter.
+    const mvfData = useDashboardMeasureValueFilterData(filter);
+    const { conditionLabel } = mvfData;
+    const handleApply = useCallback((updated) => {
+        const newConditions = normalizeMeasureValueFilterConditions(updated);
+        const next = {
+            dashboardMeasureValueFilter: {
+                ...filter.dashboardMeasureValueFilter,
+                ...(newConditions && newConditions.length > 0
+                    ? { conditions: newConditions }
+                    : { conditions: undefined }),
+            },
+        };
+        onChange(next);
+    }, [filter, onChange]);
+    return (_jsx(AutomationMeasureValueFilterProvider, { filter: filter, onChange: onChange, onDelete: onDelete, isLocked: isLocked, deleteAriaLabel: deleteAriaLabel, deleteTooltipContent: deleteTooltipContent, lockedTooltipContent: lockedTooltipContent, children: _jsx(MeasureValueFilter, { ...getSharedDashboardMvfProps(mvfData), onApply: handleApply, DropdownButtonComponent: (props) => (_jsx(AutomationMeasureValueFilterButton, { ...props, conditionLabel: conditionLabel, overlayPositionType: overlayPositionType, readonly: readonly })) }) }));
+}
+function AutomationMeasureValueFilterButton({ isActive, buttonTitle, onClick, conditionLabel, readonly, }) {
+    const { isLocked, onDelete, filter, deleteAriaLabel, deleteTooltipContent, lockedTooltipContent } = useAutomationMeasureValueFilterContext();
+    const label = `${buttonTitle}: ${conditionLabel}`;
+    const mvfTooltipId = useIdPrefixed("mvf-filter-tooltip");
+    const mvfDeleteTooltipId = useIdPrefixed("mvf-filter-delete-tooltip");
+    const tooltipContent = (_jsxs(_Fragment, { children: [label, isLocked ? _jsx("div", { children: lockedTooltipContent }) : null] }));
+    // The whole-panel disabled state is handled by a visual overlay in
+    // AutomationFiltersSelect (`gd-automation-filters__overlay`), so the chip should not
+    // claim a locked state from it. The lock icon only reflects the filter's own config.
+    const isDeletable = !isLocked && !readonly;
+    return (_jsx(UiChip, { label: label, iconBefore: "metric", isActive: isActive, isLocked: isLocked, isDeletable: isDeletable, onClick: onClick, onDelete: () => onDelete?.(filter), onKeyDown: (event) => {
+            // In case the button is locked and not disabled we need to explicitly
+            // stop the event propagation to prevent dropdown from opening
+            if (isLocked && isActionKey(event)) {
+                event.stopPropagation();
+            }
+        }, onDeleteKeyDown: (event) => {
+            // Do not propagate event to parent as MVF dropdown would always open
+            if (isActionKey(event)) {
+                event.stopPropagation();
+            }
+        }, accessibilityConfig: {
+            isExpanded: isActive,
+            popupType: "dialog",
+            ariaDescribedBy: mvfTooltipId,
+            deleteAriaLabel: buttonTitle ? `${deleteAriaLabel} ${buttonTitle}` : deleteAriaLabel,
+            deleteAriaDescribedBy: mvfDeleteTooltipId,
+        }, renderChipContent: (content) => (_jsx(UiTooltip, { id: mvfTooltipId, arrowPlacement: "top-start", content: tooltipContent, triggerBy: ["hover", "focus"], anchor: content, anchorWrapperStyles: {
+                display: "flex",
+                width: "100%",
+                height: "100%",
+                minWidth: 0,
+            } })), renderDeleteButton: (button) => (_jsx(UiTooltip, { id: mvfDeleteTooltipId, arrowPlacement: "top-start", content: deleteTooltipContent, triggerBy: ["hover", "focus"], anchor: button, anchorWrapperStyles: {
+                height: "100%",
+            } })) }));
+}

package/esm/presentation/automationFilters/components/AutomationMeasureValueFilterContext.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from "react";
+import { type FilterContextItem, type IDashboardMeasureValueFilter } from "@gooddata/sdk-model";
+/**
+ * @internal
+ */
+export interface IAutomationMeasureValueFilterContext {
+    onChange: (filter: FilterContextItem) => void;
+    onDelete: (filter: FilterContextItem) => void;
+    filter: IDashboardMeasureValueFilter;
+    isLocked?: boolean;
+    deleteAriaLabel?: string;
+    deleteTooltipContent?: string;
+    lockedTooltipContent?: string;
+}
+/**
+ * @internal
+ */
+export declare const useAutomationMeasureValueFilterContext: () => IAutomationMeasureValueFilterContext;
+export interface IAutomationMeasureValueFilterProviderProps extends IAutomationMeasureValueFilterContext {
+    children: ReactNode;
+}
+/**
+ * @internal
+ */
+export declare function AutomationMeasureValueFilterProvider({ children, onChange, onDelete, isLocked, filter, deleteAriaLabel, deleteTooltipContent, lockedTooltipContent }: IAutomationMeasureValueFilterProviderProps): import("react/jsx-runtime").JSX.Element;