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

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

@@ -1,20 +1,18 @@
 // (C) 2019-2026 GoodData Corporation
 import { useCallback, useRef } from "react";
-import { DEFAULT_CSV_DELIMITER, isExportDefinitionDashboardRequestPayload, isExportDefinitionVisualizationObjectRequestPayload, isInsightWidget, } from "@gooddata/sdk-model";
+import { DEFAULT_CSV_DELIMITER, } from "@gooddata/sdk-model";
 import { getAutomationExportParametersByTab, setExportParametersByTab, } from "../../../../../_staging/automation/index.js";
 import { useAutomationsContext } from "../../../contexts/AutomationsContext.js";
 import { useScheduledEmailDialogContext } from "../../../contexts/ScheduledEmailDialogContext.js";
-import { getDefaultSelectedFiltersFromFiltersByTab } from "../../../shared/automationFilters/useAutomationFiltersSelect.js";
-import { getAppliedDashboardFilters, getAppliedWidgetFilters, getVisibleFiltersByFilters, getVisibleFiltersByFiltersByTab, } from "../../../shared/automationFilters/utils.js";
 import { toNormalizedStartDate } from "../../utils/date.js";
 import { useScheduledEmailEffectiveFilters } from "./useScheduledEmailEffectiveFilters.js";
 import { useScheduledEmailExportSettings } from "./useScheduledEmailExportSettings.js";
+import { useScheduledEmailFilters } from "./useScheduledEmailFilters.js";
 import { useScheduledEmailFormState } from "./useScheduledEmailFormState.js";
 import { useScheduledEmailFormValidity } from "./useScheduledEmailFormValidity.js";
 export function useEditScheduledEmail({ scheduledExportToEdit, notificationChannels, insight, widget, users, editedAutomationFilters, dashboardFilters, editedAutomationFiltersByTab, maxAutomationsRecipients, setEditedAutomationFilters, setEditedAutomationFiltersByTab, availableFiltersAsVisibleFilters, storeFilters, setStoreFilters, filtersForNewAutomation, externalRecipientOverride, defaultPdfPageSize, filtersDataByTab, availableFiltersAsVisibleFiltersByTab, }) {
     const { settings, features: { enableAutomationEvaluationMode }, } = useAutomationsContext();
-    const { dashboardId, dashboardTitle, hiddenFilters: dashboardHiddenFilters, commonDateFilterId, widgetLocalIdToTabIdMap: widgetTabMap, } = useScheduledEmailDialogContext();
-    const isWidget = !!widget && !!insight;
+    const { dashboardId, dashboardTitle, widgetLocalIdToTabIdMap: widgetTabMap, } = useScheduledEmailDialogContext();
     // Dashboard
     const resolvedDefaultCsvDelimiter = settings?.exportCsvCustomDelimiter ?? DEFAULT_CSV_DELIMITER;
     const areDashboardFiltersChanged = !!dashboardFilters;
@@ -75,170 +73,19 @@ export function useEditScheduledEmail({ scheduledExportToEdit, notificationChann
         resolvedDefaultCsvDelimiter,
         latestParametersWireRef,
     });
-    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,
+    const { onFiltersChange, onFiltersByTabChange, onApplyCurrentFilters, onStoreFiltersChange } = useScheduledEmailFilters({
         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,
-            },
-        }));
-    }, [
+        setEditedAutomationFilters,
         setEditedAutomationFiltersByTab,
-        storeFilters,
-        setEditedAutomation,
+        availableFiltersAsVisibleFilters,
         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]);
