@gooddata/sdk-ui-dashboard 11.43.0-alpha.0 → 11.43.0-alpha.1

package/esm/presentation/automations/shared/hooks/useFiltersNamings.js

@@ -0,0 +1,196 @@
+// (C) 2024-2026 GoodData Corporation
+import { useIntl } from "react-intl";
+import { areObjRefsEqual, dashboardAttributeFilterItemLocalIdentifier, dashboardAttributeFilterItemTitle, getAttributeElementsItems, isAllTimeDashboardDateFilter, isAllValuesDashboardAttributeFilter, isDashboardArbitraryAttributeFilter, isDashboardAttributeFilter, isDashboardCommonDateFilter, isDashboardDateFilter, isDashboardDateFilterWithDimension, isDashboardMatchAttributeFilter, isDashboardMeasureValueFilter, objRefToString, serializeObjRef, } from "@gooddata/sdk-model";
+import { DateFilterHelpers, getAttributeFilterSubtitle, getLocalizedIcuDateFormatPattern, getMeasureValueFilterConditionLabel, getTextFilterStateText, } from "@gooddata/sdk-ui-filters";
+import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
+import { convertDateFilterConfigToDateFilterOptions } from "../dateFilterConfig/dateFilterConfigConverters.js";
+import { matchDateFilterToDateFilterOptionWithPreference } from "../dateFilterConfig/dateFilterOptionMapping.js";
+import { defaultDateFilterConfig } from "../dateFilterConfig/defaultConfig.js";
+import { ensureAllTimeFilterForExport } from "../exportUtils/filterUtils.js";
+import { useAttributeFilterDisplayFormFromMap } from "./useAttributeFilterDisplayFormFromMap.js";
+import { useCommonDateFilterTitle } from "./useCommonDateFilterTitle.js";
+import { useDateFiltersTitles } from "./useDateFiltersTitles.js";
+const PERCENT_FORMAT_REGEX = /%/;
+function isPercentageFormat(format) {
+    return !!format && PERCENT_FORMAT_REGEX.test(format);
+}
+/**
+ * Hook that gathers all dependencies needed for filter naming transformations.
+ * Reusable across different hooks that need to transform filters to namings.
+ *
+ * @param filtersForTitles - Array of filters (date filters will be extracted for titles)
+ * @returns Object containing all dependencies needed for filter naming transformations
+ */
+function useFilterNamingDependencies(filtersForTitles) {
+    const intl = useIntl();
+    const { locale, settings, catalogMeasures: measures, separators, getCatalogAttributeByRef, } = useAutomationsContext();
+    const dateFormat = settings?.formatLocale
+        ? getLocalizedIcuDateFormatPattern(settings.formatLocale)
+        : settings?.responsiveUiDateFormat;
+    const getAttributeFilterDisplayFormFromMap = useAttributeFilterDisplayFormFromMap();
+    const dateFiltersForTitles = filtersForTitles.filter(isDashboardDateFilterWithDimension);
+    const commonDateFilterTitle = useCommonDateFilterTitle(intl);
+    const allDateFiltersTitlesObj = useDateFiltersTitles(dateFiltersForTitles, intl);
+    return {
+        intl,
+        locale,
+        dateFormat,
+        getAttributeFilterDisplayFormFromMap,
+        getCatalogAttributeByRef,
+        measures,
+        separators,
+        commonDateFilterTitle,
+        allDateFiltersTitlesObj,
+    };
+}
+/**
+ * Pure function that transforms filters into filter namings.
+ * Extracted to avoid code duplication between useFiltersNamings and useFiltersByTabNamings.
+ */
+function transformFiltersToNamings(filtersToDisplay, deps) {
+    const { intl, dateFormat, getAttributeFilterDisplayFormFromMap, getCatalogAttributeByRef, measures, separators, commonDateFilterTitle, allDateFiltersTitlesObj, } = deps;
+    // we want to show all time filter in the list of filters even if it is not stored
+    const extendedFiltersToDisplay = ensureAllTimeFilterForExport(filtersToDisplay);
+    return extendedFiltersToDisplay.map((filter) => {
+        if (isDashboardAttributeFilter(filter)) {
+            const displayForm = getAttributeFilterDisplayFormFromMap(filter.attributeFilter.displayForm);
+            if (!displayForm) {
+                return undefined;
+            }
+            const attribute = getCatalogAttributeByRef(displayForm.attribute);
+            if (!attribute) {
+                return undefined;
+            }
+            const valuesAsAttributeElements = getAttributeElementsItems(filter.attributeFilter.attributeElements)?.map((element) => ({
+                title: element,
+                uri: element,
+            }));
+            const subtitle = getAttributeFilterSubtitle(filter.attributeFilter.negativeSelection, valuesAsAttributeElements, intl);
+            return {
+                type: "attributeFilter",
+                all: isAllValuesDashboardAttributeFilter(filter),
+                id: filter.attributeFilter.localIdentifier,
+                title: filter.attributeFilter.title ?? attribute.attribute.title,
+                subtitle,
+            };
+        }
+        else if (isDashboardDateFilter(filter)) {
+            /**
+             * Shenanigans inspired by core date filter and dashboard date filter implementation
+             * to get the date filter option for its subtitle.
+             */
+            const dateFilterOptionInfo = matchDateFilterToDateFilterOptionWithPreference(filter, convertDateFilterConfigToDateFilterOptions(defaultDateFilterConfig), undefined);
+            const dateFilterOption = DateFilterHelpers.applyExcludeCurrentPeriod(dateFilterOptionInfo.dateFilterOption, dateFilterOptionInfo.excludeCurrentPeriod);
+            const subtitle = DateFilterHelpers.getDateFilterTitleUsingTranslator(dateFilterOption, intl, "full", dateFormat);
+            const a = filter;
+            if (isDashboardDateFilterWithDimension(a)) {
+                const key = serializeObjRef(a.dateFilter.dataSet);
+                return {
+                    type: "dateFilter",
+                    all: isAllTimeDashboardDateFilter(a),
+                    id: a.dateFilter.localIdentifier ?? `dateFilter:${key}`,
+                    title: allDateFiltersTitlesObj[key],
+                    subtitle,
+                    dataSet: a.dateFilter.dataSet,
+                };
+            }
+            const b = filter;
+            if (isDashboardCommonDateFilter(b)) {
+                return {
+                    type: "dateFilter",
+                    common: true,
+                    all: isAllTimeDashboardDateFilter(b),
+                    id: b.dateFilter.localIdentifier ?? "dateFilter:common",
+                    title: commonDateFilterTitle || intl.formatMessage({ id: "dateFilterDropdown.title" }),
+                    subtitle,
+                };
+            }
+            return undefined;
+        }
+        else if (isDashboardArbitraryAttributeFilter(filter)) {
+            const { values, negativeSelection, displayForm } = filter.arbitraryAttributeFilter;
+            const filterDisplayForm = getAttributeFilterDisplayFormFromMap(displayForm);
+            if (!filterDisplayForm) {
+                return undefined;
+            }
+            const attribute = getCatalogAttributeByRef(filterDisplayForm.attribute);
+            if (!attribute) {
+                return undefined;
+            }
+            const operator = values.length === 0 && negativeSelection ? "all" : negativeSelection ? "isNot" : "is";
+            const subtitle = getTextFilterStateText(operator, values, "", intl);
+            const title = dashboardAttributeFilterItemTitle(filter) ?? attribute.attribute.title;
+            return {
+                type: "attributeFilter",
+                all: values.length === 0 && negativeSelection,
+                id: dashboardAttributeFilterItemLocalIdentifier(filter),
+                title,
+                subtitle,
+            };
+        }
+        else if (isDashboardMeasureValueFilter(filter)) {
+            const { measure, localIdentifier, title: customTitle, conditions, } = filter.dashboardMeasureValueFilter;
+            const catalogMetric = measures.find((m) => areObjRefsEqual(m.measure.ref, measure));
+            const defaultTitle = catalogMetric?.measure.title ?? objRefToString(measure);
+            const title = customTitle ?? defaultTitle;
+            const format = catalogMetric?.measure.format;
+            const usePercentage = isPercentageFormat(format);
+            const subtitle = getMeasureValueFilterConditionLabel(intl, conditions, {
+                usePercentage,
+                separators,
+            });
+            return {
+                type: "measureValueFilter",
+                all: !conditions || conditions.length === 0,
+                id: localIdentifier,
+                title,
+                subtitle,
+            };
+        }
+        else if (isDashboardMatchAttributeFilter(filter)) {
+            const { operator: matchOperator, literal, negativeSelection, displayForm, } = filter.matchAttributeFilter;
+            const filterDisplayForm = getAttributeFilterDisplayFormFromMap(displayForm);
+            if (!filterDisplayForm) {
+                return undefined;
+            }
+            const attribute = getCatalogAttributeByRef(filterDisplayForm.attribute);
+            if (!attribute) {
+                return undefined;
+            }
+            const isNegative = negativeSelection ?? false;
+            const operatorMap = {
+                contains: isNegative ? "doesNotContain" : "contains",
+                startsWith: isNegative ? "doesNotStartWith" : "startsWith",
+                endsWith: isNegative ? "doesNotEndWith" : "endsWith",
+            };
+            const operator = operatorMap[matchOperator] ?? "contains";
+            const subtitle = getTextFilterStateText(operator, [], literal, intl);
+            const title = dashboardAttributeFilterItemTitle(filter) ?? attribute.attribute.title;
+            return {
+                type: "attributeFilter",
+                all: false,
+                id: dashboardAttributeFilterItemLocalIdentifier(filter),
+                title,
+                subtitle,
+            };
+        }
+        else {
+            return undefined;
+        }
+    });
+}
+export function useFiltersNamings(filtersToDisplay) {
+    const deps = useFilterNamingDependencies(filtersToDisplay);
+    return transformFiltersToNamings(filtersToDisplay, deps);
+}
+export function useFiltersByTabNamings(tabFilters) {
+    // Collect all filters from all tabs for titles lookup
+    const allFilters = Object.values(tabFilters).flat();
+    const deps = useFilterNamingDependencies(allFilters);
+    // Process each tab's filters separately using the shared transformation function
+    const result = {};
+    Object.entries(tabFilters).forEach(([tabId, filters]) => {
+        result[tabId] = transformFiltersToNamings(filters, deps);
+    });
+    return result;
+}

