@gooddata/sdk-ui-dashboard 11.50.0-alpha.1 → 11.50.0-alpha.3

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/hooks/useScheduledEmailFilters.js

@@ -0,0 +1,195 @@
+// (C) 2026 GoodData Corporation
+import { useCallback } from "react";
+import { isExportDefinitionDashboardRequestPayload, isExportDefinitionVisualizationObjectRequestPayload, isInsightWidget, } from "@gooddata/sdk-model";
+import { useScheduledEmailDialogContext } from "../../../contexts/ScheduledEmailDialogContext.js";
+import { getDefaultSelectedFiltersFromFiltersByTab } from "../../../shared/automationFilters/useAutomationFiltersSelect.js";
+import { getAppliedDashboardFilters, getAppliedWidgetFilters, getVisibleFiltersByFilters, getVisibleFiltersByFiltersByTab, } from "../../../shared/automationFilters/utils.js";
+/**
+ * Owns the four scheduled-email filters handlers: they update the edited filters state and sync the
+ * result into the draft's export definitions and `metadata.visibleFilters`/`visibleFiltersByTab`.
+ *
+ * Filters slice B of 2. Runs after `useScheduledEmailFormState` because the handlers need
+ * `setEditedAutomation`; the derivation cluster in {@link useScheduledEmailEffectiveFilters} (slice A)
+ * has to run before it, which is why the two are separate hooks. Reads
+ * `hiddenFilters`/`commonDateFilterId` from {@link useScheduledEmailDialogContext} internally, same as
+ * slice A and as the parent (`useEditScheduledEmail`) did before.
+ *
+ * @internal
+ */
+export function useScheduledEmailFilters({ setEditedAutomation, widget, insight, setEditedAutomationFilters, setEditedAutomationFiltersByTab, availableFiltersAsVisibleFilters, availableFiltersAsVisibleFiltersByTab, filtersDataByTab, storeFilters, setStoreFilters, filtersForNewAutomation, }) {
+    const { hiddenFilters: dashboardHiddenFilters, commonDateFilterId } = useScheduledEmailDialogContext();
+    // Re-derived locally (not passed as a prop) so that the `if (isWidget)` branch below narrows
+    // `widget`/`insight` via TS's aliased-condition control-flow analysis — this requires the boolean
+    // to be declared from those exact variables in this same scope, same as in the parent.
+    const isWidget = !!widget && !!insight;
+    const onFiltersChange = useCallback((filters, storeFiltersParam) => {
+        setEditedAutomationFilters(filters);
+        const shouldStoreFilters = storeFiltersParam ?? storeFilters;
+        if (isWidget) {
+            if (!isInsightWidget(widget)) {
+                return;
+            }
+            setEditedAutomation((s) => {
+                const appliedDashboardFilters = getAppliedDashboardFilters(filters, dashboardHiddenFilters, true);
+                const appliedWidgetFiltersWithInsight = getAppliedWidgetFilters(filters, dashboardHiddenFilters, widget, insight, commonDateFilterId, true);
+                const appliedWidgetFiltersWithoutInsight = getAppliedWidgetFilters(filters, dashboardHiddenFilters, widget, insight, commonDateFilterId, false);
+                const visibleFilters = getVisibleFiltersByFilters(filters, availableFiltersAsVisibleFilters, true);
+                return {
+                    ...s,
+                    exportDefinitions: s.exportDefinitions?.map((exportDefinition) => {
+                        if (isExportDefinitionVisualizationObjectRequestPayload(exportDefinition.requestPayload)) {
+                            const format = exportDefinition.requestPayload.format;
+                            const shouldUseWidgetFiltersWithInsight = format === "CSV";
+                            const shouldUseWidgetFiltersWithoutInsight = format === "CSV_RAW";
+                            const appliedFilters = shouldUseWidgetFiltersWithInsight
+                                ? appliedWidgetFiltersWithInsight
+                                : shouldUseWidgetFiltersWithoutInsight
+                                    ? appliedWidgetFiltersWithoutInsight
+                                    : appliedDashboardFilters;
+                            return {
+                                ...exportDefinition,
+                                requestPayload: {
+                                    ...exportDefinition.requestPayload,
+                                    content: {
+                                        ...exportDefinition.requestPayload.content,
+                                        filters: appliedFilters,
+                                    },
+                                },
+                            };
+                        }
+                        else {
+                            return exportDefinition;
+                        }
+                    }),
+                    metadata: {
+                        ...s.metadata,
+                        visibleFilters,
+                    },
+                };
+            });
+        }
+        else {
+            setEditedAutomation((s) => {
+                const appliedFilters = getAppliedDashboardFilters(filters, dashboardHiddenFilters, shouldStoreFilters);
+                const visibleFilters = getVisibleFiltersByFilters(filters, availableFiltersAsVisibleFilters, shouldStoreFilters);
+                return {
+                    ...s,
+                    exportDefinitions: s.exportDefinitions?.map((exportDefinition) => {
+                        if (isExportDefinitionDashboardRequestPayload(exportDefinition.requestPayload)) {
+                            return {
+                                ...exportDefinition,
+                                requestPayload: {
+                                    ...exportDefinition.requestPayload,
+                                    content: {
+                                        ...exportDefinition.requestPayload.content,
+                                        filters: appliedFilters,
+                                    },
+                                },
+                            };
+                        }
+                        else {
+                            return exportDefinition;
+                        }
+                    }),
+                    metadata: {
+                        ...s.metadata,
+                        visibleFilters,
+                    },
+                };
+            });
+        }
+    }, [
+        setEditedAutomationFilters,
+        setEditedAutomation,
+        dashboardHiddenFilters,
+        availableFiltersAsVisibleFilters,
+        storeFilters,
+        widget,
+        insight,
+        isWidget,
+        commonDateFilterId,
+    ]);
+    // Callback for per-tab filter changes - updates state AND syncs to export definitions
+    const onFiltersByTabChange = useCallback((newFiltersByTab, storeFiltersParam) => {
+        // Update the editedFiltersByTab state
+        setEditedAutomationFiltersByTab?.(newFiltersByTab);
+        const shouldStoreFilters = storeFiltersParam ?? storeFilters;
+        const newEffectiveFiltersByTab = shouldStoreFilters
+            ? Object.entries(newFiltersByTab).reduce((acc, [tabId, filters]) => {
+                const tabHiddenFilters = filtersDataByTab?.find((tab) => tab.tabId === tabId)?.hiddenFilters ?? [];
+                const appliedFilters = getAppliedDashboardFilters(filters ?? [], tabHiddenFilters, true);
+                if (appliedFilters) {
+                    acc[tabId] = appliedFilters;
+                }
+                return acc;
+            }, {})
+            : undefined;
+        const newVisibleFiltersByTab = getVisibleFiltersByFiltersByTab(newFiltersByTab, availableFiltersAsVisibleFiltersByTab, shouldStoreFilters);
+        // Sync to export definitions AND metadata
+        setEditedAutomation((s) => ({
+            ...s,
+            exportDefinitions: s.exportDefinitions?.map((exportDefinition) => {
+                if (isExportDefinitionDashboardRequestPayload(exportDefinition.requestPayload)) {
+                    return {
+                        ...exportDefinition,
+                        requestPayload: {
+                            ...exportDefinition.requestPayload,
+                            content: {
+                                ...exportDefinition.requestPayload.content,
+                                filtersByTab: newEffectiveFiltersByTab,
+                            },
+                        },
+                    };
+                }
+                return exportDefinition;
+            }),
+            metadata: {
+                ...s.metadata,
+                visibleFiltersByTab: newVisibleFiltersByTab,
+            },
+        }));
+    }, [
+        setEditedAutomationFiltersByTab,
+        storeFilters,
+        setEditedAutomation,
+        availableFiltersAsVisibleFiltersByTab,
+        filtersDataByTab,
+    ]);
+    const onApplyCurrentFilters = useCallback(() => {
+        // Widget schedules should never use per-tab filters, only dashboard schedules can have tabs
+        const filtersByTabForNewAutomation = widget
+            ? undefined
+            : getDefaultSelectedFiltersFromFiltersByTab(filtersDataByTab);
+        if (filtersByTabForNewAutomation) {
+            onFiltersByTabChange(filtersByTabForNewAutomation);
+        }
+        else {
+            onFiltersChange(filtersForNewAutomation ?? [], widget ? true : storeFilters);
+        }
+    }, [
+        filtersForNewAutomation,
+        storeFilters,
+        onFiltersChange,
+        onFiltersByTabChange,
+        widget,
+        filtersDataByTab,
+    ]);
+    const onStoreFiltersChange = useCallback((value, filters, filtersByTabParam) => {
+        setStoreFilters(value);
+        // If filtersByTab is provided, use onFiltersByTabChange, otherwise use onFiltersChange
+        if (filtersByTabParam) {
+            // Trigger filtersByTab change which handles the sync
+            onFiltersByTabChange(filtersByTabParam, value);
+        }
+        if (filters) {
+            // Use regular filters change
+            onFiltersChange(filters, value);
+        }
+    }, [onFiltersChange, onFiltersByTabChange, setStoreFilters]);
+    return {
+        onFiltersChange,
+        onFiltersByTabChange,
+        onApplyCurrentFilters,
+        onStoreFiltersChange,
+    };
+}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/hooks/useScheduledEmailFormState.d.ts

