@gooddata/sdk-ui-dashboard 11.36.0-alpha.3 → 11.36.0-alpha.7

package/esm/model/commandHandlers/dashboard/common/filterViews.js

@@ -306,15 +306,17 @@ export function applyDefaultFilterView(dashboard, filterViews, settings) {
             // Use tab-specific default, or fall back to legacy global default only for the first tab
             const isFirstTab = index === 0;
             const effectiveDefaultView = tabDefaultView ?? (isFirstTab ? legacyDefaultView : undefined);
+            const parameters = applyFilterViewParameterValues(tab.parameters, effectiveDefaultView?.parameters);
             if (effectiveDefaultView && tab.filterContext && isFilterContext(tab.filterContext)) {
                 const { filterContext: updatedFilterContext, configUpdates } = changeFilterContextSelection(tab.filterContext, effectiveDefaultView.filterContext.filters, tab.attributeFilterConfigs);
                 return {
                     ...tab,
+                    ...(parameters === undefined ? {} : { parameters }),
                     filterContext: updatedFilterContext,
                     attributeFilterConfigs: applyConfigUpdates(tab.attributeFilterConfigs, configUpdates),
                 };
             }
-            return tab;
+            return parameters === undefined ? tab : { ...tab, parameters };
         });
         return {
             ...dashboard,
@@ -329,7 +331,28 @@ export function applyDefaultFilterView(dashboard, filterViews, settings) {
             ...dashboard,
             filterContext: updatedFilterContext,
             attributeFilterConfigs: applyConfigUpdates(dashboard.attributeFilterConfigs, configUpdates),
+            parameters: applyFilterViewParameterValues(dashboard.parameters, defaultFilterView.parameters),
         };
     }
     return dashboard;
 }
+/**
+ * Default filter views are applied before tab parameters are hydrated into runtime state.
+ * Copy captured filter view values into matching dashboard parameters so hydration initializes chips
+ * from the default view.
+ */
+function applyFilterViewParameterValues(dashboardParameters, filterViewParameters) {
+    if (!dashboardParameters || !filterViewParameters || filterViewParameters.length === 0) {
+        return dashboardParameters;
+    }
+    return dashboardParameters.map((parameter) => {
+        const filterViewParameter = filterViewParameters.find((item) => areObjRefsEqual(item.ref, parameter.ref));
+        if (!filterViewParameter) {
+            return parameter;
+        }
+        if (filterViewParameter.value === undefined) {
+            return omit(parameter, ["value"]);
+        }
+        return { ...parameter, value: filterViewParameter.value };
+    });
+}

package/esm/model/commandHandlers/dashboard/common/parameterHydration.d.ts