package/esm/presentation/automations/shared/utils/automationUtils.d.ts

@@ -0,0 +1,24 @@
+import { type FilterContextItem, type IAutomationMetadataObject, type IAutomationMetadataObjectDefinition, type IAutomationRecipient, type IExportDefinitionMetadataObject, type IExportDefinitionMetadataObjectDefinition, type IFilter, type IUser, type IWorkspaceUser } from "@gooddata/sdk-model";
+export declare const isDashboardAutomation: (automation: IAutomationMetadataObject | IAutomationMetadataObjectDefinition | undefined) => boolean;
+export declare const isVisualisationAutomation: (automation: IAutomationMetadataObject | IAutomationMetadataObjectDefinition | undefined) => boolean;
+export declare const isCsvVisualizationAutomation: (automation: IAutomationMetadataObject | IAutomationMetadataObjectDefinition | undefined) => boolean;
+export declare const isCsvVisualizationExportDefinition: (exportDefinition: IExportDefinitionMetadataObject | IExportDefinitionMetadataObjectDefinition | undefined) => boolean;
+export declare const isXlsxVisualizationAutomation: (automation: IAutomationMetadataObject | IAutomationMetadataObjectDefinition | undefined) => boolean;
+export declare const isXlsxVisualizationExportDefinition: (exportDefinition: IExportDefinitionMetadataObject | IExportDefinitionMetadataObjectDefinition | undefined) => boolean;
+export declare const getAutomationDashboardFilters: (automation: IAutomationMetadataObject | IAutomationMetadataObjectDefinition | undefined) => FilterContextItem[] | undefined;
+/**
+ * Extracts dashboard filters structured by tab from automation metadata object.
+ * Returns filtersByTab from the first dashboard export definition.
+ */
+export declare const getAutomationDashboardFiltersByTab: (automation: IAutomationMetadataObject | IAutomationMetadataObjectDefinition | undefined) => Record<string, FilterContextItem[]> | undefined;
+export declare const getAutomationVisualizationFilters: (automation: IAutomationMetadataObject | IAutomationMetadataObjectDefinition | undefined) => {
+    executionFilters: IFilter[] | undefined;
+    filterContextItems: FilterContextItem[] | undefined;
+};
+export declare const getAutomationAlertFilters: (automation: IAutomationMetadataObject | IAutomationMetadataObjectDefinition | undefined) => IFilter[] | undefined;
+export declare const areAutomationsEqual: (originalAutomation: IAutomationMetadataObjectDefinition, updatedAutomation: IAutomationMetadataObjectDefinition) => boolean;
+export declare const convertCurrentUserToAutomationRecipient: (users: IWorkspaceUser[], user: IUser) => IAutomationRecipient;
+export declare const convertCurrentUserToWorkspaceUser: (users: IWorkspaceUser[], user: IUser) => IWorkspaceUser;
+export declare const convertUserToAutomationRecipient: (user: IUser) => IAutomationRecipient;
+export declare const convertExternalRecipientToAutomationRecipient: (externalRecipient: string) => IAutomationRecipient;
+//# sourceMappingURL=automationUtils.d.ts.map