@@ -0,0 +1,55 @@
+import { type FilterContextItem, type IAutomationMetadataObject, type IAutomationMetadataObjectDefinition, type IAutomationRecipient, type IAutomationVisibleFilter, type IDashboardExportParameter, type IExportDefinitionVisualizationObjectSettings, type IFilter, type IInsight, type INotificationChannelIdentifier, type INotificationChannelMetadataObject, type IWidget, type IWorkspaceUser } from "@gooddata/sdk-model";
+export interface IUseScheduledEmailFormStateProps {
+    scheduledExportToEdit?: IAutomationMetadataObject;
+    widget?: IWidget;
+    insight?: IInsight;
+    notificationChannels: INotificationChannelIdentifier[] | INotificationChannelMetadataObject[];
+    /** Workspace users, lazy-loaded in the connector and passed via dialog props. */
+    users: IWorkspaceUser[];
+    externalRecipientOverride?: string;
+    effectiveWidgetFilters: IFilter[];
+    effectiveWidgetFiltersWithInsight: IFilter[];
+    effectiveVisibleWidgetFilters: IAutomationVisibleFilter[] | undefined;
+    effectiveDashboardFilters: FilterContextItem[] | undefined;
+    effectiveDashboardFiltersByTab: Record<string, FilterContextItem[]> | undefined;
+    effectiveVisibleDashboardFilters: IAutomationVisibleFilter[] | undefined;
+    effectiveVisibleDashboardFiltersByTab: Record<string, IAutomationVisibleFilter[]> | undefined;
+    parametersByTabForNewAutomation: Record<string, IDashboardExportParameter[]> | undefined;
+    defaultPdfPageSize?: IExportDefinitionVisualizationObjectSettings["pageSize"];
+    targetTabId?: string;
+}
+/**
+ * Owns the scheduled-email dialog's `editedAutomation` draft (initialized either from
+ * `scheduledExportToEdit` or via `newAutomationMetadataObjectDefinition`), its `originalAutomation`
+ * baseline, the derived defaults (`defaultRecipient`, `defaultUser`), and the form's field/message
+ * change handlers and their validity UI state.
+ *
+ * `timezone` (already part 1) and `currentUser` are read from {@link useAutomationsContext};
+ * `dashboardId`/`dashboardTitle` from {@link useScheduledEmailDialogContext}. The effective-filters
+ * derivations, `parametersByTabForNewAutomation`, `defaultPdfPageSize`, and `targetTabId` stay owned
+ * by the parent (`useEditScheduledEmail`) — shared with other consumers — and are passed in as params.
+ *
+ * Part 2 of 2 (mirrors the alerting `useAlertFormState` part 2): completes the hook by folding in the
+ * draft init that part 1 left in the parent.
+ *
+ * @internal
+ */
+export declare function useScheduledEmailFormState({ scheduledExportToEdit, widget, insight, notificationChannels, users, externalRecipientOverride, effectiveWidgetFilters, effectiveWidgetFiltersWithInsight, effectiveVisibleWidgetFilters, effectiveDashboardFilters, effectiveDashboardFiltersByTab, effectiveVisibleDashboardFilters, effectiveVisibleDashboardFiltersByTab, parametersByTabForNewAutomation, defaultPdfPageSize, targetTabId }: IUseScheduledEmailFormStateProps): {
+    editedAutomation: IAutomationMetadataObjectDefinition;
+    setEditedAutomation: import("react").Dispatch<import("react").SetStateAction<IAutomationMetadataObjectDefinition>>;
+    originalAutomation: IAutomationMetadataObjectDefinition;
+    defaultRecipient: IAutomationRecipient;
+    defaultUser: IWorkspaceUser;
+    onTitleChange: (value: string, isValid: boolean) => void;
+    onRecurrenceChange: (cronExpression: string, startDate: Date | null, isValid: boolean) => void;
+    onEvaluationModeChange: (isShared: boolean) => void;
+    onDestinationChange: (notificationChannelId: string) => void;
+    onRecipientsChange: (updatedRecipients: IAutomationRecipient[]) => void;
+    onSubjectChange: (value: string | number, isValid: boolean) => void;
+    onMessageChange: (value: string, isValid: boolean) => void;
+    isCronValid: boolean;
+    isTitleValid: boolean;
+    isSubjectValid: boolean;
+    isOnMessageValid: boolean;
+};
+//# sourceMappingURL=useScheduledEmailFormState.d.ts.map

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/hooks/useScheduledEmailFormState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useScheduledEmailFormState.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/hooks/useScheduledEmailFormState.ts"],"names":[],"mappings":"AAIA,OAAO,EAEH,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAE9B,KAAK,mCAAmC,EACxC,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,4CAA4C,EACjD,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,KAAK,8BAA8B,EACnC,KAAK,kCAAkC,EACvC,KAAK,OAAO,EACZ,KAAK,cAAc,EACtB,MAAM,qBAAqB,CAAC;AAiB7B,MAAM,WAAW,gCAAgC;IAC7C,qBAAqB,CAAC,EAAE,yBAAyB,CAAC;IAClD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,oBAAoB,EAAE,8BAA8B,EAAE,GAAG,kCAAkC,EAAE,CAAC;IAC9F,iFAAiF;IACjF,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,sBAAsB,EAAE,OAAO,EAAE,CAAC;IAClC,iCAAiC,EAAE,OAAO,EAAE,CAAC;IAC7C,6BAA6B,EAAE,wBAAwB,EAAE,GAAG,SAAS,CAAC;IACtE,yBAAyB,EAAE,iBAAiB,EAAE,GAAG,SAAS,CAAC;IAC3D,8BAA8B,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,GAAG,SAAS,CAAC;IAChF,gCAAgC,EAAE,wBAAwB,EAAE,GAAG,SAAS,CAAC;IACzE,qCAAqC,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,EAAE,CAAC,GAAG,SAAS,CAAC;IAC9F,+BAA+B,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,EAAE,CAAC,GAAG,SAAS,CAAC;IACzF,kBAAkB,CAAC,EAAE,4CAA4C,CAAC,UAAU,CAAC,CAAC;IAC9E,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CAAC,EACvC,qBAAqB,EACrB,MAAM,EACN,OAAO,EACP,oBAAoB,EACpB,KAAK,EACL,yBAAyB,EACzB,sBAAsB,EACtB,iCAAiC,EACjC,6BAA6B,EAC7B,yBAAyB,EACzB,8BAA8B,EAC9B,gCAAgC,EAChC,qCAAqC,EACrC,+BAA+B,EAC/B,kBAAkB,EAClB,WAAW,EACd,EAAE,gCAAgC;;;;;;;;;;;;;;;;;EAwIlC"}

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/hooks/useScheduledEmailFormState.js