@@ -17,5 +17,11 @@ export declare function hydrateParameterEntries(dashboardParameters: IDashboardP
  *
  * For legacy single-tab dashboards (no `tabs[]`), a synthetic tab with `DEFAULT_TAB_ID` is used
  * so the V1 root-level `parameters` migrate transparently.
+ *
+ * `activeTabOverride` patches `runtimeOverride` on its named tab for refs that match an entry;
+ * non-matching refs are silently ignored (see `overrideDefaultParameters` on DashboardConfig).
  */
-export declare function distributeParametersToTabs(tabs: IDashboardTab[] | undefined, rootParameters: IDashboardParameter[] | undefined, workspaceParameters: IParameterMetadataObject[]): Record<string, IDashboardParameterEntry[]>;
+export declare function distributeParametersToTabs(tabs: IDashboardTab[] | undefined, rootParameters: IDashboardParameter[] | undefined, workspaceParameters: IParameterMetadataObject[], activeTabOverride?: {
+    tabId: string;
+    overrides: IDashboardParameter[];
+}): Record<string, IDashboardParameterEntry[]>;

package/esm/model/commandHandlers/dashboard/common/parameterHydration.js

@@ -34,15 +34,29 @@ export function hydrateParameterEntries(dashboardParameters, workspaceParameters
  *
  * For legacy single-tab dashboards (no `tabs[]`), a synthetic tab with `DEFAULT_TAB_ID` is used
  * so the V1 root-level `parameters` migrate transparently.
+ *
+ * `activeTabOverride` patches `runtimeOverride` on its named tab for refs that match an entry;
+ * non-matching refs are silently ignored (see `overrideDefaultParameters` on DashboardConfig).
  */
-export function distributeParametersToTabs(tabs, rootParameters, workspaceParameters) {
+export function distributeParametersToTabs(tabs, rootParameters, workspaceParameters, activeTabOverride) {
     const effectiveTabs = tabs ?? [
         { localIdentifier: DEFAULT_TAB_ID, title: "", parameters: rootParameters },
     ];
     const result = {};
     for (const tab of effectiveTabs) {
         const source = pickTabParametersSource(tab, effectiveTabs, rootParameters);
-        result[tab.localIdentifier] = hydrateParameterEntries(source, workspaceParameters);
+        const entries = hydrateParameterEntries(source, workspaceParameters);
+        result[tab.localIdentifier] =
+            tab.localIdentifier === activeTabOverride?.tabId
+                ? applyRuntimeOverrides(entries, activeTabOverride.overrides)
+                : entries;
     }
     return result;
 }
+function applyRuntimeOverrides(entries, overrides) {
+    const overrideByRef = new Map(overrides.map((o) => [objRefToString(o.ref), o.value]));
+    return entries.map((entry) => {
+        const key = objRefToString(entry.parameter.ref);
+        return overrideByRef.has(key) ? { ...entry, runtimeOverride: overrideByRef.get(key) } : entry;
+    });
+}

package/esm/model/commandHandlers/dashboard/common/stateInitializers.js

@@ -394,8 +394,10 @@ export function* actionsToInitializeExistingDashboard(ctx, dashboard, insights,
      */
     const dashboardLayout = dashboardLayoutSanitize(customizedDashboard.layout ?? EmptyDashboardLayout, insights, settings);
     const screen = yield select(selectScreen);
-    const parameterSourceDashboard = persistedDashboard ?? dashboard;
-    const parametersByTab = distributeParametersToTabs(parameterSourceDashboard.tabs, parameterSourceDashboard.parameters, workspaceParameters);
+    const overrideDefaultParameters = ctx.config?.overrideDefaultParameters;
+    const parametersByTab = distributeParametersToTabs(dashboard.tabs, dashboard.parameters, workspaceParameters, overrideDefaultParameters
+        ? { tabId: effectiveActiveTabId, overrides: overrideDefaultParameters }
+        : undefined);
     // Process tabs with complete filterContext initialization for each tab
     let tabsAction = null;
     const validationResults = [];

package/esm/model/commandHandlers/drill/resolveDrillToCustomUrl.d.ts

@@ -1,5 +1,5 @@
 import { type SagaIterator } from "redux-saga";
-import { type DashboardTextAttributeFilter, type IAttributeDisplayFormMetadataObject, type IDrillToCustomUrl as IDrillToCustomUrlModel, type ObjRef, type TextAttributeFilter } from "@gooddata/sdk-model";
+import { type DashboardTextAttributeFilter, type IAttributeDisplayFormMetadataObject, type IDrillToCustomUrl as IDrillToCustomUrlModel, type MeasureValueFilterCondition, type ObjRef, type TextAttributeFilter } from "@gooddata/sdk-model";
 import { type IDrillEvent, type IDrillEventIntersectionElement } from "@gooddata/sdk-ui";
 import { type IDrillToCustomUrl } from "../../commands/drill.js";
 import { type DashboardContext } from "../../types/commonTypes.js";
@@ -22,6 +22,8 @@ export declare function loadAttributeElementsForDrillIntersection(drillIntersect
 export declare function getAttributeDisplayForms(projectId: string, objRefs: ObjRef[], ctx: DashboardContext): Promise<IAttributeDisplayFormMetadataObject[]>;
 export declare function getAttributeIdentifiersReplacements(url: string, drillIntersectionElements: IDrillEventIntersectionElement[], ctx: DashboardContext): SagaIterator<IDrillToUrlPlaceholderReplacement[]>;
 export declare function getDashboardAttributeFilterReplacements(url: string, ctx: DashboardContext): SagaIterator<IDrillToUrlPlaceholderReplacement[]>;
+export declare function getDashboardMeasureValueFilterReplacements(url: string): SagaIterator<IDrillToUrlPlaceholderReplacement[]>;
+export declare function getInsightMeasureValueFilterReplacements(url: string, widgetRef: ObjRef): SagaIterator<IDrillToUrlPlaceholderReplacement[]>;
 export declare function getInsightAttributeFilterReplacements(url: string, widgetRef: ObjRef): SagaIterator<IDrillToUrlPlaceholderReplacement[]>;
 export declare function getInsightIdentifiersReplacements(customUrl: string, widgetRef: ObjRef, ctx: DashboardContext): SagaIterator<IDrillToUrlPlaceholderReplacement[]>;
 export declare function resolveDrillToCustomUrl(drillConfig: IDrillToCustomUrlModel, widgetRef: ObjRef, event: IDrillEvent, ctx: DashboardContext, cmd: IDrillToCustomUrl): SagaIterator<string>;
@@ -29,4 +31,8 @@ export declare function resolveDrillToCustomUrl(drillConfig: IDrillToCustomUrlMo
  * @internal
  */
 export declare function stringifyTextFilterSelection(filter: DashboardTextAttributeFilter | TextAttributeFilter): string;
+/**
+ * @internal
+ */
+export declare function stringifyMeasureValueFilterCondition(conditions: MeasureValueFilterCondition[] | undefined): string;
 export {};

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

@@ -2,19 +2,21 @@
 import stringify from "json-stable-stringify";
 import { groupBy } from "lodash-es";
 import { all, call, select } from "redux-saga/effects";
-import { areObjRefsEqual, dashboardAttributeFilterItemDisplayForm, filterAttributeElements, filterObjRef, idRef, insightId, isArbitraryAttributeFilter, isAttributeDescriptor, isAttributeElementsByValue, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardTextAttributeFilter, isNegativeAttributeFilter, isTextAttributeFilter, } from "@gooddata/sdk-model";
-import { getAttributeIdentifiersPlaceholdersFromUrl, getDashboardAttributeFilterPlaceholdersFromUrl, getInsightAttributeFilterPlaceholdersFromUrl, } from "@gooddata/sdk-model/internal";
+import { areObjRefsEqual, dashboardAttributeFilterItemDisplayForm, dashboardFilterObjRef, filterAttributeElements, filterObjRef, idRef, insightFilters as insightDefinitionFilters, insightId, isArbitraryAttributeFilter, isAttributeDescriptor, isAttributeElementsByValue, isComparisonCondition, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardTextAttributeFilter, isMeasureValueFilter, isNegativeAttributeFilter, isRangeCondition, isTextAttributeFilter, measureValueFilterConditions, measureValueFilterMeasure, } from "@gooddata/sdk-model";
+import { getAttributeIdentifiersPlaceholdersFromUrl, getDashboardAttributeFilterPlaceholdersFromUrl, getDashboardMeasureValueFilterPlaceholdersFromUrl, getInsightAttributeFilterPlaceholdersFromUrl, getInsightMeasureValueFilterPlaceholdersFromUrl, } from "@gooddata/sdk-model/internal";
 import { isDrillIntersectionAttributeItem, } from "@gooddata/sdk-ui";
 import { invalidArgumentsProvided } from "../../events/general.js";
 import { queryWidgetFilters } from "../../queries/widgets.js";
 import { query } from "../../store/_infra/queryCall.js";
-import { selectAllCatalogDisplayFormsMap, selectCatalogDateAttributes, } from "../../store/catalog/catalogSelectors.js";
+import { selectAllCatalogDisplayFormsMap, selectAllCatalogMeasuresMap, selectCatalogDateAttributes, } from "../../store/catalog/catalogSelectors.js";
+import { selectEnableMeasureValueFilterKD } from "../../store/config/configSelectors.js";
 import { selectInsightByRef } from "../../store/insights/insightsSelectors.js";
 import { selectDashboardId } from "../../store/meta/metaSelectors.js";
 import { selectAttributeFilterConfigsOverrides } from "../../store/tabs/attributeFilterConfigs/attributeFilterConfigsSelectors.js";
-import { selectFilterContextAttributeFilterItems } from "../../store/tabs/filterContext/filterContextSelectors.js";
+import { selectFilterContextAttributeFilterItems, selectFilterContextMeasureValueFilters, } from "../../store/tabs/filterContext/filterContextSelectors.js";
 import { selectAnalyticalWidgetByRef } from "../../store/tabs/layout/layoutSelectors.js";
 import { DRILL_TO_URL_PLACEHOLDER } from "../../types/drillTypes.js";
+import { dashboardMeasureValueFilterMatchesIdentifier, insightMeasureValueFilterMatchesIdentifier, } from "../../utils/measureValueFilterUtils.js";
 import { getElementTitle, getElementsSecondaryTitles } from "./getElementTitle.js";
 export function* loadElementTitle(dfRef, dfIdentifier, attrElementUri, ctx) {
     const elementTitle = yield call(getElementTitle, ctx.workspace, dfRef, attrElementUri, ctx);
@@ -164,6 +166,49 @@ export function* getDashboardAttributeFilterReplacements(url, ctx) {
     const attributeFilterConfigs = yield select(selectAttributeFilterConfigsOverrides);
     return yield all(attributeFilterPlaceholders.map((placeholder) => call(resolveDashboardAttributeFilterReplacement, placeholder, attributeFilters, catalogDisplayForms, attributeFilterConfigs, ctx)));
 }
+function resolveDashboardMeasureValueFilterReplacement({ placeholder: toBeReplaced, identifier }, measureValueFilters, catalogMeasures) {
+    const usedFilter = measureValueFilters.find((filter) => {
+        const measureRef = dashboardFilterObjRef(filter);
+        return dashboardMeasureValueFilterMatchesIdentifier(measureRef, identifier, catalogMeasures);
+    });
+    const parsedFilter = stringifyMeasureValueFilterCondition(usedFilter?.dashboardMeasureValueFilter.conditions);
+    const replacement = usedFilter ? encodeParameterIfSet(parsedFilter) : undefined;
+    return {
+        toBeReplaced,
+        replacement: replacement,
+    };
+}
+export function* getDashboardMeasureValueFilterReplacements(url) {
+    const measureValueFilterPlaceholders = getDashboardMeasureValueFilterPlaceholdersFromUrl(url);
+    if (measureValueFilterPlaceholders.length === 0) {
+        return [];
+    }
+    const measureValueFilters = yield select(selectFilterContextMeasureValueFilters);
+    const catalogMeasures = yield select(selectAllCatalogMeasuresMap);
+    return measureValueFilterPlaceholders.map((placeholder) => resolveDashboardMeasureValueFilterReplacement(placeholder, measureValueFilters, catalogMeasures));
+}
+function resolveInsightMeasureValueFilterReplacement({ placeholder: toBeReplaced, identifier }, measureValueFilters) {
+    const usedFilter = measureValueFilters.find((filter) => {
+        const measureRef = measureValueFilterMeasure(filter);
+        return insightMeasureValueFilterMatchesIdentifier(measureRef, identifier);
+    });
+    const parsedFilter = stringifyMeasureValueFilterCondition(usedFilter ? measureValueFilterConditions(usedFilter) : undefined);
+    const replacement = usedFilter ? encodeParameterIfSet(parsedFilter) : undefined;
+    return {
+        toBeReplaced,
+        replacement: replacement,
+    };
+}
+export function* getInsightMeasureValueFilterReplacements(url, widgetRef) {
+    const measureValueFilterPlaceholders = getInsightMeasureValueFilterPlaceholdersFromUrl(url);
+    if (measureValueFilterPlaceholders.length === 0) {
+        return [];
+    }
+    const widget = yield select(selectAnalyticalWidgetByRef(widgetRef));
+    const insight = yield select(selectInsightByRef(widget.insight));
+    const measureValueFilters = insight ? insightDefinitionFilters(insight).filter(isMeasureValueFilter) : [];
+    return measureValueFilterPlaceholders.map((placeholder) => resolveInsightMeasureValueFilterReplacement(placeholder, measureValueFilters));
+}
 export function* getInsightAttributeFilterReplacements(url, widgetRef) {
     const attributeFilterPlaceholders = getInsightAttributeFilterPlaceholdersFromUrl(url);
     if (attributeFilterPlaceholders.length === 0) {
@@ -224,10 +269,20 @@ export function* resolveDrillToCustomUrl(drillConfig, widgetRef, event, ctx, cmd
     const attributeIdentifiersReplacements = yield call(getAttributeIdentifiersReplacements, customUrl, event.drillContext.intersection, ctx);
     const dashboardAttributeFilterReplacements = yield call(getDashboardAttributeFilterReplacements, customUrl, ctx);
     const insightAttributeFilterReplacements = yield call(getInsightAttributeFilterReplacements, customUrl, widgetRef);
+    const dashboardMeasureValueFilterReplacements = yield call(getDashboardMeasureValueFilterReplacements, customUrl);
+    const enableMeasureValueFilterKD = yield select(selectEnableMeasureValueFilterKD);
+    const insightMeasureValueFilterReplacements = enableMeasureValueFilterKD
+        ? yield call(getInsightMeasureValueFilterReplacements, customUrl, widgetRef)
+        : getInsightMeasureValueFilterPlaceholdersFromUrl(customUrl).map(({ placeholder }) => ({
+            toBeReplaced: placeholder,
+            replacement: undefined,
+        }));
     const missingReplacement = [
         ...attributeIdentifiersReplacements,
         ...dashboardAttributeFilterReplacements,
         ...insightAttributeFilterReplacements,
+        ...dashboardMeasureValueFilterReplacements,
+        ...insightMeasureValueFilterReplacements,
     ].find(({ replacement }) => replacement === undefined);
     if (missingReplacement) {
         throw invalidArgumentsProvided(ctx, cmd, `Drill to custom URL unable to resolve missing parameter ${missingReplacement.toBeReplaced}`);
@@ -237,6 +292,8 @@ export function* resolveDrillToCustomUrl(drillConfig, widgetRef, event, ctx, cmd
         ...attributeIdentifiersReplacements,
         ...dashboardAttributeFilterReplacements,
         ...insightAttributeFilterReplacements,
+        ...dashboardMeasureValueFilterReplacements,
+        ...insightMeasureValueFilterReplacements,
         ...insightIdentifiersReplacements,
     ];
     return applyReplacements(customUrl, replacements);
@@ -265,3 +322,22 @@ function stringifyMatchFilterSelection(literal, operator, isNegative) {
     const prefix = isNegative ? `NOT_${operatorStr}` : operatorStr;
     return `${prefix}${stringify([literal])}`;
 }
+/**
+ * @internal
+ */
+export function stringifyMeasureValueFilterCondition(conditions) {
+    if (!conditions || conditions.length === 0) {
+        return "ALL";
+    }
+    return conditions
+        .map((condition) => {
+        if (isComparisonCondition(condition)) {
+            return `${condition.comparison.operator}(${condition.comparison.value})`;
+        }
+        if (isRangeCondition(condition)) {
+            return `${condition.range.operator}(${condition.range.from},${condition.range.to})`;
+        }
+        return "ALL";
+    })
+        .join("|");
+}

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

@@ -4,6 +4,7 @@ import { areObjRefsEqual, isDashboardAttributeFilter, } from "@gooddata/sdk-mode
 import { defaultErrorHandler } from "@gooddata/sdk-ui";
 import { changeFilterContextSelectionByParams, reloadFilterViews, } from "../../commands/filters.js";
 import { filterViewApplicationFailed, filterViewApplicationSucceeded, filterViewCreationFailed, filterViewCreationSucceeded, filterViewDefaultStatusChangeFailed, filterViewDefaultStatusChangeSucceeded, filterViewDeletionFailed, filterViewDeletionSucceeded, } from "../../events/filters.js";
+import { selectCatalogParameters } from "../../store/catalog/catalogSelectors.js";
 import { selectIsApplyFiltersAllAtOnceEnabledAndSet } from "../../store/config/configSelectors.js";
 import { selectCrossFilteringFiltersLocalIdentifiers } from "../../store/drill/drillSelectors.js";
 import { selectFilterViews } from "../../store/filterViews/filterViewsReducersSelectors.js";
@@ -11,9 +12,11 @@ import { filterViewsActions } from "../../store/filterViews/index.js";
 import { selectAttributeFilterConfigsOverrides } from "../../store/tabs/attributeFilterConfigs/attributeFilterConfigsSelectors.js";
 import { selectFilterContextDefinition, selectWorkingFilterContextDefinition, } from "../../store/tabs/filterContext/filterContextSelectors.js";
 import { tabsActions } from "../../store/tabs/index.js";
+import { selectFilterViewParameters } from "../../store/tabs/parameters/parametersSelectors.js";
 import { selectActiveTabLocalIdentifier } from "../../store/tabs/tabsSelectors.js";
 import { loadFilterViews } from "../dashboard/initializeDashboardHandler/loadFilterViews.js";
 import { resetCrossFiltering } from "./common.js";
+import { resolveFilterViewParameterValues } from "./filterViewParameters.js";
 function createFilterView(ctx, filterView) {
     return ctx.backend.workspace(ctx.workspace).dashboards().createFilterView(filterView);
 }
@@ -36,6 +39,7 @@ export function* saveFilterViewHandler(ctx, cmd) {
             !filter.attributeFilter.localIdentifier ||
             !virtualFilters.includes(filter.attributeFilter.localIdentifier)),
     };
+    const parameters = yield select(selectFilterViewParameters);
     const filterView = {
         name: cmd.payload.name,
         dashboard: ctx.dashboardRef,
@@ -43,6 +47,7 @@ export function* saveFilterViewHandler(ctx, cmd) {
         isDefault: cmd.payload.isDefault,
         // Include tabId if there's an active tab
         ...(activeTabLocalIdentifier ? { tabLocalIdentifier: activeTabLocalIdentifier } : {}),
+        ...(parameters ? { parameters } : {}),
     };
     try {
         const newFilterView = yield call(createFilterView, ctx, filterView);
@@ -91,6 +96,11 @@ export function* applyFilterViewHandler(ctx, cmd) {
             resetOthers: true,
             correlationId: cmd.correlationId,
         }));
+        if (filterView.parameters && filterView.parameters.length > 0) {
+            const workspaceParameters = yield select(selectCatalogParameters);
+            const values = resolveFilterViewParameterValues(filterView.parameters, workspaceParameters);
+            yield put(tabsActions.setParameterRuntimeValues({ values }));
+        }
         yield put(filterViewApplicationSucceeded(ctx, filterView, cmd.correlationId));
     }
     else {

package/esm/model/commandHandlers/filterContext/filterViewParameters.d.ts

@@ -0,0 +1,7 @@
+import { type IDashboardParameter, type IParameterMetadataObject, type ObjRef } from "@gooddata/sdk-model";
+interface IResolvedFilterViewParameter {
+    ref: ObjRef;
+    value: number | undefined;
+}
+export declare function resolveFilterViewParameterValues(parameters: ReadonlyArray<IDashboardParameter>, workspaceParameters: ReadonlyArray<IParameterMetadataObject>): IResolvedFilterViewParameter[];
+export {};

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

@@ -0,0 +1,11 @@
+// (C) 2026 GoodData Corporation
+import { areObjRefsEqual, } from "@gooddata/sdk-model";
+export function resolveFilterViewParameterValues(parameters, workspaceParameters) {
+    return parameters.map((parameter) => {
+        if (parameter.value !== undefined) {
+            return { ref: parameter.ref, value: parameter.value };
+        }
+        const workspaceParameter = workspaceParameters.find((item) => areObjRefsEqual(item.ref, parameter.ref));
+        return { ref: parameter.ref, value: workspaceParameter?.definition.defaultValue };
+    });
+}

package/esm/model/store/config/configSelectors.d.ts

@@ -467,12 +467,6 @@ export declare const selectEnableExecutionCancelling: DashboardSelector<boolean>
  * @internal
  */
 export declare const selectEnableDashboardShareLink: DashboardSelector<boolean>;
-/**
- * Selector for the automation filter context feature flag
- *
- * @internal
- */
-export declare const selectEnableAutomationFilterContext: DashboardSelector<boolean>;
 /**
  * Selector for the date filter local identifiers feature flag
  *
@@ -563,12 +557,6 @@ export declare const selectEnableSnapshotExport: DashboardSelector<boolean>;
  * @internal
  */
 export declare const selectEnableAccessibilityMode: DashboardSelector<boolean>;
-/**
- * Returns whether implicit drill to url feature is enabled.
- *
- * @alpha
- */
-export declare const selectEnableImplicitDrillToUrl: DashboardSelector<boolean>;
 /**
  * Returns the timeout to use when polling for export results (in milliseconds).
  *

package/esm/model/store/config/configSelectors.js

@@ -630,14 +630,6 @@ export const selectEnableExecutionCancelling = createSelector(selectConfig, (sta
 export const selectEnableDashboardShareLink = createSelector(selectConfig, (state) => {
     return Boolean(state.settings?.enableDashboardShareLink);
 });
-/**
- * Selector for the automation filter context feature flag
- *
- * @internal
- */
-export const selectEnableAutomationFilterContext = createSelector(selectConfig, (state) => {
-    return Boolean(state.settings?.enableAutomationFilterContext);
-});
 /**
  * Selector for the date filter local identifiers feature flag
  *
@@ -758,14 +750,6 @@ export const selectEnableSnapshotExport = createSelector(selectConfig, (state) =
 export const selectEnableAccessibilityMode = createSelector(selectConfig, (state) => {
     return Boolean(state.settings?.enableAccessibilityMode);
 });
-/**
- * Returns whether implicit drill to url feature is enabled.
- *
- * @alpha
- */
-export const selectEnableImplicitDrillToUrl = createSelector(selectConfig, (state) => {
-    return state.settings?.enableImplicitDrillToUrl ?? true;
-});
 /**
  * Returns the timeout to use when polling for export results (in milliseconds).
  *
@@ -784,8 +768,8 @@ export const selectExportResultPollingTimeout = createSelector(selectConfig, (st
  *
  * @alpha
  */
-export const selectEnableDrillToUrlByDefault = createSelector(selectConfig, selectEnableImplicitDrillToUrl, (state, enableImplicitDrillToUrl) => {
-    return enableImplicitDrillToUrl ? (state.settings?.enableDrillToUrlByDefault ?? false) : false;
+export const selectEnableDrillToUrlByDefault = createSelector(selectConfig, (state) => {
+    return state.settings?.enableDrillToUrlByDefault ?? false;
 });
 /**
  * Returns whether fiscal calendars feature flag is enabled.

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

@@ -575,6 +575,10 @@ export declare const tabsActions: import("@reduxjs/toolkit").CaseReducerActions<
         payload: import("./parameters/parametersReducers.js").ISetParameterRuntimeValuePayload;
         type: string;
     }) => void | import("./tabsState.js").ITabsState | import("immer").WritableDraft<import("./tabsState.js").ITabsState>;
+    readonly setParameterRuntimeValues: (state: import("immer").WritableDraft<import("./tabsState.js").ITabsState>, action: {
+        payload: import("./parameters/parametersReducers.js").ISetParameterRuntimeValuesPayload;
+        type: string;
+    }) => void | import("./tabsState.js").ITabsState | import("immer").WritableDraft<import("./tabsState.js").ITabsState>;
     readonly removeParameter: (state: import("immer").WritableDraft<import("./tabsState.js").ITabsState>, action: {
         payload: import("./parameters/parametersReducers.js").IRemoveParameterPayload;
         type: string;

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

@@ -17,7 +17,13 @@ export interface IAddParameterPayload {
  */
 export interface ISetParameterRuntimeValuePayload {
     ref: ObjRef;
-    value: number;
+    value: number | undefined;
+}
+/**
+ * @alpha
+ */
+export interface ISetParameterRuntimeValuesPayload {
+    values: ISetParameterRuntimeValuePayload[];
 }
 /**
  * @alpha
@@ -34,6 +40,10 @@ export declare const parametersReducers: {
         payload: ISetParameterRuntimeValuePayload;
         type: string;
     }>;
+    setParameterRuntimeValues: ParametersReducer<{
+        payload: ISetParameterRuntimeValuesPayload;
+        type: string;
+    }>;
     removeParameter: ParametersReducer<{
         payload: IRemoveParameterPayload;
         type: string;

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

@@ -20,14 +20,11 @@ const addParameter = (state, action) => {
     };
 };
 const setParameterRuntimeValue = (state, action) => {
-    const activeTab = getActiveTab(state);
-    if (!activeTab?.parameters) {
-        return;
-    }
-    const { ref, value } = action.payload;
-    const entry = activeTab.parameters.parameters.find((item) => areObjRefsEqual(item.parameter.ref, ref));
-    if (entry) {
-        entry.runtimeOverride = value;
+    setRuntimeOverride(state, action.payload);
+};
+const setParameterRuntimeValues = (state, action) => {
+    for (const entry of action.payload.values) {
+        setRuntimeOverride(state, entry);
     }
 };
 const removeParameter = (state, action) => {
@@ -39,8 +36,19 @@ const removeParameter = (state, action) => {
         parameters: activeTab.parameters.parameters.filter((entry) => !areObjRefsEqual(entry.parameter.ref, action.payload.ref)),
     };
 };
+function setRuntimeOverride(state, { ref, value }) {
+    const activeTab = getActiveTab(state);
+    if (!activeTab?.parameters) {
+        return;
+    }
+    const entry = activeTab.parameters.parameters.find((item) => areObjRefsEqual(item.parameter.ref, ref));
+    if (entry && entry.runtimeOverride !== value) {
+        entry.runtimeOverride = value;
+    }
+}
 export const parametersReducers = {
     addParameter,
     setParameterRuntimeValue,
+    setParameterRuntimeValues,
     removeParameter,
 };

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

@@ -20,6 +20,13 @@ export declare const selectActiveParameterRefKeys: DashboardSelector<ReadonlySet
  * @internal
  */
 export declare const selectDashboardParameterEntries: DashboardSelector<IDashboardParameterEntry[]>;
+/**
+ * Returns the active tab's parameters in the shape persisted by a filter view.
+ * Runtime overrides become persisted `value`; existing parameter values are kept when no runtime value exists.
+ *
+ * @internal
+ */
+export declare const selectFilterViewParameters: DashboardSelector<IDashboardParameter[] | undefined>;
 /**
  * Returns a selector that yields the entry held by the active tab for a given parameter ref,
  * or `undefined` if no such entry exists.

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

@@ -35,6 +35,23 @@ export const selectActiveParameterRefKeys = createSelector(selectDashboardParame
  * @internal
  */
 export const selectDashboardParameterEntries = createSelector(selectParametersState, (state) => state.parameters);
+/**
+ * Returns the active tab's parameters in the shape persisted by a filter view.
+ * Runtime overrides become persisted `value`; existing parameter values are kept when no runtime value exists.
+ *
+ * @internal
+ */
+export const selectFilterViewParameters = createSelector(selectDashboardParameterEntries, (entries) => {
+    if (entries.length === 0) {
+        return undefined;
+    }
+    return entries.map((entry) => {
+        if (entry.runtimeOverride === undefined) {
+            return entry.parameter;
+        }
+        return { ...entry.parameter, value: entry.runtimeOverride };
+    });
+});
 /**
  * Returns a selector that yields the entry held by the active tab for a given parameter ref,
  * or `undefined` if no such entry exists.

package/esm/model/store/widgetDrills/widgetDrillSelectors.js

@@ -10,7 +10,7 @@ import { createMemoizedSelector } from "../_infra/selectors.js";
 import { selectAccessibleDashboardsLoaded, selectAccessibleDashboardsMap, } from "../accessibleDashboards/accessibleDashboardsSelectors.js";
 import { selectBackendCapabilities, selectSupportsAttributeHierarchies, selectSupportsCrossFiltering, } from "../backendCapabilities/backendCapabilitiesSelectors.js";
 import { selectAllCatalogAttributeHierarchies, selectAllCatalogAttributesMap, selectAllCatalogDisplayFormsMap, selectAttributesWithDisplayFormLink, selectAttributesWithHierarchyDescendants, selectCatalogDateAttributes, selectCatalogIsLoaded, } from "../catalog/catalogSelectors.js";
-import { selectDisableDefaultDrills, selectEnableDrillToUrlByDefault, selectEnableImplicitDrillToUrl, selectEnableKDCrossFiltering, selectEnableKda, selectIsDisabledCrossFiltering, selectIsDisabledKda, selectIsEmbedded, } from "../config/configSelectors.js";
+import { selectDisableDefaultDrills, selectEnableDrillToUrlByDefault, selectEnableKDCrossFiltering, selectEnableKda, selectIsDisabledCrossFiltering, selectIsDisabledKda, selectIsEmbedded, } from "../config/configSelectors.js";
 import { selectDrillableItems } from "../drill/drillSelectors.js";
 import { selectDrillTargetsByWidgetRef } from "../drillTargets/drillTargetsSelectors.js";
 import { selectInsightByWidgetRef, selectInsightsMap } from "../insights/insightsSelectors.js";
@@ -126,14 +126,11 @@ function getDrillDownDefinitionsWithPredicates(availableDrillAttributes, attribu
         });
     });
 }
-function getDrillToUrlDefinitionsWithPredicates(availableDrillAttributes, attributesWithDisplayFormLink, ignoredDrillToUrlAttributes, enableImplicitDrillToUrl) {
+function getDrillToUrlDefinitionsWithPredicates(availableDrillAttributes, attributesWithDisplayFormLink, ignoredDrillToUrlAttributes) {
     const matchingAvailableDrillAttributes = availableDrillAttributes.filter((candidate) => {
         return attributesWithDisplayFormLink.some((attr) => areObjRefsEqual(attr.attribute.ref, candidate.attribute.attributeHeader.formOf.ref));
     });
     const filterIgnoredDrillToUrlAttributes = (targetAttribute) => {
-        if (!enableImplicitDrillToUrl) {
-            return true;
-        }
         return !ignoredDrillToUrlAttributes?.some((ignoredAttributeRef) => areObjRefsEqual(targetAttribute.attribute.attributeHeader.ref, ignoredAttributeRef));
     };
     const mapDrillTargetToDefinition = (targetAttribute) => {
@@ -304,10 +301,7 @@ export const selectGlobalDrillsDownAttributeHierarchyByWidgetRef = createMemoize
 /**
  * @internal
  */
-export const selectDrillsToUrlAttributeByWidgetRef = createMemoizedSelector((ref) => createSelector(selectDrillTargetsByWidgetRef(ref), selectIgnoredDrillToUrlAttributesByWidgetRef(ref), selectInsightByWidgetRef(ref), selectAllCatalogDisplayFormsMap, selectAllCatalogAttributesMap, selectEnableDrillToUrlByDefault, selectEnableImplicitDrillToUrl, (availableDrillTargets, ignoredDrillToUrlAttributes, widgetInsight, allCatalogDisplayFormsMap, allCatalogAttributesMap, enableDrillToUrlByDefault, enableImplicitDrillToUrl) => {
-    if (!enableImplicitDrillToUrl) {
-        return [];
-    }
+export const selectDrillsToUrlAttributeByWidgetRef = createMemoizedSelector((ref) => createSelector(selectDrillTargetsByWidgetRef(ref), selectIgnoredDrillToUrlAttributesByWidgetRef(ref), selectInsightByWidgetRef(ref), selectAllCatalogDisplayFormsMap, selectAllCatalogAttributesMap, selectEnableDrillToUrlByDefault, (availableDrillTargets, ignoredDrillToUrlAttributes, widgetInsight, allCatalogDisplayFormsMap, allCatalogAttributesMap, enableDrillToUrlByDefault) => {
     const disableDrillIntoURL = widgetInsight?.insight?.properties?.["controls"]?.disableDrillIntoURL ??
         !enableDrillToUrlByDefault;
     if (disableDrillIntoURL) {
@@ -341,9 +335,9 @@ export const selectDrillsToUrlAttributeByWidgetRef = createMemoizedSelector((ref
 /**
  * @internal
  */
-export const selectImplicitDrillsToUrlByWidgetRef = createMemoizedSelector((ref) => createSelector(selectDrillTargetsByWidgetRef(ref), selectAttributesWithDisplayFormLink, selectIgnoredDrillToUrlAttributesByWidgetRef(ref), selectEnableImplicitDrillToUrl, (availableDrillTargets, attributesWithLink, ignoredDrillToUrlAttributes, enableImplicitDrillToUrl) => {
+export const selectImplicitDrillsToUrlByWidgetRef = createMemoizedSelector((ref) => createSelector(selectDrillTargetsByWidgetRef(ref), selectAttributesWithDisplayFormLink, selectIgnoredDrillToUrlAttributesByWidgetRef(ref), (availableDrillTargets, attributesWithLink, ignoredDrillToUrlAttributes) => {
     const availableDrillAttributes = availableDrillTargets?.availableDrillTargets?.attributes ?? [];
-    return getDrillToUrlDefinitionsWithPredicates(availableDrillAttributes, attributesWithLink, ignoredDrillToUrlAttributes, enableImplicitDrillToUrl);
+    return getDrillToUrlDefinitionsWithPredicates(availableDrillAttributes, attributesWithLink, ignoredDrillToUrlAttributes);
 }));
 /**
  * @internal
@@ -433,9 +427,9 @@ const selectKeyDriverAnalysisPredicates = createMemoizedSelector((ref) => create
 /**
  * @internal
  */
-export const selectConfiguredAndImplicitDrillsByWidgetRef = createMemoizedSelector((ref) => createSelector(selectCatalogIsLoaded, selectAccessibleDashboardsLoaded, selectValidConfiguredDrillsByWidgetRef(ref), selectImplicitDrillsDownByWidgetRef(ref), selectImplicitDrillsToUrlByWidgetRef(ref), selectCrossFilteringByWidgetRef(ref), selectKdaByWidgetRef(ref), selectInsightByWidgetRef(ref), selectEnableDrillToUrlByDefault, selectEnableImplicitDrillToUrl, (catalogIsLoaded, accessibleDashboardsLoaded, configuredDrills, implicitDrillDownDrills, implicitDrillToUrlDrills, crossFiltering, keyDriverAnalysis, insight, enableDrillToUrlByDefault, enableImplicitDrillToUrl) => {
+export const selectConfiguredAndImplicitDrillsByWidgetRef = createMemoizedSelector((ref) => createSelector(selectCatalogIsLoaded, selectAccessibleDashboardsLoaded, selectValidConfiguredDrillsByWidgetRef(ref), selectImplicitDrillsDownByWidgetRef(ref), selectImplicitDrillsToUrlByWidgetRef(ref), selectCrossFilteringByWidgetRef(ref), selectKdaByWidgetRef(ref), selectInsightByWidgetRef(ref), selectEnableDrillToUrlByDefault, (catalogIsLoaded, accessibleDashboardsLoaded, configuredDrills, implicitDrillDownDrills, implicitDrillToUrlDrills, crossFiltering, keyDriverAnalysis, insight, enableDrillToUrlByDefault) => {
     const disableDrillIntoURL = insight?.insight.properties["controls"]?.disableDrillIntoURL ?? !enableDrillToUrlByDefault;
-    const isDrillToUrlDisabled = !enableImplicitDrillToUrl || disableDrillIntoURL;
+    const isDrillToUrlDisabled = disableDrillIntoURL;
     // disable drilling until all necessary items are loaded (catalog, dash list, ...)
     const drillActive = catalogIsLoaded && accessibleDashboardsLoaded;
     return drillActive
@@ -464,16 +458,14 @@ export const selectDrillableItemsByWidgetRef = createMemoizedSelector((ref) => c
 /**
  * @internal
  */
-export const selectImplicitDrillsByAvailableDrillTargets = createMemoizedSelector((availableDrillTargets, ignoredDrillDownHierarchies = [], disableDrillIntoURL) => createSelector(selectAttributesWithDisplayFormLink, selectAttributesWithHierarchyDescendants, selectAllCatalogAttributesMap, selectSupportsAttributeHierarchies, selectAllCatalogAttributeHierarchies, selectBackendCapabilities, selectEnableDrillToUrlByDefault, selectEnableImplicitDrillToUrl, (attributesWithLink, attributesWithHierarchyDescendants, allCatalogAttributesMap, isDrillDownEnabled, allCatalogHierarchies, backendCapabilities, enableDrillToUrlByDefault, enableImplicitDrillToUrl) => {
+export const selectImplicitDrillsByAvailableDrillTargets = createMemoizedSelector((availableDrillTargets, ignoredDrillDownHierarchies = [], disableDrillIntoURL) => createSelector(selectAttributesWithDisplayFormLink, selectAttributesWithHierarchyDescendants, selectAllCatalogAttributesMap, selectSupportsAttributeHierarchies, selectAllCatalogAttributeHierarchies, selectBackendCapabilities, selectEnableDrillToUrlByDefault, (attributesWithLink, attributesWithHierarchyDescendants, allCatalogAttributesMap, isDrillDownEnabled, allCatalogHierarchies, backendCapabilities, enableDrillToUrlByDefault) => {
     const isDrillToUrlDisabled = disableDrillIntoURL ?? !enableDrillToUrlByDefault;
     const availableDrillAttributes = availableDrillTargets?.attributes ?? [];
     const drillDownDrills = isDrillDownEnabled
         ? getDrillDownDefinitionsWithPredicates(availableDrillAttributes, attributesWithHierarchyDescendants, allCatalogAttributesMap, allCatalogHierarchies, ignoredDrillDownHierarchies, backendCapabilities.supportsAttributeHierarchies)
         : [];
-    const drillToUrlDrills = getDrillToUrlDefinitionsWithPredicates(availableDrillAttributes, attributesWithLink, [], enableImplicitDrillToUrl);
-    return !enableImplicitDrillToUrl || isDrillToUrlDisabled
-        ? drillDownDrills
-        : [...drillDownDrills, ...drillToUrlDrills];
+    const drillToUrlDrills = getDrillToUrlDefinitionsWithPredicates(availableDrillAttributes, attributesWithLink, []);
+    return isDrillToUrlDisabled ? drillDownDrills : [...drillDownDrills, ...drillToUrlDrills];
 }));
 /**
  * @internal