package/esm/presentation/automations/shared/utils/automationUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automationUtils.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/shared/utils/automationUtils.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAC9B,KAAK,mCAAmC,EACxC,KAAK,oBAAoB,EAEzB,KAAK,+BAA+B,EACpC,KAAK,yCAAyC,EAE9C,KAAK,OAAO,EACZ,KAAK,KAAK,EACV,KAAK,cAAc,EAKtB,MAAM,qBAAqB,CAAC;AAE7B,eAAO,MAAM,qBAAqB,sGAYjC,CAAC;AAEF,eAAO,MAAM,yBAAyB,sGAYrC,CAAC;AAEF,eAAO,MAAM,4BAA4B,sGAQxC,CAAC;AAEF,eAAO,MAAM,kCAAkC,wHAW9C,CAAC;AAEF,eAAO,MAAM,6BAA6B,sGAQzC,CAAC;AAEF,eAAO,MAAM,mCAAmC,wHAW/C,CAAC;AAEF,eAAO,MAAM,6BAA6B,8HAYzC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kCAAkC,8IAY9C,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;CAuB7C,CAAC;AAEF,eAAO,MAAM,yBAAyB,oHAQrC,CAAC;AAOF,eAAO,MAAM,mBAAmB,8HAqB/B,CAAC;AAEF,eAAO,MAAM,uCAAuC,gEAOnD,CAAC;AAEF,eAAO,MAAM,iCAAiC,0DAe7C,CAAC;AAEF,eAAO,MAAM,gCAAgC,uCAO5C,CAAC;AAEF,eAAO,MAAM,6CAA6C,qDASzD,CAAC"}

package/esm/presentation/automations/shared/utils/automationUtils.js