@@ -0,0 +1,203 @@
+// (C) 2026 GoodData Corporation
+import { useState } from "react";
+import { setExportParametersByTab } from "../../../../../_staging/automation/index.js";
+import { useAutomationsContext } from "../../../contexts/AutomationsContext.js";
+import { useScheduledEmailDialogContext } from "../../../contexts/ScheduledEmailDialogContext.js";
+import { convertCurrentUserToAutomationRecipient, convertCurrentUserToWorkspaceUser, convertExternalRecipientToAutomationRecipient, } from "../../../shared/utils/automationUtils.js";
+import { toModifiedISOStringToTimezone, toNormalizedFirstRunAndCron } from "../../utils/date.js";
+import { getUserTimezone } from "../../utils/timezone.js";
+import { newDashboardExportDefinitionMetadataObjectDefinition, newWidgetExportDefinitionMetadataObjectDefinition, } from "../utils/exportDefinitions.js";
+/**
+ * Owns the scheduled-email dialog's `editedAutomation` draft (initialized either from
+ * `scheduledExportToEdit` or via `newAutomationMetadataObjectDefinition`), its `originalAutomation`
+ * baseline, the derived defaults (`defaultRecipient`, `defaultUser`), and the form's field/message
+ * change handlers and their validity UI state.
+ *
+ * `timezone` (already part 1) and `currentUser` are read from {@link useAutomationsContext};
+ * `dashboardId`/`dashboardTitle` from {@link useScheduledEmailDialogContext}. The effective-filters
+ * derivations, `parametersByTabForNewAutomation`, `defaultPdfPageSize`, and `targetTabId` stay owned
+ * by the parent (`useEditScheduledEmail`) — shared with other consumers — and are passed in as params.
+ *
+ * Part 2 of 2 (mirrors the alerting `useAlertFormState` part 2): completes the hook by folding in the
+ * draft init that part 1 left in the parent.
+ *
+ * @internal
+ */
+export function useScheduledEmailFormState({ scheduledExportToEdit, widget, insight, notificationChannels, users, externalRecipientOverride, effectiveWidgetFilters, effectiveWidgetFiltersWithInsight, effectiveVisibleWidgetFilters, effectiveDashboardFilters, effectiveDashboardFiltersByTab, effectiveVisibleDashboardFilters, effectiveVisibleDashboardFiltersByTab, parametersByTabForNewAutomation, defaultPdfPageSize, targetTabId, }) {
+    const { timezone, currentUser } = useAutomationsContext();
+    const { dashboardId, dashboardTitle } = useScheduledEmailDialogContext();
+    const isWidget = !!widget && !!insight;
+    const defaultUser = convertCurrentUserToWorkspaceUser(users ?? [], currentUser);
+    const defaultRecipient = externalRecipientOverride
+        ? convertExternalRecipientToAutomationRecipient(externalRecipientOverride)
+        : convertCurrentUserToAutomationRecipient(users ?? [], currentUser);
+    const firstChannel = notificationChannels[0]?.id;
+    const [editedAutomation, setEditedAutomation] = useState(scheduledExportToEdit ??
+        newAutomationMetadataObjectDefinition(isWidget
+            ? {
+                timezone,
+                dashboardId: dashboardId,
+                notificationChannel: firstChannel,
+                insight,
+                widget,
+                recipient: defaultRecipient,
+                widgetFilters: effectiveWidgetFilters,
+                widgetFiltersWithInsight: effectiveWidgetFiltersWithInsight,
+                dashboardFilters: effectiveDashboardFilters,
+                visibleFiltersMetadata: effectiveVisibleWidgetFilters,
+                defaultPdfPageSize,
+                evaluationMode: "PER_RECIPIENT",
+                targetTabId,
+                parametersByTab: parametersByTabForNewAutomation,
+            }
+            : {
+                timezone,
+                dashboardId: dashboardId,
+                notificationChannel: firstChannel,
+                title: dashboardTitle,
+                recipient: defaultRecipient,
+                dashboardFilters: effectiveDashboardFilters,
+                filtersByTab: effectiveDashboardFiltersByTab,
+                visibleFiltersMetadata: effectiveVisibleDashboardFilters,
+                visibleFiltersByTab: effectiveVisibleDashboardFiltersByTab,
+                defaultPdfPageSize,
+                evaluationMode: "PER_RECIPIENT",
+                parametersByTab: parametersByTabForNewAutomation,
+            }));
+    const [originalAutomation] = useState(editedAutomation);
+    const [isCronValid, setIsCronValid] = useState(true);
+    const [isTitleValid, setIsTitleValid] = useState(true);
+    const [isSubjectValid, setIsSubjectValid] = useState(true);
+    const [isOnMessageValid, setIsOnMessageValid] = useState(true);
+    const onTitleChange = (value, isValid) => {
+        setIsTitleValid(isValid);
+        setEditedAutomation((s) => ({ ...s, title: value }));
+    };
+    const onRecurrenceChange = (cronExpression, startDate, isValid) => {
+        setIsCronValid(isValid);
+        setEditedAutomation((s) => ({
+            ...s,
+            schedule: {
+                ...s.schedule,
+                cron: cronExpression,
+                firstRun: toModifiedISOStringToTimezone(startDate ?? new Date(), timezone).iso,
+            },
+        }));
+    };
+    const onEvaluationModeChange = (isShared) => {
+        setEditedAutomation((s) => ({
+            ...s,
+            evaluationMode: isShared ? "SHARED" : "PER_RECIPIENT",
+        }));
+    };
+    const onDestinationChange = (notificationChannelId) => {
+        setEditedAutomation((s) => ({
+            ...s,
+            notificationChannel: notificationChannelId,
+        }));
+    };
+    const onRecipientsChange = (updatedRecipients) => {
+        setEditedAutomation((s) => ({
+            ...s,
+            recipients: updatedRecipients,
+        }));
+    };
+    const onSubjectChange = (value, isValid) => {
+        setIsSubjectValid(isValid);
+        setEditedAutomation((s) => ({
+            ...s,
+            details: {
+                ...s.details,
+                subject: value,
+            },
+        }));
+    };
+    const onMessageChange = (value, isValid) => {
+        setIsOnMessageValid(isValid);
+        setEditedAutomation((s) => ({
+            ...s,
+            details: {
+                ...s.details,
+                message: value,
+            },
+        }));
+    };
+    return {
+        editedAutomation,
+        setEditedAutomation,
+        originalAutomation,
+        defaultRecipient,
+        defaultUser,
+        onTitleChange,
+        onRecurrenceChange,
+        onEvaluationModeChange,
+        onDestinationChange,
+        onRecipientsChange,
+        onSubjectChange,
+        onMessageChange,
+        isCronValid,
+        isTitleValid,
+        isSubjectValid,
+        isOnMessageValid,
+    };
+}
+function newAutomationMetadataObjectDefinition({ timezone, dashboardId, notificationChannel, title, insight, widget, recipient, dashboardFilters, filtersByTab, widgetFilters, widgetFiltersWithInsight, visibleFiltersMetadata, visibleFiltersByTab, defaultPdfPageSize, evaluationMode, targetTabId, parametersByTab, }) {
+    const { firstRun, cron } = toNormalizedFirstRunAndCron(timezone);
+    const exportDefinition = widget && insight
+        ? newWidgetExportDefinitionMetadataObjectDefinition({
+            insight,
+            widget,
+            dashboardId,
+            format: "PNG",
+            widgetFilters,
+            widgetFiltersWithInsight,
+            dashboardFilters,
+            defaultPdfPageSize,
+        })
+        : newDashboardExportDefinitionMetadataObjectDefinition({
+            dashboardId,
+            dashboardTitle: title ?? "",
+            dashboardFilters,
+            filtersByTab,
+            format: "PDF",
+        });
+    let metadataObj = visibleFiltersMetadata || visibleFiltersByTab
+        ? {
+            metadata: {
+                ...(visibleFiltersMetadata ? { visibleFilters: visibleFiltersMetadata } : {}),
+                ...(visibleFiltersByTab ? { visibleFiltersByTab } : {}),
+            },
+        }
+        : {};
+    if (targetTabId) {
+        metadataObj = {
+            ...metadataObj,
+            metadata: {
+                ...metadataObj.metadata,
+                targetTabIdentifier: targetTabId,
+            },
+        };
+    }
+    const automation = {
+        type: "automation",
+        title: undefined,
+        description: undefined,
+        tags: [],
+        schedule: {
+            timezone: timezone ?? getUserTimezone().identifier,
+            firstRun,
+            cron,
+        },
+        details: {
+            message: "",
+            subject: "",
+        },
+        exportDefinitions: [{ ...exportDefinition }],
+        recipients: [recipient],
+        evaluationMode,
+        notificationChannel,
+        dashboard: dashboardId ? { id: dashboardId } : undefined,
+        ...metadataObj,
+    };
+    return parametersByTab ? setExportParametersByTab(automation, parametersByTab) : automation;
+}