+        setStoreFilters,
+        filtersForNewAutomation,
+    });
     const startDate = toNormalizedStartDate(editedAutomation.schedule?.firstRun, editedAutomation.schedule?.timezone);
     const { isSubmitDisabled, validationErrorMessage, isParentValid, allowExternalRecipients, allowOnlyLoggedUserRecipients, } = useScheduledEmailFormValidity({
         editedAutomation,

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

@@ -12,16 +12,16 @@ export interface IUseScheduledEmailEffectiveFiltersProps {
 }
 /**
  * Derives the effective-filters cluster consumed early by `useScheduledEmailFormState` (draft init) and
- * `useScheduledEmailExportSettings`, and later still by the (still-in-parent) filters handlers.
+ * `useScheduledEmailExportSettings`, and later still by the `useScheduledEmailFilters` handlers.
  *
  * Filters slice A of 2. Reads `hiddenFilters`/`commonDateFilterId`/`exportParametersByTab` from
- * {@link useScheduledEmailDialogContext} internally, same as the parent (`useEditScheduledEmail`) does
- * today. `isWidget` is re-derived internally (`!!widget && !!insight`) — if the parent still needs it for
- * the filters handlers, it keeps its own copy, a harmless identical re-derivation (mirrors the sibling
- * hooks).
+ * {@link useScheduledEmailDialogContext} internally, as does `useScheduledEmailFilters` — the parent
+ * (`useEditScheduledEmail`) no longer reads them itself. `isWidget` is re-derived internally
+ * (`!!widget && !!insight`) — `useScheduledEmailFilters` keeps its own copy, a harmless identical
+ * re-derivation (mirrors the sibling hooks).
  *
- * Slice B (`useScheduledEmailFilters`, next PR) will own the four filters handlers, which run after
- * `formState` (they need `setEditedAutomation`); this derivation cluster runs before it, hence the split.
+ * `useScheduledEmailFilters` (slice B) owns the four filters handlers, which run after `formState` (they
+ * need `setEditedAutomation`); this derivation cluster runs before it, hence the split.
  *
  * @internal
  */

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

@@ -5,16 +5,16 @@ import { shouldStoreExportParameters } from "../../../shared/automationFilters/a
 import { getAppliedDashboardFilters, getAppliedWidgetFilters, getVisibleFiltersByFilters, getVisibleFiltersByFiltersByTab, } from "../../../shared/automationFilters/utils.js";
 /**
  * Derives the effective-filters cluster consumed early by `useScheduledEmailFormState` (draft init) and
- * `useScheduledEmailExportSettings`, and later still by the (still-in-parent) filters handlers.
+ * `useScheduledEmailExportSettings`, and later still by the `useScheduledEmailFilters` handlers.
  *
  * Filters slice A of 2. Reads `hiddenFilters`/`commonDateFilterId`/`exportParametersByTab` from
- * {@link useScheduledEmailDialogContext} internally, same as the parent (`useEditScheduledEmail`) does
- * today. `isWidget` is re-derived internally (`!!widget && !!insight`) — if the parent still needs it for
- * the filters handlers, it keeps its own copy, a harmless identical re-derivation (mirrors the sibling
- * hooks).
+ * {@link useScheduledEmailDialogContext} internally, as does `useScheduledEmailFilters` — the parent
+ * (`useEditScheduledEmail`) no longer reads them itself. `isWidget` is re-derived internally
+ * (`!!widget && !!insight`) — `useScheduledEmailFilters` keeps its own copy, a harmless identical
+ * re-derivation (mirrors the sibling hooks).
  *
- * Slice B (`useScheduledEmailFilters`, next PR) will own the four filters handlers, which run after
- * `formState` (they need `setEditedAutomation`); this derivation cluster runs before it, hence the split.
+ * `useScheduledEmailFilters` (slice B) owns the four filters handlers, which run after `formState` (they
+ * need `setEditedAutomation`); this derivation cluster runs before it, hence the split.
  *
  * @internal
  */

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

@@ -0,0 +1,35 @@
+import { type Dispatch, type SetStateAction } from "react";
+import { type FilterContextItem, type IAutomationMetadataObjectDefinition, type IAutomationVisibleFilter, type IInsight, type IWidget } from "@gooddata/sdk-model";
+import type { IAutomationFiltersTab } from "../../../../../model/store/filtering/types.js";
+export interface IUseScheduledEmailFiltersProps {
+    setEditedAutomation: Dispatch<SetStateAction<IAutomationMetadataObjectDefinition>>;
+    widget?: IWidget;
+    insight?: IInsight;
+    setEditedAutomationFilters: (filters: FilterContextItem[]) => void;
+    setEditedAutomationFiltersByTab?: (filters: Record<string, FilterContextItem[]>) => void;
+    availableFiltersAsVisibleFilters?: IAutomationVisibleFilter[] | undefined;
+    availableFiltersAsVisibleFiltersByTab?: Record<string, IAutomationVisibleFilter[]>;
+    filtersDataByTab?: IAutomationFiltersTab[] | undefined;
+    storeFilters?: boolean;
+    setStoreFilters: (storeFilters: boolean) => void;
+    filtersForNewAutomation: FilterContextItem[];
+}
+/**
+ * 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 declare function useScheduledEmailFilters({ setEditedAutomation, widget, insight, setEditedAutomationFilters, setEditedAutomationFiltersByTab, availableFiltersAsVisibleFilters, availableFiltersAsVisibleFiltersByTab, filtersDataByTab, storeFilters, setStoreFilters, filtersForNewAutomation }: IUseScheduledEmailFiltersProps): {
+    onFiltersChange: (filters: FilterContextItem[], storeFiltersParam?: boolean | undefined) => void;
+    onFiltersByTabChange: (newFiltersByTab: Record<string, FilterContextItem[]>, storeFiltersParam?: boolean | undefined) => void;
+    onApplyCurrentFilters: () => void;
+    onStoreFiltersChange: (value: boolean, filters?: FilterContextItem[] | undefined, filtersByTabParam?: Record<string, FilterContextItem[]> | undefined) => void;
+};
+//# sourceMappingURL=useScheduledEmailFilters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useScheduledEmailFilters.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/hooks/useScheduledEmailFilters.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAe,MAAM,OAAO,CAAC;AAExE,OAAO,EACH,KAAK,iBAAiB,EACtB,KAAK,mCAAmC,EACxC,KAAK,wBAAwB,EAC7B,KAAK,QAAQ,EACb,KAAK,OAAO,EAIf,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+CAA+C,CAAC;AAU3F,MAAM,WAAW,8BAA8B;IAC3C,mBAAmB,EAAE,QAAQ,CAAC,cAAc,CAAC,mCAAmC,CAAC,CAAC,CAAC;IACnF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,0BAA0B,EAAE,CAAC,OAAO,EAAE,iBAAiB,EAAE,KAAK,IAAI,CAAC;IACnE,+BAA+B,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,KAAK,IAAI,CAAC;IACzF,gCAAgC,CAAC,EAAE,wBAAwB,EAAE,GAAG,SAAS,CAAC;IAC1E,qCAAqC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,EAAE,CAAC,CAAC;IACnF,gBAAgB,CAAC,EAAE,qBAAqB,EAAE,GAAG,SAAS,CAAC;IACvD,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,CAAC,YAAY,EAAE,OAAO,KAAK,IAAI,CAAC;IACjD,uBAAuB,EAAE,iBAAiB,EAAE,CAAC;CAChD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,EACrC,mBAAmB,EACnB,MAAM,EACN,OAAO,EACP,0BAA0B,EAC1B,+BAA+B,EAC/B,gCAAgC,EAChC,qCAAqC,EACrC,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,uBAAuB,EAC1B,EAAE,8BAA8B;;;;;EAqPhC"}

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/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"}