@@ -0,0 +1,135 @@
+// (C) 2024-2026 GoodData Corporation
+import { isEqual, omit, pick } from "lodash-es";
+import { isExportDefinitionDashboardRequestPayload, isExportDefinitionVisualizationObjectRequestPayload, isFilter, isFilterContextItem, } from "@gooddata/sdk-model";
+export const isDashboardAutomation = (automation) => {
+    if (!automation) {
+        return false;
+    }
+    return (automation.exportDefinitions?.some((exportDefinition) => {
+        return isExportDefinitionDashboardRequestPayload(exportDefinition.requestPayload);
+    }) ?? false);
+};
+export const isVisualisationAutomation = (automation) => {
+    if (!automation) {
+        return false;
+    }
+    return (automation.exportDefinitions?.some((exportDefinition) => {
+        return isExportDefinitionVisualizationObjectRequestPayload(exportDefinition.requestPayload);
+    }) ?? false);
+};
+export const isCsvVisualizationAutomation = (automation) => {
+    if (!automation) {
+        return false;
+    }
+    return automation.exportDefinitions?.some(isCsvVisualizationExportDefinition) ?? false;
+};
+export const isCsvVisualizationExportDefinition = (exportDefinition) => {
+    if (!exportDefinition) {
+        return false;
+    }
+    return (isExportDefinitionVisualizationObjectRequestPayload(exportDefinition.requestPayload) &&
+        exportDefinition.requestPayload.format === "CSV");
+};
+export const isXlsxVisualizationAutomation = (automation) => {
+    if (!automation) {
+        return false;
+    }
+    return automation.exportDefinitions?.some(isXlsxVisualizationExportDefinition) ?? false;
+};
+export const isXlsxVisualizationExportDefinition = (exportDefinition) => {
+    if (!exportDefinition) {
+        return false;
+    }
+    return (isExportDefinitionVisualizationObjectRequestPayload(exportDefinition.requestPayload) &&
+        exportDefinition.requestPayload.format === "XLSX");
+};
+export const getAutomationDashboardFilters = (automation) => {
+    if (!automation) {
+        return undefined;
+    }
+    return automation.exportDefinitions?.find((exportDefinition) => {
+        return isExportDefinitionDashboardRequestPayload(exportDefinition.requestPayload);
+    })?.requestPayload?.content.filters?.filter((f) => isFilterContextItem(f));
+};
+/**
+ * Extracts dashboard filters structured by tab from automation metadata object.
+ * Returns filtersByTab from the first dashboard export definition.
+ */
+export const getAutomationDashboardFiltersByTab = (automation) => {
+    if (!automation) {
+        return undefined;
+    }
+    return automation.exportDefinitions?.find((exportDefinition) => {
+        return isExportDefinitionDashboardRequestPayload(exportDefinition.requestPayload);
+    })?.requestPayload?.content.filtersByTab;
+};
+export const getAutomationVisualizationFilters = (automation) => {
+    if (!automation) {
+        return { executionFilters: undefined, filterContextItems: undefined };
+    }
+    const executionFilters = automation.exportDefinitions?.find((exportDefinition) => {
+        return isExportDefinitionVisualizationObjectRequestPayload(exportDefinition.requestPayload);
+    })?.requestPayload?.content.filters?.filter((f) => isFilter(f));
+    const filterContextItems = automation.exportDefinitions?.find((exportDefinition) => {
+        return isExportDefinitionVisualizationObjectRequestPayload(exportDefinition.requestPayload);
+    })?.requestPayload?.content.filters?.filter((f) => isFilterContextItem(f));
+    return {
+        executionFilters: (executionFilters ?? []).length > 0 ? executionFilters : undefined,
+        filterContextItems: (filterContextItems ?? []).length > 0 ? filterContextItems : undefined,
+    };
+};
+export const getAutomationAlertFilters = (automation) => {
+    if (!automation) {
+        return undefined;
+    }
+    return automation.alert?.execution?.filters?.filter(isFilter);
+};
+const sortByFormat = (a, b) => a.requestPayload.format.localeCompare(b.requestPayload.format);
+export const areAutomationsEqual = (originalAutomation, updatedAutomation) => {
+    const automationWithoutExportDefinitions = omit(updatedAutomation, "exportDefinitions");
+    const origAutomationWithoutExportDefinitions = omit(originalAutomation, "exportDefinitions");
+    // We only want to compare requestPayload and title of exportDefinitions, rest may be omitted as it is just arbitrary
+    // metadata that is not relevant for the comparison and causes false positive results when comparing new and old def.
+    // Sorting is done just to avoid false positive result of different order of export definitions.
+    const automationExportDefinitions = updatedAutomation.exportDefinitions
+        ?.map((exportDefinition) => pick(exportDefinition, ["requestPayload", "title"]))
+        .sort(sortByFormat);
+    const origAutomationExportDefinitions = originalAutomation.exportDefinitions
+        ?.map((exportDefinition) => pick(exportDefinition, ["requestPayload", "title"]))
+        .sort(sortByFormat);
+    return (isEqual(automationWithoutExportDefinitions, origAutomationWithoutExportDefinitions) &&
+        isEqual(automationExportDefinitions, origAutomationExportDefinitions));
+};
+export const convertCurrentUserToAutomationRecipient = (users, user) => {
+    const foundUser = users.find((u) => u.login === user.login);
+    return convertUserToAutomationRecipient(foundUser ?? user);
+};
+export const convertCurrentUserToWorkspaceUser = (users, user) => {
+    const foundUser = users.find((u) => u.login === user.login);
+    return (foundUser ?? {
+        email: user.email ?? "",
+        fullName: user.fullName,
+        status: "ENABLED",
+        login: user.login,
+        lastName: user.lastName,
+        firstName: user.firstName,
+        uri: user.login,
+        ref: user.ref,
+    });
+};
+export const convertUserToAutomationRecipient = (user) => {
+    return {
+        id: user.login,
+        email: user.email,
+        name: user.fullName,
+        type: "user",
+    };
+};
+export const convertExternalRecipientToAutomationRecipient = (externalRecipient) => {
+    return {
+        id: externalRecipient,
+        email: externalRecipient,
+        name: externalRecipient,
+        type: "externalUser",
+    };
+};