package/esm/presentation/automations/shared/dateFilterConfig/dateFilterConfigConverters.d.ts

@@ -1,10 +1,2 @@
-import { type IDateFilterConfig } from "@gooddata/sdk-model";
-import { type IDateFilterOptionsByType } from "@gooddata/sdk-ui-filters";
-/**
- * Converts date filter config - as stored on the backend - into the date filter options that are aimed for
- * consumption by the actual date filtering view components.
- *
- * @param config - date filter config from backend
- */
-export declare function convertDateFilterConfigToDateFilterOptions(config: IDateFilterConfig): IDateFilterOptionsByType;
+export { convertDateFilterConfigToDateFilterOptions } from "@gooddata/sdk-ui-filters";
 //# sourceMappingURL=dateFilterConfigConverters.d.ts.map

package/esm/presentation/automations/shared/dateFilterConfig/dateFilterConfigConverters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dateFilterConfigConverters.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/shared/dateFilterConfig/dateFilterConfigConverters.ts"],"names":[],"mappings":"AAKA,OAAO,EAIH,KAAK,iBAAiB,EAIzB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGH,KAAK,wBAAwB,EAIhC,MAAM,0BAA0B,CAAC;AAKlC;;;;;GAKG;AACH,wBAAgB,0CAA0C,CACtD,MAAM,EAAE,iBAAiB,GAC1B,wBAAwB,CAgB1B"}
+{"version":3,"file":"dateFilterConfigConverters.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/shared/dateFilterConfig/dateFilterConfigConverters.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,0CAA0C,EAAE,MAAM,0BAA0B,CAAC"}

