@gooddata/sdk-ui-dashboard 11.39.0 → 11.40.0-alpha.1

package/esm/__version.d.ts

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

package/esm/index.d.ts

@@ -140,7 +140,7 @@ export { catalogActions } from "./model/store/catalog/index.js";
 export type { SetCatalogMeasuresAndFactsPayload, SetCatalogItemsPayload, } from "./model/store/catalog/catalogReducers.js";
 export type { IAddParameterPayload, IRemoveParameterPayload, ISetParameterRuntimeValuePayload, ISetParameterRuntimeValuesPayload, } from "./model/store/tabs/parameters/parametersReducers.js";
 export type { IDashboardParameterEntry, IParametersState, } from "./model/store/tabs/parameters/parametersState.js";
-export { selectDashboardParameterEntries, selectDashboardParameters, selectEffectiveParameterValuesForWidget, selectHasAnyResettableParameterOnActiveTab, selectIsParametersChanged, selectParameterRuntimeOverrideByRef, } from "./model/store/tabs/parameters/parametersSelectors.js";
+export { selectDashboardParameterEntries, selectDashboardParameters, selectEffectiveParameterValuesForWidget, selectExportEffectiveParameters, selectHasAnyResettableParameterOnActiveTab, selectIsParametersChanged, selectParameterRuntimeOverrideByRef, } from "./model/store/tabs/parameters/parametersSelectors.js";
 export { drillActions } from "./model/store/drill/index.js";
 export { selectDrillableItems, selectIsCrossFiltering, selectCrossFilteringItems, selectCrossFilteringItemByWidgetRef, selectCrossFilteringFiltersLocalIdentifiers, selectCrossFilteringFiltersLocalIdentifiersByWidgetRef, selectCrossFilteringSelectedPointsByWidgetRef, selectIsFilterFromCrossFilteringByLocalIdentifier, } from "./model/store/drill/drillSelectors.js";
 export type { IDrillState } from "./model/store/drill/drillState.js";

package/esm/index.js

@@ -101,7 +101,7 @@ export { selectDateFilterConfigsOverrides, selectDateFilterConfigsOverridesByTab
 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, selectCatalogMeasureParameters, selectCatalogMeasureParametersStatus, } from "./model/store/catalog/catalogSelectors.js";
 export { catalogActions } from "./model/store/catalog/index.js";
-export { selectDashboardParameterEntries, selectDashboardParameters, selectEffectiveParameterValuesForWidget, selectHasAnyResettableParameterOnActiveTab, selectIsParametersChanged, selectParameterRuntimeOverrideByRef, } from "./model/store/tabs/parameters/parametersSelectors.js";
+export { selectDashboardParameterEntries, selectDashboardParameters, selectEffectiveParameterValuesForWidget, selectExportEffectiveParameters, selectHasAnyResettableParameterOnActiveTab, selectIsParametersChanged, selectParameterRuntimeOverrideByRef, } from "./model/store/tabs/parameters/parametersSelectors.js";
 export { drillActions } from "./model/store/drill/index.js";
 export { selectDrillableItems, selectIsCrossFiltering, selectCrossFilteringItems, selectCrossFilteringItemByWidgetRef, selectCrossFilteringFiltersLocalIdentifiers, selectCrossFilteringFiltersLocalIdentifiersByWidgetRef, selectCrossFilteringSelectedPointsByWidgetRef, selectIsFilterFromCrossFilteringByLocalIdentifier, } from "./model/store/drill/drillSelectors.js";
 export { selectCurrentUser, selectCurrentUserRef } from "./model/store/user/userSelectors.js";

package/esm/model/commandHandlers/dashboard/exportToTabularHandler.js

@@ -6,7 +6,8 @@ import { selectExportResultPollingTimeout } from "../../store/config/configSelec
 import { selectFilterViews } from "../../store/filterViews/filterViewsReducersSelectors.js";
 import { selectDashboardRef, selectIsFiltersChanged } from "../../store/meta/metaSelectors.js";
 import { selectFilterContextFilters, selectFiltersByTab, } from "../../store/tabs/filterContext/filterContextSelectors.js";