package/esm/presentation/automations/shared/utils/filterContextUtils.d.ts

@@ -0,0 +1,4 @@
+import { type FilterContextItem } from "@gooddata/sdk-model";
+import { type IDashboardFilter } from "../../../../types.js";
+export declare function dashboardFilterToFilterContextItem(filter: IDashboardFilter, keepDatasets: boolean): FilterContextItem | undefined;
+//# sourceMappingURL=filterContextUtils.d.ts.map

package/esm/presentation/automations/shared/utils/filterContextUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterContextUtils.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/shared/utils/filterContextUtils.ts"],"names":[],"mappings":"AAKA,OAAO,EAEH,KAAK,iBAAiB,EAmBzB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,wBAAgB,kCAAkC,CAC9C,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,OAAO,GACtB,iBAAiB,GAAG,SAAS,CA8E/B"}

package/esm/presentation/automations/shared/utils/filterContextUtils.js

@@ -0,0 +1,67 @@
+// (C) 2021-2026 GoodData Corporation
+// Derived from _staging/dashboard/dashboardFilterContext.ts
+import { NotSupported } from "@gooddata/sdk-backend-spi";
+import { filterAttributeElements, filterLocalIdentifier, filterObjRef, isAbsoluteDateFilter, isAllTimeDateFilter, isArbitraryAttributeFilter, isAttributeFilterWithSelection, isMatchAttributeFilter, isMeasureValueFilter, isNegativeAttributeFilter, isObjRef, isRelativeBoundedDateFilter, isRelativeDateFilter, measureValueFilterConditions, measureValueFilterMeasure, newAbsoluteDashboardDateFilter, newAllTimeDashboardDateFilter, newRelativeDashboardDateFilter, } from "@gooddata/sdk-model";
+export function dashboardFilterToFilterContextItem(filter, keepDatasets) {
+    if (isAttributeFilterWithSelection(filter)) {
+        return {
+            attributeFilter: {
+                negativeSelection: isNegativeAttributeFilter(filter),
+                displayForm: filterObjRef(filter),
+                attributeElements: filterAttributeElements(filter),
+                selectionMode: "multi",
+                localIdentifier: filterLocalIdentifier(filter),
+            },
+        };
+    }
+    else if (isArbitraryAttributeFilter(filter)) {
+        return {
+            arbitraryAttributeFilter: {
+                displayForm: filterObjRef(filter),
+                values: filter.arbitraryAttributeFilter.values,
+                negativeSelection: filter.arbitraryAttributeFilter.negativeSelection ?? false,
+                localIdentifier: filterLocalIdentifier(filter),
+            },
+        };
+    }
+    else if (isMatchAttributeFilter(filter)) {
+        return {
+            matchAttributeFilter: {
+                displayForm: filterObjRef(filter),
+                operator: filter.matchAttributeFilter.operator,
+                literal: filter.matchAttributeFilter.literal,
+                caseSensitive: filter.matchAttributeFilter.caseSensitive,
+                negativeSelection: filter.matchAttributeFilter.negativeSelection,
+                localIdentifier: filterLocalIdentifier(filter),
+            },
+        };
+    }
+    else if (isAbsoluteDateFilter(filter)) {
+        return newAbsoluteDashboardDateFilter(filter.absoluteDateFilter.from, filter.absoluteDateFilter.to, keepDatasets ? filter.absoluteDateFilter.dataSet : undefined, filter.absoluteDateFilter.localIdentifier, filter.absoluteDateFilter.emptyValueHandling);
+    }
+    else if (isAllTimeDateFilter(filter)) {
+        return newAllTimeDashboardDateFilter(keepDatasets ? filter.relativeDateFilter.dataSet : undefined, filter.relativeDateFilter.localIdentifier, filter.relativeDateFilter.emptyValueHandling);
+    }
+    else if (isRelativeDateFilter(filter)) {
+        return newRelativeDashboardDateFilter(filter.relativeDateFilter.granularity, filter.relativeDateFilter.from, filter.relativeDateFilter.to, keepDatasets ? filter.relativeDateFilter.dataSet : undefined, filter.relativeDateFilter.localIdentifier, isRelativeBoundedDateFilter(filter) ? filter.relativeDateFilter.boundedFilter : undefined, filter.relativeDateFilter.emptyValueHandling);
+    }
+    else if (isMeasureValueFilter(filter)) {
+        const measure = measureValueFilterMeasure(filter);
+        // Dashboard MVFs always reference the measure by ObjRef. Insight MVFs use LocalIdRef
+        // (bucket localId) and have no honest representation in the dashboard filter context —
+        // they reach this converter only because automation execution filters mix dashboard and
+        // insight filters. Caller is responsible for dropping these undefined entries.
+        if (!isObjRef(measure)) {
+            return undefined;
+        }
+        const conditions = measureValueFilterConditions(filter);
+        return {
+            dashboardMeasureValueFilter: {
+                measure,
+                localIdentifier: filter.measureValueFilter.localIdentifier ?? `mvf:${JSON.stringify(measure)}`,
+                ...(conditions ? { conditions } : {}),
+            },
+        };
+    }
+    throw new NotSupported(`Unsupported filter type! Please provide valid dashboard filter. Filter: ${JSON.stringify(filter)}`);
+}