package/esm/presentation/automations/shared/dateFilterConfig/dateFilterConfigConverters.js

@@ -1,89 +1,4 @@
 // (C) 2019-2026 GoodData Corporation
-import { endOfDay, format, startOfDay, subMonths } from "date-fns";
-import { groupBy, isEmpty, max, min } from "lodash-es";
-// TODO: this import was coming from internal/esm and was wrecking tests
-const PLATFORM_DATE_FORMAT = "yyyy-MM-dd HH:mm";
-/**
- * Converts date filter config - as stored on the backend - into the date filter options that are aimed for
- * consumption by the actual date filtering view components.
- *
- * @param config - date filter config from backend
- */
-export function convertDateFilterConfigToDateFilterOptions(config) {
-    const allTime = convertAllTime(config.allTime);
-    const emptyValues = convertEmptyValues(config.emptyValues);
-    const absoluteForm = convertAbsoluteForm(config.absoluteForm);
-    const relativeForm = convertRelativeForm(config.relativeForm);
-    const absolutePreset = convertAbsolutePresets(config.absolutePresets);
-    const relativePreset = convertRelativePresets(config.relativePresets);
-    return removeEmptyKeysFromDateFilterOptions({
-        allTime,
-        emptyValues,
-        absoluteForm,
-        absolutePreset,
-        relativeForm,
-        relativePreset,
-    });
-}
-function convertAllTime(filter) {
-    return (filter && {
-        ...filter,
-        type: "allTime",
-    });
-}
-function convertEmptyValues(filter) {
-    return (filter && {
-        ...filter,
-        type: "emptyValues",
-    });
-}
-function convertAbsoluteForm(filter) {
-    return (filter && {
-        ...filter,
-        from: format(startOfDay(subMonths(new Date(), 1)), PLATFORM_DATE_FORMAT),
-        to: format(endOfDay(new Date()), PLATFORM_DATE_FORMAT),
-        type: "absoluteForm",
-    });
-}
-function convertRelativeForm(filter) {
-    return (filter && {
-        from: undefined,
-        // we order the granularities anyway, this lets the user to config the default
-        granularity: filter.availableGranularities[0],
-        localIdentifier: filter.localIdentifier,
-        name: filter.name,
-        to: undefined,
-        type: "relativeForm",
-        visible: filter.visible,
-    });
-}
-function convertAbsolutePresets(filters) {
-    return filters?.map((preset) => sanitizeDateFilterOption({
-        ...preset,
-        type: "absolutePreset",
-    }));
-}
-function convertRelativePresets(filters) {
-    return (filters &&
-        groupBy(filters.map((preset) => sanitizeDateFilterOption({
-            ...preset,
-            type: "relativePreset",
-        })), (preset) => preset.granularity));
-}
-function removeEmptyKeysFromDateFilterOptions({ absoluteForm, absolutePreset, allTime, emptyValues, relativeForm, relativePreset, }) {
-    return {
-        ...(allTime && { allTime }),
-        ...(emptyValues && { emptyValues }),
-        ...(absoluteForm && { absoluteForm }),
-        ...(!isEmpty(absolutePreset) && { absolutePreset }),
-        ...(relativeForm && { relativeForm }),
-        ...(!isEmpty(relativePreset) && { relativePreset }),
-    };
-}
-function sanitizeDateFilterOption(option) {
-    return {
-        ...option,
-        from: min([option.from, option.to]),
-        to: max([option.from, option.to]),
-    };
-}
+/* oxlint-disable no-barrel-files/no-barrel-files */
+// Moved to sdk-ui-filters (shared with the CF date picker); re-exported for existing import sites.
+export { convertDateFilterConfigToDateFilterOptions } from "@gooddata/sdk-ui-filters";

