@gooddata/sdk-ui-dashboard 11.35.0-alpha.5 → 11.35.0-alpha.7

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

@@ -0,0 +1,228 @@
+// (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 { createMemoizedSelector } from "../../_infra/selectors.js";
+import { selectCatalogParameters, selectCatalogParametersIsLoaded } from "../../catalog/catalogSelectors.js";
+import { selectEnableParameters } from "../../config/configSelectors.js";
+import { selectInsightsMap } from "../../insights/insightsSelectors.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_TABS = [];
+const selectParametersState = createSelector(selectActiveTab, (activeTab) => activeTab?.parameters ?? parametersInitialState);
+const selectPersistedParametersFromMeta = (state) => state.meta?.persistedDashboard?.parameters ?? EMPTY_PARAMETERS;
+const selectPersistedDashboardTabsRaw = (state) => state.meta?.persistedDashboard?.tabs ?? EMPTY_TABS;
+/**
+ * Returns the persisted-shape parameter entries currently held by the active tab.
+ *
+ * @alpha
+ */
+export const selectDashboardParameters = createSelector(selectParametersState, (state) => state.parameters.map((entry) => entry.parameter));
+/**
+ * Returns currently active parameter references on the active tab.
+ *
+ * @alpha
+ */
+export const selectActiveParameterRefKeys = createSelector(selectDashboardParameters, (parameters) => new Set(parameters.map((parameter) => objRefToString(parameter.ref))));
+/**
+ * Returns the full per-parameter entries (persisted shape + ephemeral `runtimeOverride`) for the
+ * active tab.
+ *
+ * @internal
+ */
+export const selectDashboardParameterEntries = createSelector(selectParametersState, (state) => state.parameters);
+/**
+ * Returns a selector that yields the entry held by the active tab for a given parameter ref,
+ * or `undefined` if no such entry exists.
+ *
+ * @alpha
+ */
+export const selectDashboardParameterEntryByRef = createMemoizedSelector((ref) => createSelector(selectParametersState, (state) => state.parameters.find((item) => areObjRefsEqual(item.parameter.ref, ref))));
+/**
+ * Returns a selector that yields the current `runtimeOverride` for a given parameter ref on the
+ * active tab, or `undefined` if the active tab does not hold an entry for that ref.
+ *
+ * @alpha
+ */
+export const selectParameterRuntimeOverrideByRef = createMemoizedSelector((ref) => createSelector(selectDashboardParameterEntryByRef(ref), (entry) => entry?.runtimeOverride));
+/**
+ * Computes the dashboard parameters keyed by tab `localIdentifier` in the shape that would be
+ * persisted on save right now.
+ *
+ * @remarks
+ * Smart persistence applies independently per tab: `value` is dropped when equal to the
+ * workspace default, `label` is dropped when equal to the parameter title, all per tab.
+ * Non-resolved entries (catalog not loaded, gated off, ref missing) are emitted verbatim from
+ * the previously persisted entry on the same tab when available. V1 fallback applies when no
+ * tab in the persisted dashboard carries `parameters` — the persisted root array is used as the
+ * persistence source for every tab.
+ *
+ * @internal
+ */
+export const selectSmartPersistedTabsParameters = createSelector(selectTabs, selectCatalogParameters, selectCatalogParametersIsLoaded, selectPersistedDashboardTabsRaw, selectPersistedParametersFromMeta, (tabs, workspaceParameters, isCatalogLoaded, persistedTabs, rootPersistedParameters) => {
+    const result = {};
+    if (!tabs) {
+        return result;
+    }
+    const workspaceByRef = new Map(workspaceParameters.map((wp) => [objRefToString(wp.ref), wp]));
+    const persistedByTabAndRef = buildPersistedByTabAndRef(persistedTabs, rootPersistedParameters);
+    for (const tab of tabs) {
+        const entries = tab.parameters?.parameters ?? [];
+        const persistedForTab = persistedByTabAndRef.get(tab.localIdentifier) ?? new Map();
+        result[tab.localIdentifier] = entries.map((entry) => {
+            const refKey = objRefToString(entry.parameter.ref);
+            const workspaceParameter = isCatalogLoaded ? workspaceByRef.get(refKey) : undefined;
+            if (!workspaceParameter) {
+                return persistedForTab.get(refKey) ?? entry.parameter;
+            }
+            return smartPersistResolvedEntry(entry, workspaceParameter);
+        });
+    }
+    return result;
+});
+/**
+ * Returns persisted parameters from `meta.persistedDashboard`, keyed by tab `localIdentifier`.
+ * Honors V1 → per-tab migration: when no tab in the persisted dashboard carries `parameters`,
+ * the persisted root `parameters` is used as fallback for every tab. For legacy single-tab
+ * dashboards (no `tabs[]` in persistedDashboard), the synthetic `DEFAULT_TAB_ID` tab carries
+ * the persisted root parameters.
+ *
+ * @internal
+ */
+const selectPersistedTabsParametersFromMeta = createSelector(selectPersistedDashboardTabsRaw, selectPersistedParametersFromMeta, (persistedTabs, rootPersistedParameters) => {
+    const result = {};
+    if (persistedTabs.length === 0) {
+        result[DEFAULT_TAB_ID] = rootPersistedParameters;
+        return result;
+    }
+    for (const tab of persistedTabs) {
+        result[tab.localIdentifier] =
+            pickTabParametersSource(tab, persistedTabs, rootPersistedParameters) ?? EMPTY_PARAMETERS;
+    }
+    return result;
+});
+/**
+ * Returns true if the dashboard parameters that would be persisted differ from the persisted
+ * version on any tab.
+ *
+ * @alpha
+ */
+export const selectIsParametersChanged = createSelector(selectSmartPersistedTabsParameters, selectPersistedTabsParametersFromMeta, (smartPersistedByTab, persistedByTab) => {
+    const allTabIds = new Set([...Object.keys(smartPersistedByTab), ...Object.keys(persistedByTab)]);
+    for (const tabId of allTabIds) {
+        const smart = smartPersistedByTab[tabId] ?? EMPTY_PARAMETERS;
+        const persisted = persistedByTab[tabId] ?? EMPTY_PARAMETERS;
+        if (!isEqual(smart, persisted)) {
+            return true;
+        }
+    }
+    return false;
+});
+/**
+ * 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.
+ *
+ * @alpha
+ */
+export const selectEffectiveParameterValuesForWidget = createMemoizedSelector((ref) => createSelector(selectParameterExecutionContextByWidgetRef(ref), selectInsightsMap, selectEnableParameters, (context, insights, isEnabled) => {
+    if (!isEnabled || !context) {
+        return [];
+    }
+    const insight = insights.get(context.widget.insight);
+    if (!insight) {
+        return [];
+    }
+    const entries = context.tab.parameters?.parameters ?? parametersInitialState.parameters;
+    const referencedRefs = new Set(insightParameters(insight).map((parameter) => objRefToString(parameter.ref)));
+    const result = [];
+    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 });
+        }
+    }
+    return result;
+}));
+const selectParameterExecutionContextByWidgetRef = createMemoizedSelector((ref) => createSelector(selectTabs, (tabs) => findParameterExecutionContext(tabs, ref)));
+function findParameterExecutionContext(tabs, ref) {
+    if (!ref || !tabs) {
+        return undefined;
+    }
+    for (const tab of tabs) {
+        const layout = tab.layout?.layout;
+        if (!layout) {
+            continue;
+        }
+        const widget = findInsightWidgetInLayout(layout, ref);
+        if (widget) {
+            return { tab, widget };
+        }
+    }
+    return undefined;
+}
+function findInsightWidgetInLayout(layout, ref) {
+    for (const section of layout.sections) {
+        for (const item of section.items) {
+            const widget = item.widget;
+            if (!widget) {
+                continue;
+            }
+            if (isInsightWidget(widget) && areObjRefsEqual(widget.ref, ref)) {
+                return widget;
+            }
+            if (isDashboardLayout(widget)) {
+                const nestedWidget = findInsightWidgetInLayout(widget, ref);
+                if (nestedWidget) {
+                    return nestedWidget;
+                }
+            }
+            if (isVisualizationSwitcherWidget(widget)) {
+                const visualization = widget.visualizations.find((visualization) => areObjRefsEqual(visualization.ref, ref));
+                if (visualization) {
+                    return visualization;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function buildPersistedByTabAndRef(persistedTabs, rootPersistedParameters) {
+    const result = new Map();
+    for (const tab of persistedTabs) {
+        const sourceParameters = pickTabParametersSource(tab, persistedTabs, rootPersistedParameters) ?? EMPTY_PARAMETERS;
+        result.set(tab.localIdentifier, new Map(sourceParameters.map((parameter) => [objRefToString(parameter.ref), parameter])));
+    }
+    return result;
+}
+function smartPersistResolvedEntry(entry, workspaceParameter) {
+    const workspaceDefault = isNumberParameterDefinition(workspaceParameter.definition)
+        ? workspaceParameter.definition.defaultValue
+        : undefined;
+    const result = {
+        ref: entry.parameter.ref,
+        parameterType: entry.parameter.parameterType,
+        mode: entry.parameter.mode,
+        ...labelOverride(entry, workspaceParameter),
+    };
+    if (entry.runtimeOverride === undefined || entry.runtimeOverride === workspaceDefault) {
+        return result;
+    }
+    return { ...result, value: entry.runtimeOverride };
+}
+function labelOverride(entry, workspaceParameter) {
+    if (entry.parameter.label && entry.parameter.label !== workspaceParameter.title) {
+        return { label: entry.parameter.label };
+    }
+    return {};
+}

package/esm/model/store/{parameters → tabs/parameters}/parametersState.d.ts

@@ -1,4 +1,4 @@
-import { type IDashboardParameter } from "@gooddata/sdk-model";
+import { type IDashboardParameter, type IDashboardTab } from "@gooddata/sdk-model";
 /**
  * Per-parameter state tracked by the dashboard store.
  *
@@ -26,3 +26,13 @@ export interface IParametersState {
     parameters: IDashboardParameterEntry[];
 }
 export declare const parametersInitialState: IParametersState;
+/**
+ * Picks a tab's persisted parameter source under the V1 → per-tab migration rule.
+ *
+ * - If the tab has its own `parameters` (including `[]`) → return it.
+ * - Else if every tab's `parameters === undefined` AND root `parameters` is defined → root array.
+ * - Else → `undefined`.
+ *
+ * @internal
+ */
+export declare function pickTabParametersSource(tab: IDashboardTab, allTabs: ReadonlyArray<IDashboardTab>, rootParameters: IDashboardParameter[] | undefined): IDashboardParameter[] | undefined;

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

@@ -0,0 +1,20 @@
+// (C) 2026 GoodData Corporation
+export const parametersInitialState = {
+    parameters: [],
+};
+/**
+ * Picks a tab's persisted parameter source under the V1 → per-tab migration rule.
+ *
+ * - If the tab has its own `parameters` (including `[]`) → return it.
+ * - Else if every tab's `parameters === undefined` AND root `parameters` is defined → root array.
+ * - Else → `undefined`.
+ *
+ * @internal
+ */
+export function pickTabParametersSource(tab, allTabs, rootParameters) {
+    if (tab.parameters !== undefined) {
+        return tab.parameters;
+    }
+    const everyTabUndefined = allTabs.length > 0 && allTabs.every((other) => other.parameters === undefined);
+    return everyTabUndefined ? rootParameters : undefined;
+}

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

@@ -6,6 +6,7 @@ import { type IDateFilterConfigsState } from "./dateFilterConfigs/dateFilterConf
 import type { FilterContextState } from "./filterContext/filterContextState.js";
 import type { ILayoutState } from "./layout/layoutState.js";
 import { type IMeasureValueFilterConfigsState } from "./measureValueFilterConfigs/measureValueFilterConfigsState.js";
+import { type IParametersState } from "./parameters/parametersState.js";
 /**
  * Identifier used for dashboards without explicit tabs support and the first tab created automatically.
  *
@@ -36,6 +37,7 @@ export interface ITabState {
     filterContext?: FilterContextState;
     filterGroupsConfig?: IDashboardFilterGroupsConfig;
     layout?: ILayoutState;
+    parameters?: IParametersState;
     /**
      * UI-only flag indicating the tab is currently being renamed.
      * @internal

package/esm/model/store/types.d.ts

@@ -17,7 +17,6 @@ import { type IFilterViewsState } from "./filterViews/filterViewsState.js";
 import { type ILoadingState } from "./loading/loadingState.js";
 import { type IDashboardMetaState } from "./meta/metaState.js";
 import { type INotificationChannelsState } from "./notificationChannels/notificationChannelsState.js";
-import { type IParametersState } from "./parameters/parametersState.js";
 import { type PermissionsState } from "./permissions/permissionsState.js";
 import { type IRenderModeState } from "./renderMode/renderModeState.js";
 import { type SavingState } from "./saving/savingState.js";
@@ -75,11 +74,6 @@ export type DashboardState = {
     users: IUsersState;
     /** @alpha */
     notificationChannels: INotificationChannelsState;
-    /**
-     * Dashboard-level parameter overrides slice.
-     * @alpha
-     */
-    parameters: IParametersState;
     /**
      * Internal state for dashboard summary AI workflow.
      *

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;

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

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { createContext, useContext } from "react";
+const AutomationMeasureValueFilterContext = createContext(null);
+/**
+ * @internal
+ */
+export const useAutomationMeasureValueFilterContext = () => {
+    const context = useContext(AutomationMeasureValueFilterContext);
+    if (!context) {
+        throw new Error("AutomationMeasureValueFilterContext not found");
+    }
+    return context;
+};
+/**
+ * @internal
+ */
+export function AutomationMeasureValueFilterProvider({ children, onChange, onDelete, isLocked, filter, deleteAriaLabel, deleteTooltipContent, lockedTooltipContent, }) {
+    return (_jsx(AutomationMeasureValueFilterContext.Provider, { value: {
+            onChange,
+            onDelete,
+            isLocked,
+            filter,
+            deleteAriaLabel,
+            deleteTooltipContent,
+            lockedTooltipContent,
+        }, children: children }));
+}

package/esm/presentation/automationFilters/useAutomationFilters.d.ts

@@ -1,5 +1,5 @@
 import { type MutableRefObject } from "react";
-import { type FilterContextItem, type ICatalogAttribute, type ICatalogDateDataset, type IDashboardAttributeFilterConfig, type IDashboardDateFilterConfigItem, type ObjRef } from "@gooddata/sdk-model";
+import { type FilterContextItem, type ICatalogAttribute, type ICatalogDateDataset, type ICatalogMeasure, type IDashboardAttributeFilterConfig, type IDashboardDateFilterConfigItem, type ObjRef } from "@gooddata/sdk-model";
 import { type IAutomationFiltersTab } from "../../model/store/filtering/dashboardFilterSelectors.js";
 /**
  * Processed filter data for a single tab, ready for UI rendering.
@@ -17,6 +17,8 @@ export interface IProcessedAutomationFiltersTab {
     attributes: ICatalogAttribute[];
     /** Catalog date datasets available for Add filter dropdown */
     dateDatasets: ICatalogDateDataset[];
+    /** Catalog measures available for Add filter dropdown (for re-adding removed MVFs) */
+    measures: ICatalogMeasure[];
     /** Non-selected filters (available but not yet selected) */
     nonSelectedFilters: FilterContextItem[];
     /** Attribute filter configs for this tab */
@@ -39,6 +41,7 @@ export declare const useAutomationFilters: ({ availableFilters, selectedFilters,
     visibleFilters: FilterContextItem[];
     attributes: ICatalogAttribute[];
     dateDatasets: ICatalogDateDataset[];
+    measures: ICatalogMeasure[];
     attributeConfigs: IDashboardAttributeFilterConfig[];
     dateConfigs: IDashboardDateFilterConfigItem[];
     filterAnnouncement: string;