package/esm/presentation/filterBar/attributeFilter/dashboardDropdownBody/configuration/hooks/useDependentDateFilterConfigurationState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDependentDateFilterConfigurationState.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/filterBar/attributeFilter/dashboardDropdownBody/configuration/hooks/useDependentDateFilterConfigurationState.ts"],"names":[],"mappings":"AAMA,OAAO,EACH,KAAK,+BAA+B,EACpC,KAAK,oBAAoB,EAE5B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,6BAA6B,EAAE,MAAM,kDAAkD,CAAC;AAEtG;;GAEG;AACH,wBAAgB,wCAAwC,CACpD,eAAe,EAAE,oBAAoB,EAAE,EACvC,gBAAgB,CAAC,EAAE,oBAAoB,EACvC,oBAAoB,CAAC,EAAE,+BAA+B,EAAE,mCAoD3D;AAED,wBAAgB,8CAA8C,CAC1D,gBAAgB,CAAC,EAAE,oBAAoB,GACxC,oBAAoB,CAWtB"}
+{"version":3,"file":"useDependentDateFilterConfigurationState.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/filterBar/attributeFilter/dashboardDropdownBody/configuration/hooks/useDependentDateFilterConfigurationState.ts"],"names":[],"mappings":"AAMA,OAAO,EACH,KAAK,+BAA+B,EACpC,KAAK,oBAAoB,EAG5B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,6BAA6B,EAAE,MAAM,kDAAkD,CAAC;AAEtG;;GAEG;AACH,wBAAgB,wCAAwC,CACpD,eAAe,EAAE,oBAAoB,EAAE,EACvC,gBAAgB,CAAC,EAAE,oBAAoB,EACvC,oBAAoB,CAAC,EAAE,+BAA+B,EAAE,mCAyE3D;AAED,wBAAgB,8CAA8C,CAC1D,gBAAgB,CAAC,EAAE,oBAAoB,GACxC,oBAAoB,CAWtB"}

package/esm/presentation/filterBar/attributeFilter/dashboardDropdownBody/configuration/hooks/useDependentDateFilterConfigurationState.js