package/esm/presentation/automations/shared/dateFilterConfig/dateFilterOptionMapping.d.ts

@@ -1,34 +1,2 @@
-import { type IDashboardDateFilter } from "@gooddata/sdk-model";
-import { type DateFilterOption, type IDateFilterOptionsByType } from "@gooddata/sdk-ui-filters";
-interface IDateFilterOptionInfo {
-    dateFilterOption: DateFilterOption;
-    excludeCurrentPeriod: boolean;
-}
-/**
- * Tries to match a preset or a form with the provided value. Prioritizes the provided option if possible.
- *
- * @remarks
- * This is to handle cases when user picked a form and filled values that match an existing preset.
- * In those cases we want to show the form as picked even though a preset would otherwise be preferred.
- *
- * @param dateFilter - value to match against
- * @param availableOptions - date options available
- * @param preferredOptionId - id of the option that should be matched first if possible
- */
-export declare function matchDateFilterToDateFilterOptionWithPreference(dateFilter: IDashboardDateFilter | undefined, availableOptions: IDateFilterOptionsByType, preferredOptionId: string | undefined): IDateFilterOptionInfo;
-/**
- * Tries to match a preset or a form with the provided value. Prioritizes presets over forms.
- * @param dateFilterValue - value to match against
- * @param availableOptions - date options available
- */
-export declare function matchDateFilterToDateFilterOption(dateFilter: IDashboardDateFilter | undefined, availableOptions: IDateFilterOptionsByType): IDateFilterOptionInfo;
-/**
- * Flattens the provided date filter options. The flattening maintains a stable, predefined order in which
- * the options should be rendered by the date filter component.
- *
- * @param dateFilterOptions - available options to flatten
- */
-export declare function flattenDateFilterOptions(dateFilterOptions: IDateFilterOptionsByType): DateFilterOption[];
-export declare function findDateFilterOptionByValue(dateFilter: IDashboardDateFilter, dateFilterOptions: IDateFilterOptionsByType): DateFilterOption | undefined;
-export {};
+export { findDateFilterOptionByValue, flattenDateFilterOptions, matchDateFilterToDateFilterOption, matchDateFilterToDateFilterOptionWithPreference, } from "@gooddata/sdk-ui-filters";
 //# sourceMappingURL=dateFilterOptionMapping.d.ts.map