-function exportDashboardToTabular(ctx, dashboardRef, title, mergeHeaders, exportInfo, widgetIds, dashboardFiltersOverride, filtersByTab, format, pdfConfiguration, timeout) {
+import { selectExportEffectiveParameters } from "../../store/tabs/parameters/parametersSelectors.js";
+function exportDashboardToTabular(ctx, dashboardRef, title, mergeHeaders, exportInfo, widgetIds, dashboardFiltersOverride, filtersByTab, dashboardTabsParametersOverrides, format, pdfConfiguration, timeout) {
     const { backend, workspace } = ctx;
     return backend.workspace(workspace).dashboards().exportDashboardToTabular(dashboardRef, {
         title,
@@ -15,6 +16,7 @@ function exportDashboardToTabular(ctx, dashboardRef, title, mergeHeaders, export
         exportInfo,
         dashboardFiltersOverride,
         dashboardTabsFiltersOverrides: filtersByTab,
+        dashboardTabsParametersOverrides,
         widgetIds,
         pdfConfiguration,
         timeout,
@@ -32,8 +34,9 @@ export function* exportToTabularHandler(ctx, cmd) {
     const hasDefaultFilterViewApplied = filterViews.some((filterView) => filterView.isDefault);
     const filterContextFilters = yield select(selectFilterContextFilters);
     const filtersByTab = yield select(selectFiltersByTab);
+    const parametersByTab = yield select(selectExportEffectiveParameters(widgetIds));
     const timeout = yield select(selectExportResultPollingTimeout);
-    const result = yield call(exportDashboardToTabular, ctx, dashboardRef, fileName, mergeHeaders, exportInfo, widgetIds, isFilterContextChanged || hasDefaultFilterViewApplied ? filterContextFilters : undefined, isFilterContextChanged || hasDefaultFilterViewApplied ? filtersByTab : undefined, format, pdfConfiguration, timeout);
+    const result = yield call(exportDashboardToTabular, ctx, dashboardRef, fileName, mergeHeaders, exportInfo, widgetIds, isFilterContextChanged || hasDefaultFilterViewApplied ? filterContextFilters : undefined, isFilterContextChanged || hasDefaultFilterViewApplied ? filtersByTab : undefined, parametersByTab, format, pdfConfiguration, timeout);
     // prepend hostname if provided so that the results are downloaded from there, not from where the app is hosted
     const fullUri = ctx.backend.config.hostname
         ? new URL(result.uri, ctx.backend.config.hostname).href

package/esm/model/commandHandlers/dashboard/saveAsDashboardHandler.js

@@ -50,6 +50,11 @@ function processExistingTabsForSaveAs(tabs, parametersByTab, useOriginalFilterCo
         const measureValueFilterConfigsProp = measureValueFilterConfigs?.length
             ? { measureValueFilterConfigs }
             : {};
+        const filterGroupsConfigProp = tab.filterGroupsConfig
+            ? {
+                filterGroupsConfig: tab.filterGroupsConfig,
+            }
+            : {};
         // Get this tab's specific layout, filter out custom widgets, then process
         const tabLayout = tab.layout?.layout
             ? processLayout(filterOutCustomWidgets(tab.layout.layout))
@@ -73,6 +78,7 @@ function processExistingTabsForSaveAs(tabs, parametersByTab, useOriginalFilterCo
             ...dateFilterConfigsProp,
             ...attributeFilterConfigsProp,
             ...measureValueFilterConfigsProp,
+            ...filterGroupsConfigProp,
             // Always persist `parameters` (incl. `[]`) so V1 root fallback never re-hydrates stale
             // root parameters when every tab has been emptied.
             parameters: tabParameters,

package/esm/model/commandHandlers/dashboard/saveDashboardHandler.js

@@ -20,13 +20,13 @@ import { metaActions } from "../../store/meta/index.js";
 import { selectDashboardDescriptor, selectPersistedDashboard } from "../../store/meta/metaSelectors.js";
 import { selectIsInViewMode } from "../../store/renderMode/renderModeSelectors.js";
 import { savingActions } from "../../store/saving/index.js";
-import { selectAttributeFilterConfigsOverrides } from "../../store/tabs/attributeFilterConfigs/attributeFilterConfigsSelectors.js";
-import { selectDateFilterConfigOverrides } from "../../store/tabs/dateFilterConfig/dateFilterConfigSelectors.js";
-import { selectDateFilterConfigsOverrides } from "../../store/tabs/dateFilterConfigs/dateFilterConfigsSelectors.js";
-import { selectFilterContextDefinition, selectFilterContextIdentity, } from "../../store/tabs/filterContext/filterContextSelectors.js";
+import { selectAttributeFilterConfigsOverridesByTab } from "../../store/tabs/attributeFilterConfigs/attributeFilterConfigsSelectors.js";
+import { selectDateFilterConfigOverridesByTab } from "../../store/tabs/dateFilterConfig/dateFilterConfigSelectors.js";
+import { selectDateFilterConfigsOverridesByTab } from "../../store/tabs/dateFilterConfigs/dateFilterConfigsSelectors.js";
+import { selectFilterContextStatesByTab } from "../../store/tabs/filterContext/filterContextSelectors.js";
 import { tabsActions } from "../../store/tabs/index.js";
-import { filterOutCustomWidgets, selectBasicLayout } from "../../store/tabs/layout/layoutSelectors.js";
-import { selectMeasureValueFilterConfigsOverrides } from "../../store/tabs/measureValueFilterConfigs/measureValueFilterConfigsSelectors.js";
+import { filterOutCustomWidgets, selectBasicLayoutByTab } from "../../store/tabs/layout/layoutSelectors.js";
+import { selectMeasureValueFilterConfigsOverridesByTab } from "../../store/tabs/measureValueFilterConfigs/measureValueFilterConfigsSelectors.js";
 import { selectSmartPersistedTabsParameters } from "../../store/tabs/parameters/parametersSelectors.js";
 import { selectTabs } from "../../store/tabs/tabsSelectors.js";
 import { isTemporaryIdentity } from "../../utils/dashboardItemUtils.js";
@@ -156,14 +156,24 @@ function resolveProcessedTabs(tabs, rootFilterContext, layout, dateFilterConfig,
 function* createDashboardSaveContext(cmd, isNewDashboard) {
     const persistedDashboard = yield select(selectPersistedDashboard);
     const dashboardDescriptor = yield select(selectDashboardDescriptor);
-    const filterContextDefinition = yield select(selectFilterContextDefinition);
-    const filterContextIdentity = yield select(selectFilterContextIdentity);
-    const layout = yield select(selectBasicLayout);
-    const dateFilterConfig = yield select(selectDateFilterConfigOverrides);
-    const attributeFilterConfigs = yield select(selectAttributeFilterConfigsOverrides);
-    const dateFilterConfigs = yield select(selectDateFilterConfigsOverrides);
-    const measureValueFilterConfigs = yield select(selectMeasureValueFilterConfigsOverrides);
     const tabs = yield select(selectTabs);
+    // Root-level properties must always reflect the first tab, regardless of which tab is active.
+    // Using active-tab selectors here would persist the wrong data when saving from a non-first tab.
+    const firstTabId = tabs?.[0]?.localIdentifier;
+    const filterContextStatesByTab = yield select(selectFilterContextStatesByTab);
+    const basicLayoutByTab = yield select(selectBasicLayoutByTab);
+    const dateFilterConfigByTab = yield select(selectDateFilterConfigOverridesByTab);
+    const attributeFilterConfigsByTab = yield select(selectAttributeFilterConfigsOverridesByTab);
+    const dateFilterConfigsByTab = yield select(selectDateFilterConfigsOverridesByTab);
+    const measureValueFilterConfigsByTab = yield select(selectMeasureValueFilterConfigsOverridesByTab);
+    const firstTabFilterContextState = firstTabId ? filterContextStatesByTab[firstTabId] : undefined;
+    const filterContextDefinition = firstTabFilterContextState?.filterContextDefinition;
+    const filterContextIdentity = firstTabFilterContextState?.filterContextIdentity;
+    const layout = firstTabId ? basicLayoutByTab[firstTabId] : undefined;
+    const dateFilterConfig = firstTabId ? dateFilterConfigByTab[firstTabId] : undefined;
+    const attributeFilterConfigs = firstTabId ? attributeFilterConfigsByTab[firstTabId] : undefined;
+    const dateFilterConfigs = firstTabId ? dateFilterConfigsByTab[firstTabId] : undefined;
+    const measureValueFilterConfigs = firstTabId ? measureValueFilterConfigsByTab[firstTabId] : undefined;
     const parametersByTab = yield select(selectSmartPersistedTabsParameters);
     const capabilities = yield select(selectBackendCapabilities);
     /*
@@ -195,10 +205,12 @@ function* createDashboardSaveContext(cmd, isNewDashboard) {
         ...dashboardDescriptor,
         title,
         ...dashboardIdentity,
-        filterContext: {
-            ...filterContextIdentity,
-            ...filterContextDefinition,
-        },
+        filterContext: filterContextDefinition
+            ? {
+                ...filterContextIdentity,
+                ...filterContextDefinition,
+            }
+            : undefined,
         layout,
         dateFilterConfig,
         ...buildOptionalFilterConfigsProps(attributeFilterConfigs, dateFilterConfigs, measureValueFilterConfigs),
@@ -207,7 +219,7 @@ function* createDashboardSaveContext(cmd, isNewDashboard) {
     };
     const dashboardToSave = {
         ...dashboardFromState,
-        layout: dashboardLayoutRemoveIdentity(layout, isTemporaryIdentity),
+        layout: layout ? dashboardLayoutRemoveIdentity(layout, isTemporaryIdentity) : undefined,
     };
     return {
         cmd,

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

@@ -1,10 +1,11 @@
-import { type DrillDefinition, type IDashboardLayout, type IDrillDownReference, type IDrillToLegacyDashboard, type IKpiWidget, type IWidget, type InsightDrillDefinition, type ObjRef, type ScreenSize } from "@gooddata/sdk-model";
+import { type DrillDefinition, type IDashboardLayout, type IDrillDownReference, type IDrillToLegacyDashboard, type IInsightWidget, type IKpiWidget, type IWidget, type InsightDrillDefinition, type ObjRef, type ScreenSize } from "@gooddata/sdk-model";
 import { type ObjRefMap } from "../../../../_staging/metadata/objRefMap.js";
 import { type IDashboardFilter, type ILayoutCoordinates, type ILayoutItemPath } from "../../../../types.js";
 import { type DashboardLayoutCommands } from "../../../commands/layout.js";
 import { type ExtendedDashboardWidget, type ICustomWidget } from "../../../types/layoutTypes.js";
 import { type IUndoableCommand } from "../../_infra/undoEnhancer.js";
 import { type DashboardSelector } from "../../types.js";
+import { type ITabState } from "../tabsState.js";
 import { type LayoutStash } from "./layoutState.js";
 /**
  * Returns layout keyed by tab identifier.
@@ -248,6 +249,45 @@ export declare const selectKpiWidgetPlaceholderCoordinates: DashboardSelector<IL
  * @alpha
  */
 export declare const selectWidgetIgnoreCrossFiltering: (ref: ObjRef) => DashboardSelector<boolean>;
+/**
+ * Per-tab widget contexts. Each entry pairs a widget with its owning tab; nested layout widgets
+ * and visualization switcher children are flattened in. Used by cross-tab widget lookups.
+ *
+ * @internal
+ */
+export interface IWidgetTabContext {
+    tab: ITabState;
+    widget: ExtendedDashboardWidget;
+}
+/**
+ * `IWidgetTabContext` narrowed to its insight-widget shape.
+ *
+ * @internal
+ */
+export interface IInsightWidgetTabContext extends IWidgetTabContext {
+    widget: IInsightWidget;
+}
+/**
+ * Cross-tab widget contexts. Walks every tab's layout (including nested layouts and visualization
+ * switcher children) once and pairs each widget with its owning tab. Consumers needing to resolve
+ * a widget's owning tab by ref or identifier should `.find()` against this array.
+ *
+ * @internal
+ */
+export declare const selectAllTabsWidgetContexts: DashboardSelector<IWidgetTabContext[]>;
+/**
+ * `selectAllTabsWidgetContexts` pre-filtered to insight-widget contexts so consumers can `.find()`
+ * against an already-narrowed array.
+ *
+ * @internal
+ */
+export declare const selectAllTabsInsightWidgetContexts: DashboardSelector<IInsightWidgetTabContext[]>;
+/**
+ * Type guard for narrowing an `IWidgetTabContext` to `IInsightWidgetTabContext`.
+ *
+ * @internal
+ */
+export declare function isInsightWidgetTabContext(context: IWidgetTabContext): context is IInsightWidgetTabContext;
 /**
  * Selects the local identifier of the tab that contains the specified widget.
  * Returns undefined if the widget is not found in any tab.

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

@@ -452,6 +452,44 @@ export const selectKpiWidgetPlaceholderCoordinates = createSelector(selectKpiWid
 export const selectWidgetIgnoreCrossFiltering = createMemoizedSelector((ref) => createSelector(selectAnalyticalWidgetByRef(ref), (widget) => {
     return widget?.ignoreCrossFiltering ?? false;
 }));
+/**
+ * Cross-tab widget contexts. Walks every tab's layout (including nested layouts and visualization
+ * switcher children) once and pairs each widget with its owning tab. Consumers needing to resolve
+ * a widget's owning tab by ref or identifier should `.find()` against this array.
+ *
+ * @internal
+ */
+export const selectAllTabsWidgetContexts = createSelector(selectTabs, (tabs) => {
+    if (!tabs) {
+        return [];
+    }
+    const result = [];
+    for (const tab of tabs) {
+        const layout = tab.layout?.layout;
+        if (!layout) {
+            continue;
+        }
+        for (const widget of getLayoutWidgets(layout)) {
+            result.push({ tab, widget });
+        }
+    }
+    return result;
+});
+/**
+ * `selectAllTabsWidgetContexts` pre-filtered to insight-widget contexts so consumers can `.find()`
+ * against an already-narrowed array.
+ *
+ * @internal
+ */
+export const selectAllTabsInsightWidgetContexts = createSelector(selectAllTabsWidgetContexts, (contexts) => contexts.filter(isInsightWidgetTabContext));
+/**
+ * Type guard for narrowing an `IWidgetTabContext` to `IInsightWidgetTabContext`.
+ *
+ * @internal
+ */
+export function isInsightWidgetTabContext(context) {
+    return isInsightWidget(context.widget);
+}
 /**
  * Selects the local identifier of the tab that contains the specified widget.
  * Returns undefined if the widget is not found in any tab.

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

@@ -0,0 +1,86 @@
+import { type IDashboardParameterValueOverride } from "@gooddata/sdk-backend-spi";
+import { type IDashboardParameter, type IDashboardTab, type IInsight, type IInsightDefinition, type IParameterMetadataObject, type IdentifierRef } from "@gooddata/sdk-model";
+import { type ObjRefMap } from "../../../../_staging/metadata/objRefMap.js";
+import { type IInsightWidgetTabContext } from "../layout/layoutSelectors.js";
+import { type ITabState } from "../tabsState.js";
+import { type IDashboardParameterEntry } from "./parametersState.js";
+/**
+ * @internal
+ */
+export declare const EMPTY_EXPORT_PARAMETERS: Record<string, IDashboardParameterValueOverride[]>;
+/**
+ * Walks the insight's metric buckets and returns the parameter refs they reference,
+ * deduped by ref string. The order matches the first occurrence in the measure traversal.
+ *
+ * @internal
+ */
+export declare function collectReferencedParameterRefs(insight: IInsightDefinition, measureParameters: Record<string, IdentifierRef[]>): IdentifierRef[];
+/**
+ * Resolves a single parameter entry to the export wire shape. Returns `undefined` for entries with
+ * no `runtimeOverride` — the dashboard's persisted parameter state and the workspace default are
+ * applied by the backend on its own, and insight-level `insight.parameters` are applied per-insight
+ * by the backend; sending a row in those cases would override the backend's resolution with a stale
+ * FE snapshot (matches the live-render path in `selectEffectiveParameterValuesForWidget`).
+ *
+ * Title precedence (when a row is emitted): `parameter.label` → workspace title → `ref.identifier`.
+ *
+ * @internal
+ */
+export declare function formatDashboardParameter(entry: IDashboardParameterEntry, workspaceParameter: IParameterMetadataObject | undefined): IDashboardParameterValueOverride | undefined;
+/**
+ * Resolves the persisted shape of a parameter entry against its workspace catalog parameter.
+ * Drops `value` when it equals the workspace default; drops `label` when it equals the workspace title.
+ *
+ * @internal
+ */
+export declare function smartPersistResolvedEntry(entry: IDashboardParameterEntry, workspaceParameter: IParameterMetadataObject): IDashboardParameter;
+/**
+ * Builds the persisted-parameter lookup keyed by tab and then by ref string. 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.
+ *
+ * @internal
+ */
+export declare function buildPersistedByTabAndRef(persistedTabs: ReadonlyArray<IDashboardTab>, rootPersistedParameters: IDashboardParameter[]): Map<string, Map<string, IDashboardParameter>>;
+/**
+ * Returns `undefined` when reset would be a no-op: missing/non-number workspace parameter, or
+ * in edit mode when `parameter.value` is unset / already equals the workspace default.
+ *
+ * @internal
+ */
+export declare function computeParameterResetValue(entry: IDashboardParameterEntry, workspaceParameter: IParameterMetadataObject | undefined, isInEditMode: boolean): number | undefined;
+/**
+ * Only `mode: "active"` entries with a defined `runtimeOverride` are considered resettable;
+ * HIDDEN and READONLY entries are skipped, and entries with `runtimeOverride === undefined`
+ * (chip hidden, execution falls back to `insight.parameters`) are preserved as-is — symmetric
+ * with per-chip behavior in `DashboardParameterFilter`.
+ *
+ * @internal
+ */
+export declare function computeParameterResetTargets(entries: IDashboardParameterEntry[], workspaceParameters: IParameterMetadataObject[], isInEditMode: boolean): {
+    ref: IDashboardParameterEntry["parameter"]["ref"];
+    value: number | undefined;
+}[];
+/**
+ * Folds per-tab ref selections into the wire shape, dropping entries without a
+ * `runtimeOverride`. Each selection pairs a tab with an optional ref restriction:
+ * `allowedRefs === undefined` selects all refs (whole-dashboard scope); a defined set restricts
+ * entries to those refs (widget scope). Tabs that yield no rows are omitted from the result.
+ *
+ * @internal
+ */
+export declare function collectExportOverrides(tabRefSelections: ReadonlyArray<{
+    tab: ITabState;
+    allowedRefs?: Set<string>;
+}>, workspaceByRef: Map<string, IParameterMetadataObject>): Record<string, IDashboardParameterValueOverride[]>;
+/**
+ * Builds per-tab ref selections for a widget-scope export: each widget's owning tab is restricted
+ * to refs referenced by the widget's insight metrics. Multiple widgets on the same tab union their
+ * refs.
+ *
+ * @internal
+ */
+export declare function buildWidgetScopeTabRefSelections(widgetContexts: ReadonlyArray<IInsightWidgetTabContext>, widgetIds: ReadonlyArray<string>, insights: ObjRefMap<IInsight>, measureParameters: Record<string, IdentifierRef[]>): {
+    tab: ITabState;
+    allowedRefs: Set<string>;
+}[];

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

@@ -0,0 +1,208 @@
+// (C) 2026 GoodData Corporation
+import { DashboardParameterModeValues, insightMeasures, isMeasureDefinition, isNumberParameterDefinition, objRefToString, } from "@gooddata/sdk-model";
+import { parametersInitialState, pickTabParametersSource, } from "./parametersState.js";
+const EMPTY_PARAMETERS = [];
+/**
+ * @internal
+ */
+export const EMPTY_EXPORT_PARAMETERS = {};
+/**
+ * Walks the insight's metric buckets and returns the parameter refs they reference,
+ * deduped by ref string. The order matches the first occurrence in the measure traversal.
+ *
+ * @internal
+ */
+export function collectReferencedParameterRefs(insight, measureParameters) {
+    const seen = new Set();
+    const result = [];
+    for (const measure of insightMeasures(insight)) {
+        const def = measure.measure.definition;
+        if (!isMeasureDefinition(def)) {
+            continue;
+        }
+        const refs = measureParameters[objRefToString(def.measureDefinition.item)] ?? [];
+        for (const ref of refs) {
+            const key = objRefToString(ref);
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            result.push(ref);
+        }
+    }
+    return result;
+}
+/**
+ * Resolves a single parameter entry to the export wire shape. Returns `undefined` for entries with
+ * no `runtimeOverride` — the dashboard's persisted parameter state and the workspace default are
+ * applied by the backend on its own, and insight-level `insight.parameters` are applied per-insight
+ * by the backend; sending a row in those cases would override the backend's resolution with a stale
+ * FE snapshot (matches the live-render path in `selectEffectiveParameterValuesForWidget`).
+ *
+ * Title precedence (when a row is emitted): `parameter.label` → workspace title → `ref.identifier`.
+ *
+ * @internal
+ */
+export function formatDashboardParameter(entry, workspaceParameter) {
+    if (entry.runtimeOverride === undefined) {
+        return undefined;
+    }
+    const ref = entry.parameter.ref;
+    return {
+        id: ref.identifier,
+        value: String(entry.runtimeOverride),
+        title: entry.parameter.label || workspaceParameter?.title || ref.identifier,
+    };
+}
+/**
+ * Resolves the persisted shape of a parameter entry against its workspace catalog parameter.
+ * Drops `value` when it equals the workspace default; drops `label` when it equals the workspace title.
+ *
+ * @internal
+ */
+export 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 {};
+}
+/**
+ * Builds the persisted-parameter lookup keyed by tab and then by ref string. 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.
+ *
+ * @internal
+ */
+export 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;
+}
+/**
+ * Returns `undefined` when reset would be a no-op: missing/non-number workspace parameter, or
+ * in edit mode when `parameter.value` is unset / already equals the workspace default.
+ *
+ * @internal
+ */
+export function computeParameterResetValue(entry, workspaceParameter, isInEditMode) {
+    if (!workspaceParameter || !isNumberParameterDefinition(workspaceParameter.definition)) {
+        return undefined;
+    }
+    const workspaceDefault = workspaceParameter.definition.defaultValue;
+    const dashboardOverride = entry.parameter.value;
+    if (isInEditMode) {
+        if (dashboardOverride === undefined || dashboardOverride === workspaceDefault) {
+            return undefined;
+        }
+        return workspaceDefault;
+    }
+    return dashboardOverride ?? workspaceDefault;
+}
+/**
+ * Only `mode: "active"` entries with a defined `runtimeOverride` are considered resettable;
+ * HIDDEN and READONLY entries are skipped, and entries with `runtimeOverride === undefined`
+ * (chip hidden, execution falls back to `insight.parameters`) are preserved as-is — symmetric
+ * with per-chip behavior in `DashboardParameterFilter`.
+ *
+ * @internal
+ */
+export function computeParameterResetTargets(entries, workspaceParameters, isInEditMode) {
+    const workspaceByRef = new Map(workspaceParameters.map((wp) => [objRefToString(wp.ref), wp]));
+    const result = [];
+    for (const entry of entries) {
+        if (entry.parameter.mode !== DashboardParameterModeValues.ACTIVE) {
+            continue;
+        }
+        if (entry.runtimeOverride === undefined) {
+            continue;
+        }
+        const workspaceParameter = workspaceByRef.get(objRefToString(entry.parameter.ref));
+        const resetValue = computeParameterResetValue(entry, workspaceParameter, isInEditMode);
+        if (resetValue !== undefined && resetValue !== entry.runtimeOverride) {
+            result.push({ ref: entry.parameter.ref, value: resetValue });
+        }
+    }
+    return result;
+}
+/**
+ * Folds per-tab ref selections into the wire shape, dropping entries without a
+ * `runtimeOverride`. Each selection pairs a tab with an optional ref restriction:
+ * `allowedRefs === undefined` selects all refs (whole-dashboard scope); a defined set restricts
+ * entries to those refs (widget scope). Tabs that yield no rows are omitted from the result.
+ *
+ * @internal
+ */
+export function collectExportOverrides(tabRefSelections, workspaceByRef) {
+    const result = {};
+    for (const { tab, allowedRefs } of tabRefSelections) {
+        const entries = tab.parameters?.parameters ?? parametersInitialState.parameters;
+        const scoped = allowedRefs
+            ? entries.filter((entry) => allowedRefs.has(objRefToString(entry.parameter.ref)))
+            : entries;
+        const rows = formatEntries(scoped, workspaceByRef);
+        if (rows.length > 0) {
+            result[tab.localIdentifier] = rows;
+        }
+    }
+    return Object.keys(result).length === 0 ? EMPTY_EXPORT_PARAMETERS : result;
+}
+/**
+ * Builds per-tab ref selections for a widget-scope export: each widget's owning tab is restricted
+ * to refs referenced by the widget's insight metrics. Multiple widgets on the same tab union their
+ * refs.
+ *
+ * @internal
+ */
+export function buildWidgetScopeTabRefSelections(widgetContexts, widgetIds, insights, measureParameters) {
+    const byTab = new Map();
+    for (const widgetId of widgetIds) {
+        const context = widgetContexts.find((ctx) => ctx.widget.identifier === widgetId);
+        if (!context) {
+            continue;
+        }
+        const insight = insights.get(context.widget.insight);
+        if (!insight) {
+            continue;
+        }
+        const referencedRefs = collectReferencedParameterRefs(insight, measureParameters);
+        if (referencedRefs.length === 0) {
+            continue;
+        }
+        const tabId = context.tab.localIdentifier;
+        const existing = byTab.get(tabId) ?? { tab: context.tab, allowedRefs: new Set() };
+        for (const ref of referencedRefs) {
+            existing.allowedRefs.add(objRefToString(ref));
+        }
+        byTab.set(tabId, existing);
+    }
+    return [...byTab.values()];
+}
+function formatEntries(entries, workspaceByRef) {
+    const rows = [];
+    for (const entry of entries) {
+        const workspaceParameter = workspaceByRef.get(objRefToString(entry.parameter.ref));
+        const row = formatDashboardParameter(entry, workspaceParameter);
+        if (row !== undefined) {
+            rows.push(row);
+        }
+    }
+    return rows;
+}

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

@@ -1,4 +1,5 @@
-import { type IDashboardParameter, type IInsightParameterValue, type IParameterMetadataObject, type ObjRef } from "@gooddata/sdk-model";
+import { type IDashboardParameterValueOverride } from "@gooddata/sdk-backend-spi";
+import { type IDashboardParameter, type IInsightParameterValue, type ObjRef } from "@gooddata/sdk-model";
 import { type DashboardSelector } from "../../types.js";
 import { type IDashboardParameterEntry } from "./parametersState.js";
 /**
@@ -108,21 +109,25 @@ export declare const selectHasAnyResettableParameterOnActiveTab: DashboardSelect
  */
 export declare const selectEffectiveParameterValuesForWidget: (ref: ObjRef | undefined) => DashboardSelector<IInsightParameterValue[]>;
 /**
- * Returns `undefined` when reset would be a no-op: missing/non-number workspace parameter, or
- * in edit mode when `parameter.value` is unset / already equals the workspace default.
+ * Returns the per-tab parameter overrides to send on dashboard tabular export, keyed by
+ * tab `localIdentifier`. The shape matches the backend's `dashboardTabsParametersOverrides`
+ * field directly.
  *
- * @internal
- */
-export declare function computeParameterResetValue(entry: IDashboardParameterEntry, workspaceParameter: IParameterMetadataObject | undefined, isInEditMode: boolean): number | undefined;
-/**
- * Only `mode: "active"` entries with a defined `runtimeOverride` are considered resettable;
- * HIDDEN and READONLY entries are skipped, and entries with `runtimeOverride === undefined`
- * (chip hidden, execution falls back to `insight.parameters`) are preserved as-is — symmetric
- * with per-chip behavior in `DashboardParameterFilter`.
+ * @remarks
+ * Scope rules:
+ * - When `widgetIds` is empty/undefined (whole-dashboard export), every tab in scope contributes
+ *   parameter entries with a `runtimeOverride`.
+ * - When `widgetIds` is non-empty, each widget's owning tab contributes only entries with a
+ *   `runtimeOverride` whose ref is referenced by the widget's insight metrics via the dashboard-wide
+ *   metric → parameter dependency map. Multi-widget across distinct owning tabs yields one
+ *   map entry per owning tab; entries for the same tab are unioned and deduplicated by ref.
+ *
+ * Returns `{}` (signalling "omit the field on the wire") when:
+ * - `enableParameters` is off,
+ * - the workspace catalog parameters are not loaded,
+ * - (widget scope only) the `measureParameters` dependency map is not loaded,
+ * - or no in-scope parameter has a `runtimeOverride`.
  *
- * @internal
+ * @alpha
  */
-export declare function computeParameterResetTargets(entries: IDashboardParameterEntry[], workspaceParameters: IParameterMetadataObject[], isInEditMode: boolean): {
-    ref: ObjRef;
-    value: number | undefined;
-}[];
+export declare const selectExportEffectiveParameters: (widgetIds: string[] | undefined) => DashboardSelector<Record<string, IDashboardParameterValueOverride[]>>;

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

@@ -1,14 +1,16 @@
 // (C) 2026 GoodData Corporation
 import { createSelector } from "@reduxjs/toolkit";
 import { isEqual } from "lodash-es";
-import { DashboardParameterModeValues, areObjRefsEqual, insightMeasures, insightParameters, isDashboardLayout, isInsightWidget, isMeasureDefinition, isNumberParameterDefinition, isVisualizationSwitcherWidget, objRefToString, } from "@gooddata/sdk-model";
+import { areObjRefsEqual, insightParameters, objRefToString, } from "@gooddata/sdk-model";
 import { createMemoizedSelector } from "../../_infra/selectors.js";
 import { selectCatalogMeasureParameters, selectCatalogMeasureParametersStatus, selectCatalogParameterByRef, selectCatalogParameters, selectCatalogParametersIsLoaded, } from "../../catalog/catalogSelectors.js";
 import { selectEnableParameters } from "../../config/configSelectors.js";
 import { selectInsightsMap } from "../../insights/insightsSelectors.js";
 import { selectIsInEditMode } from "../../renderMode/renderModeSelectors.js";
+import { selectAllTabsInsightWidgetContexts } from "../layout/layoutSelectors.js";
 import { selectActiveTab, selectTabs } from "../tabsSelectors.js";
 import { DEFAULT_TAB_ID } from "../tabsState.js";
+import { EMPTY_EXPORT_PARAMETERS, buildPersistedByTabAndRef, buildWidgetScopeTabRefSelections, collectExportOverrides, collectReferencedParameterRefs, computeParameterResetTargets, computeParameterResetValue, smartPersistResolvedEntry, } from "./parametersHelpers.js";
 import { parametersInitialState, pickTabParametersSource, } from "./parametersState.js";
 const EMPTY_PARAMETERS = [];
 const EMPTY_PARAMETER_VALUES = [];
@@ -191,25 +193,19 @@ export const selectHasAnyResettableParameterOnActiveTab = createSelector(selectA
  *
  * @alpha
  */
-export const selectEffectiveParameterValuesForWidget = createMemoizedSelector((ref) => createSelector(selectParameterExecutionContextByWidgetRef(ref), selectInsightsMap, selectEnableParameters, selectCatalogMeasureParameters, selectCatalogMeasureParametersStatus, (context, insights, isEnabled, measureParameters, measureParametersStatus) => {
-    if (!isEnabled || !context || measureParametersStatus !== "loaded") {
+export const selectEffectiveParameterValuesForWidget = createMemoizedSelector((ref) => createSelector(selectAllTabsInsightWidgetContexts, selectInsightsMap, selectEnableParameters, selectCatalogMeasureParameters, selectCatalogMeasureParametersStatus, (contexts, insights, isEnabled, measureParameters, measureParametersStatus) => {
+    if (!isEnabled || !ref || measureParametersStatus !== "loaded") {
+        return EMPTY_PARAMETER_VALUES;
+    }
+    const context = contexts.find((ctx) => areObjRefsEqual(ctx.widget.ref, ref));
+    if (!context) {
         return EMPTY_PARAMETER_VALUES;
     }
     const insight = insights.get(context.widget.insight);
     if (!insight) {
         return EMPTY_PARAMETER_VALUES;
     }
-    const referencedRefs = new Set();
-    for (const measure of insightMeasures(insight)) {
-        const def = measure.measure.definition;
-        if (!isMeasureDefinition(def)) {
-            continue;
-        }
-        const parameterRefs = measureParameters[objRefToString(def.measureDefinition.item)] ?? [];
-        for (const parameterRef of parameterRefs) {
-            referencedRefs.add(objRefToString(parameterRef));
-        }
-    }
+    const referencedRefs = new Set(collectReferencedParameterRefs(insight, measureParameters).map(objRefToString));
     const entries = context.tab.parameters?.parameters ?? parametersInitialState.parameters;
     const result = [];
     const seen = new Set();
@@ -234,121 +230,43 @@ export const selectEffectiveParameterValuesForWidget = createMemoizedSelector((r
     }
     return result.length === 0 ? EMPTY_PARAMETER_VALUES : 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 {};
-}
 /**
- * Returns `undefined` when reset would be a no-op: missing/non-number workspace parameter, or
- * in edit mode when `parameter.value` is unset / already equals the workspace default.
+ * Returns the per-tab parameter overrides to send on dashboard tabular export, keyed by
+ * tab `localIdentifier`. The shape matches the backend's `dashboardTabsParametersOverrides`
+ * field directly.
  *
- * @internal
- */
-export function computeParameterResetValue(entry, workspaceParameter, isInEditMode) {
-    if (!workspaceParameter || !isNumberParameterDefinition(workspaceParameter.definition)) {
-        return undefined;
-    }
-    const workspaceDefault = workspaceParameter.definition.defaultValue;
-    const dashboardOverride = entry.parameter.value;
-    if (isInEditMode) {
-        if (dashboardOverride === undefined || dashboardOverride === workspaceDefault) {
-            return undefined;
-        }
-        return workspaceDefault;
-    }
-    return dashboardOverride ?? workspaceDefault;
-}
-/**
- * Only `mode: "active"` entries with a defined `runtimeOverride` are considered resettable;
- * HIDDEN and READONLY entries are skipped, and entries with `runtimeOverride === undefined`
- * (chip hidden, execution falls back to `insight.parameters`) are preserved as-is — symmetric
- * with per-chip behavior in `DashboardParameterFilter`.
+ * @remarks
+ * Scope rules:
+ * - When `widgetIds` is empty/undefined (whole-dashboard export), every tab in scope contributes
+ *   parameter entries with a `runtimeOverride`.
+ * - When `widgetIds` is non-empty, each widget's owning tab contributes only entries with a
+ *   `runtimeOverride` whose ref is referenced by the widget's insight metrics via the dashboard-wide
+ *   metric → parameter dependency map. Multi-widget across distinct owning tabs yields one
+ *   map entry per owning tab; entries for the same tab are unioned and deduplicated by ref.
  *
- * @internal
+ * Returns `{}` (signalling "omit the field on the wire") when:
+ * - `enableParameters` is off,
+ * - the workspace catalog parameters are not loaded,
+ * - (widget scope only) the `measureParameters` dependency map is not loaded,
+ * - or no in-scope parameter has a `runtimeOverride`.
+ *
+ * @alpha
  */
-export function computeParameterResetTargets(entries, workspaceParameters, isInEditMode) {
-    const workspaceByRef = new Map(workspaceParameters.map((wp) => [objRefToString(wp.ref), wp]));
-    const result = [];
-    for (const entry of entries) {
-        if (entry.parameter.mode !== DashboardParameterModeValues.ACTIVE) {
-            continue;
-        }
-        if (entry.runtimeOverride === undefined) {
-            continue;
-        }
-        const workspaceParameter = workspaceByRef.get(objRefToString(entry.parameter.ref));
-        const resetValue = computeParameterResetValue(entry, workspaceParameter, isInEditMode);
-        if (resetValue !== undefined && resetValue !== entry.runtimeOverride) {
-            result.push({ ref: entry.parameter.ref, value: resetValue });
-        }
+export const selectExportEffectiveParameters = (widgetIds) => widgetIds?.length
+    ? selectExportEffectiveParametersForWidgets(widgetIds)
+    : selectExportEffectiveParametersDashboardScope;
+const selectExportEffectiveParametersDashboardScope = createSelector(selectTabs, selectEnableParameters, selectCatalogParameters, selectCatalogParametersIsLoaded, (tabs, isEnabled, catalogParameters, isCatalogLoaded) => {
+    if (!isEnabled || !isCatalogLoaded || !tabs?.length) {
+        return EMPTY_EXPORT_PARAMETERS;
     }
-    return result;
-}
+    const workspaceByRef = new Map(catalogParameters.map((parameter) => [objRefToString(parameter.ref), parameter]));
+    return collectExportOverrides(tabs.map((tab) => ({ tab })), workspaceByRef);
+});
+const selectExportEffectiveParametersForWidgets = createMemoizedSelector((widgetIds) => createSelector(selectAllTabsInsightWidgetContexts, selectInsightsMap, selectEnableParameters, selectCatalogParameters, selectCatalogParametersIsLoaded, selectCatalogMeasureParameters, selectCatalogMeasureParametersStatus, (widgetContexts, insights, isEnabled, catalogParameters, isCatalogLoaded, measureParameters, measureParametersStatus) => {
+    if (!isEnabled || !isCatalogLoaded || measureParametersStatus !== "loaded") {
+        return EMPTY_EXPORT_PARAMETERS;
+    }
+    const workspaceByRef = new Map(catalogParameters.map((parameter) => [objRefToString(parameter.ref), parameter]));
+    const tabRefSelections = buildWidgetScopeTabRefSelections(widgetContexts, widgetIds, insights, measureParameters);
+    return collectExportOverrides(tabRefSelections, workspaceByRef);
+}));

package/esm/sdk-ui-dashboard.d.ts

@@ -98,6 +98,7 @@ import { IDashboardMeasureValueFilter } from '@gooddata/sdk-model';
 import { IDashboardMeasureValueFilterConfig } from '@gooddata/sdk-model';
 import { IDashboardObjectIdentity } from '@gooddata/sdk-model';
 import { IDashboardParameter } from '@gooddata/sdk-model';
+import { IDashboardParameterValueOverride } from '@gooddata/sdk-backend-spi';
 import { IDashboardPermissions } from '@gooddata/sdk-model';
 import { IDashboardReferences } from '@gooddata/sdk-backend-spi';
 import { IDashboardWidget } from '@gooddata/sdk-model';
@@ -24093,6 +24094,30 @@ export declare const selectExecutionResultByRef: (ref: ObjRef | undefined) => Da
  */
 export declare const selectExecutionTimestamp: DashboardSelector<string | undefined>;
 
+/**
+ * Returns the per-tab parameter overrides to send on dashboard tabular export, keyed by
+ * tab `localIdentifier`. The shape matches the backend's `dashboardTabsParametersOverrides`
+ * field directly.
+ *
+ * @remarks
+ * Scope rules:
+ * - When `widgetIds` is empty/undefined (whole-dashboard export), every tab in scope contributes
+ *   parameter entries with a `runtimeOverride`.
+ * - When `widgetIds` is non-empty, each widget's owning tab contributes only entries with a
+ *   `runtimeOverride` whose ref is referenced by the widget's insight metrics via the dashboard-wide
+ *   metric → parameter dependency map. Multi-widget across distinct owning tabs yields one
+ *   map entry per owning tab; entries for the same tab are unioned and deduplicated by ref.
+ *
+ * Returns `{}` (signalling "omit the field on the wire") when:
+ * - `enableParameters` is off,
+ * - the workspace catalog parameters are not loaded,
+ * - (widget scope only) the `measureParameters` dependency map is not loaded,
+ * - or no in-scope parameter has a `runtimeOverride`.
+ *
+ * @alpha
+ */
+export declare const selectExportEffectiveParameters: (widgetIds: string[] | undefined) => DashboardSelector<Record<string, IDashboardParameterValueOverride[]>>;
+
 /**
  * Returns custom export metadata.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-ui-dashboard",
-  "version": "11.39.0",
+  "version": "11.40.0-alpha.1",
   "description": "GoodData SDK - Dashboard Component",
   "license": "LicenseRef-LICENSE",
   "author": "GoodData Corporation",
@@ -60,19 +60,19 @@
     "ts-invariant": "0.10.3",
     "tslib": "2.8.1",
     "uuid": "11.1.0",
-    "@gooddata/sdk-backend-base": "11.39.0",
-    "@gooddata/sdk-backend-spi": "11.39.0",
-    "@gooddata/sdk-ui": "11.39.0",
-    "@gooddata/sdk-ui-charts": "11.39.0",
-    "@gooddata/sdk-model": "11.39.0",
-    "@gooddata/sdk-ui-ext": "11.39.0",
-    "@gooddata/sdk-ui-filters": "11.39.0",
-    "@gooddata/sdk-ui-geo": "11.39.0",
-    "@gooddata/sdk-ui-kit": "11.39.0",
-    "@gooddata/sdk-ui-pivot": "11.39.0",
-    "@gooddata/sdk-ui-theme-provider": "11.39.0",
-    "@gooddata/sdk-ui-vis-commons": "11.39.0",
-    "@gooddata/util": "11.39.0"
+    "@gooddata/sdk-backend-base": "11.40.0-alpha.1",
+    "@gooddata/sdk-backend-spi": "11.40.0-alpha.1",
+    "@gooddata/sdk-model": "11.40.0-alpha.1",
+    "@gooddata/sdk-ui": "11.40.0-alpha.1",
+    "@gooddata/sdk-ui-charts": "11.40.0-alpha.1",
+    "@gooddata/sdk-ui-ext": "11.40.0-alpha.1",
+    "@gooddata/sdk-ui-filters": "11.40.0-alpha.1",
+    "@gooddata/sdk-ui-geo": "11.40.0-alpha.1",
+    "@gooddata/sdk-ui-pivot": "11.40.0-alpha.1",
+    "@gooddata/sdk-ui-vis-commons": "11.40.0-alpha.1",
+    "@gooddata/sdk-ui-kit": "11.40.0-alpha.1",
+    "@gooddata/util": "11.40.0-alpha.1",
+    "@gooddata/sdk-ui-theme-provider": "11.40.0-alpha.1"
   },
   "devDependencies": {
     "@microsoft/api-documenter": "^7.17.0",
@@ -118,12 +118,12 @@
     "typescript": "5.9.3",
     "vitest": "4.1.0",
     "vitest-dom": "0.1.1",
-    "@gooddata/eslint-config": "11.39.0",
-    "@gooddata/i18n-toolkit": "11.39.0",
-    "@gooddata/oxlint-config": "11.39.0",
-    "@gooddata/stylelint-config": "11.39.0",
-    "@gooddata/reference-workspace": "11.39.0",
-    "@gooddata/sdk-backend-mockingbird": "11.39.0"
+    "@gooddata/eslint-config": "11.40.0-alpha.1",
+    "@gooddata/i18n-toolkit": "11.40.0-alpha.1",
+    "@gooddata/oxlint-config": "11.40.0-alpha.1",
+    "@gooddata/reference-workspace": "11.40.0-alpha.1",
+    "@gooddata/sdk-backend-mockingbird": "11.40.0-alpha.1",
+    "@gooddata/stylelint-config": "11.40.0-alpha.1"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",