@@ -8,12 +8,22 @@ import { isUriRef, } from "@gooddata/sdk-model";
 export function useDependentDateFilterConfigurationState(neighborFilters, commonDateFilter, filterElementsByDate) {
     const neighborDateFiltersWithDimensions = useMemo(() => {
         return neighborFilters.map((neighborFilter) => {
-            const neighborLocalId = neighborFilter.dateFilter.dataSet;
-            invariant(!isUriRef(neighborLocalId));
-            const isSelected = filterElementsByDate?.some((by) => by.filterLocalIdentifier === neighborLocalId?.identifier && !by.isCommonDate) || false;
-            invariant(neighborLocalId?.identifier, "Cannot initialize the attribute filter configuration panel, neighbor date filter has missing 'localIdentifier' property.");
+            const neighborDataSet = neighborFilter.dateFilter.dataSet;
+            invariant(!isUriRef(neighborDataSet));
+            // Prefer the filter's own localIdentifier over the dataset identifier so that multiple date
+            // filters backed by the same dataset can be told apart. Falls back to the dataset identifier
+            // for date filters that don't carry a localIdentifier (e.g. older backend records).
+            const filterLocalIdentifier = neighborFilter.dateFilter.localIdentifier ?? neighborDataSet?.identifier;
+            const isSelected = filterElementsByDate?.some((by) => 
+            // Match against both the new (localIdentifier) and legacy (dataset identifier)
+            // formats: dashboards saved before this change store the dataset identifier in
+            // filterLocalIdentifier, so we must accept either form to stay backwards compatible.
+            (by.filterLocalIdentifier === filterLocalIdentifier ||
+                by.filterLocalIdentifier === neighborDataSet?.identifier) &&
+                !by.isCommonDate) || false;
+            invariant(filterLocalIdentifier, "Cannot initialize the attribute filter configuration panel, neighbor date filter has missing 'localIdentifier' property.");
             return {
-                localIdentifier: neighborLocalId.identifier,
+                localIdentifier: filterLocalIdentifier,
                 isSelected,
                 dataSet: neighborFilter.dateFilter.dataSet,
                 from: neighborFilter.dateFilter.from,
@@ -28,19 +38,27 @@ export function useDependentDateFilterConfigurationState(neighborFilters, common
         const commonDate = parseCommonDateFilter(commonDateFilter);
         return (filterElementsByDate ?? [])
             .filter((parent) => parent.isCommonDate)
-            .map((parent) => ({
-            localIdentifier: parent.filterLocalIdentifier,
-            isSelected: true,
-            dataSet: {
+            .map((parent) => {
+            // Resolve the target dimension. New format: the explicit `dataSet` field carries it
+            // (filterLocalIdentifier references the common date filter itself). Legacy format: no
+            // `dataSet`, so the dimension identifier was stored directly in filterLocalIdentifier.
+            // The config item is keyed by the dimension so it matches the per-dimension picker items.
+            const dimension = parent.dataSet ?? {
                 identifier: parent.filterLocalIdentifier,
                 type: "dataSet",
-            },
-            from: commonDate.from,
-            to: commonDate.to,
-            granularity: commonDate.granularity,
-            type: commonDate.type,
-            isCommonDate: true,
-        }));
+            };
+            invariant(!isUriRef(dimension));
+            return {
+                localIdentifier: dimension.identifier,
+                isSelected: true,
+                dataSet: dimension,
+                from: commonDate.from,
+                to: commonDate.to,
+                granularity: commonDate.granularity,
+                type: commonDate.type,
+                isCommonDate: true,
+            };
+        });
     }, [filterElementsByDate, commonDateFilter]);
     return [...neighborDateFiltersWithDimensions, ...commonDateFilters];
 }

package/esm/presentation/filterBar/attributeFilter/dashboardDropdownBody/configuration/hooks/useDependentDateFiltersConfiguration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDependentDateFiltersConfiguration.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/filterBar/attributeFilter/dashboardDropdownBody/configuration/hooks/useDependentDateFiltersConfiguration.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,yBAAyB,EAAE,KAAK,oBAAoB,EAAY,MAAM,qBAAqB,CAAC;AAI1G,OAAO,EAAE,KAAK,6BAA6B,EAAE,MAAM,kDAAkD,CAAC;AAOtG,wBAAgB,oCAAoC,CAChD,mBAAmB,EAAE,oBAAoB,EAAE,EAC3C,aAAa,EAAE,yBAAyB,EACxC,gBAAgB,CAAC,EAAE,oBAAoB;;;;;;;EAmG1C"}
+{"version":3,"file":"useDependentDateFiltersConfiguration.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/filterBar/attributeFilter/dashboardDropdownBody/configuration/hooks/useDependentDateFiltersConfiguration.ts"],"names":[],"mappings":"AAQA,OAAO,EACH,KAAK,yBAAyB,EAE9B,KAAK,oBAAoB,EAE5B,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EAAE,KAAK,6BAA6B,EAAE,MAAM,kDAAkD,CAAC;AAOtG,wBAAgB,oCAAoC,CAChD,mBAAmB,EAAE,oBAAoB,EAAE,EAC3C,aAAa,EAAE,yBAAyB,EACxC,gBAAgB,CAAC,EAAE,oBAAoB;;;;;;;EAqH1C"}

package/esm/presentation/filterBar/attributeFilter/dashboardDropdownBody/configuration/hooks/useDependentDateFiltersConfiguration.js

@@ -2,7 +2,8 @@
 import { useCallback, useMemo, useState } from "react";
 import { isEqual } from "lodash-es";
 import { invariant } from "ts-invariant";
-import { isUriRef } from "@gooddata/sdk-model";
+import { generateDateFilterLocalIdentifier } from "@gooddata/sdk-backend-base";
+import { isUriRef, } from "@gooddata/sdk-model";
 import { setAttributeFilterDependentDateFilters } from "../../../../../../model/commands/filters.js";
 import { useDispatchDashboardCommand } from "../../../../../../model/react/useDispatchDashboardCommand.js";
 import { useDependentCommonDateFilterConfigurationState, useDependentDateFilterConfigurationState, } from "./useDependentDateFilterConfigurationState.js";
@@ -15,9 +16,11 @@ export function useDependentDateFiltersConfiguration(neighborDateFilters, curren
     const [dependentDateFilters, setDependentDateFilters] = useState(originalState);
     const [dependentCommonDateFilter, setDependentCommonDateFilter] = useState(originalCommonDateFilterState);
     const onDependentDateFiltersSelect = (item, isSelected, isCommonDate) => {
-        const localIdentifier = item.dataSet;
-        invariant(!isUriRef(localIdentifier));
-        const changedParentIndex = dependentDateFilters.findIndex((dependentDateFilter) => dependentDateFilter.localIdentifier === localIdentifier?.identifier &&
+        invariant(!isUriRef(item.dataSet));
+        // Match on item.localIdentifier rather than item.dataSet?.identifier (the dataset identifier):
+        // state entries now store dateFilter.localIdentifier as their key, which matches item.localIdentifier
+        // since both come from the same useDependentDateFilterConfigurationState initializer.
+        const changedParentIndex = dependentDateFilters.findIndex((dependentDateFilter) => dependentDateFilter.localIdentifier === item.localIdentifier &&
             dependentDateFilter.isCommonDate === isCommonDate);
         if (changedParentIndex === -1) {
             setDependentDateFilters([...dependentDateFilters, item]);
@@ -44,18 +47,30 @@ export function useDependentDateFiltersConfiguration(neighborDateFilters, curren
     const onDependentDateFiltersChange = useCallback(() => {
         // dispatch the command only if the configuration changed
         if (onDependentDateFiltersConfigurationChanged) {
+            // Common date filter has no dimension of its own, so we reference it by its own
+            // localIdentifier (falling back to the canonical common-date id) and carry the chosen
+            // dimension in the separate `dataSet` field. Specific date filters are referenced by their
+            // localIdentifier and need no dataSet (it is derived from the referenced filter).
+            const commonDateLocalId = commonDateFilter?.dateFilter.localIdentifier ?? generateDateFilterLocalIdentifier(0);
             const dateFilters = dependentDateFilters
                 .filter((filter) => filter.isSelected)
-                .map((filter) => ({
-                filterLocalIdentifier: filter.localIdentifier,
-                isCommonDate: filter.isCommonDate,
-            }));
+                .map((filter) => filter.isCommonDate
+                ? {
+                    filterLocalIdentifier: commonDateLocalId,
+                    isCommonDate: true,
+                    dataSet: filter.dataSet,
+                }
+                : {
+                    filterLocalIdentifier: filter.localIdentifier,
+                    isCommonDate: false,
+                });
             saveDependentDateFilterCommand(currentFilter.attributeFilter.localIdentifier, dateFilters);
         }
     }, [
         dependentDateFilters,
         onDependentDateFiltersConfigurationChanged,
         currentFilter,
+        commonDateFilter,
         saveDependentDateFilterCommand,
     ]);
     return {

package/esm/presentation/filterBar/attributeFilter/useDependentDateFilters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDependentDateFilters.d.ts","sourceRoot":"","sources":["../../../../src/presentation/filterBar/attributeFilter/useDependentDateFilters.ts"],"names":[],"mappings":"AAMA,OAAO,EACH,KAAK,4BAA4B,EAKpC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAe1E;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,yBAAyB,EAAE,sBAAsB,CAAC,CAAC;AAE7F;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,8FAqEnC,CAAC"}
+{"version":3,"file":"useDependentDateFilters.d.ts","sourceRoot":"","sources":["../../../../src/presentation/filterBar/attributeFilter/useDependentDateFilters.ts"],"names":[],"mappings":"AAMA,OAAO,EACH,KAAK,4BAA4B,EAMpC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAe1E;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,yBAAyB,EAAE,sBAAsB,CAAC,CAAC;AAE7F;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,8FAiFnC,CAAC"}

package/esm/presentation/filterBar/attributeFilter/useDependentDateFilters.js

@@ -34,23 +34,34 @@ export const useDependentDateFilters = (filter, tabId) => {
     const dependentDateFilters = useMemo(() => {
         return filterElementsByDate?.map((dependentDateFilter) => {
             if (dependentDateFilter.isCommonDate) {
+                // The dimension to apply the common date range through.
+                // New format: the explicit `dataSet` field (filterLocalIdentifier references the common
+                // date filter itself). Legacy format: no `dataSet` field, so the dataset identifier was
+                // stored directly in filterLocalIdentifier.
+                const dataSet = dependentDateFilter.dataSet ?? {
+                    identifier: dependentDateFilter.filterLocalIdentifier,
+                    type: "dataSet",
+                };
                 const commonDashboardDateFilter = {
                     dateFilter: {
                         type: commonDateFilterWithAllTime?.dateFilter.type,
                         granularity: commonDateFilterWithAllTime?.dateFilter.granularity,
                         from: commonDateFilterWithAllTime?.dateFilter.from,
                         to: commonDateFilterWithAllTime?.dateFilter.to,
-                        dataSet: {
-                            identifier: dependentDateFilter.filterLocalIdentifier,
-                            type: "dataSet",
-                        },
+                        dataSet,
                     },
                 };
                 return commonDashboardDateFilter;
             }
             else {
-                const matchingFilter = allDateFilters.find((filter) => objRefToString(filter.dateFilter.dataSet) ===
-                    dependentDateFilter.filterLocalIdentifier);
+                // Try localIdentifier first (new format), then fall back to dataset identifier
+                // (legacy format) for dashboards saved before the localIdentifier-based approach.
+                // NOTE: If a filter's localIdentifier happens to equal another filter's dataset
+                // identifier the wrong filter could be matched — this is an accepted theoretical
+                // risk given the practical namespace separation between the two.
+                const matchingFilter = allDateFilters.find((filter) => filter.dateFilter.localIdentifier === dependentDateFilter.filterLocalIdentifier ||
+                    objRefToString(filter.dateFilter.dataSet) ===
+                        dependentDateFilter.filterLocalIdentifier);
                 invariant(matchingFilter); // if this blows up, the state is inconsistent
                 return matchingFilter;
             }

package/esm/presentation/topBar/menuButton/DefaultMenuButton.js

@@ -236,5 +236,5 @@ function MenuItem({ menuItem, selectedMenuItem, setMenuItemRef, setSelectedMenuI
     });
 }
 function renderMenuItemWarning(info, suppressHover) {
-    return (_jsx("span", { className: "gd-list-icon gd-list-icon-right", children: _jsx(UiTooltip, { triggerBy: ["hover"], disabled: suppressHover, arrowPlacement: "left", optimalPlacement: true, content: info, anchor: _jsx(UiIcon, { type: "warning", size: 16, color: "warning", accessibilityConfig: { ariaHidden: true } }) }) }));
+    return (_jsx("span", { className: "gd-list-icon gd-list-icon-right", "data-testid": "menu-item-info-icon", children: _jsx(UiTooltip, { triggerBy: ["hover"], disabled: suppressHover, arrowPlacement: "left", optimalPlacement: true, content: info, anchor: _jsx(UiIcon, { type: "warning", size: 16, color: "warning", accessibilityConfig: { ariaHidden: true } }) }) }));
 }