package/esm/presentation/automations/shared/dateFilterConfig/dateFilterOptionMapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dateFilterOptionMapping.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/shared/dateFilterConfig/dateFilterOptionMapping.ts"],"names":[],"mappings":"AAIA,OAAO,EAKH,KAAK,oBAAoB,EAM5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACH,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAKhC,MAAM,0BAA0B,CAAC;AAUlC,UAAU,qBAAqB;IAC3B,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,oBAAoB,EAAE,OAAO,CAAC;CACjC;AAaD;;;;;;;;;;GAUG;AACH,wBAAgB,+CAA+C,CAC3D,UAAU,EAAE,oBAAoB,GAAG,SAAS,EAC5C,gBAAgB,EAAE,wBAAwB,EAC1C,iBAAiB,EAAE,MAAM,GAAG,SAAS,GACtC,qBAAqB,CAmBvB;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC7C,UAAU,EAAE,oBAAoB,GAAG,SAAS,EAC5C,gBAAgB,EAAE,wBAAwB,GAC3C,qBAAqB,CAqEvB;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,iBAAiB,EAAE,wBAAwB,GAAG,gBAAgB,EAAE,CAmBxG;AAsDD,wBAAgB,2BAA2B,CACvC,UAAU,EAAE,oBAAoB,EAChC,iBAAiB,EAAE,wBAAwB,gCAG9C"}
+{"version":3,"file":"dateFilterOptionMapping.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/shared/dateFilterConfig/dateFilterOptionMapping.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,2BAA2B,EAC3B,wBAAwB,EACxB,iCAAiC,EACjC,+CAA+C,GAClD,MAAM,0BAA0B,CAAC"}