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

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/RecipientsSelect/RecipientsSelect.js

@@ -3,11 +3,11 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { useMemo } from "react";
 import { sortBy } from "lodash-es";
 import { DETAILED_ANNOUNCEMENT_THRESHOLD, UiSearchResultsAnnouncement } from "@gooddata/sdk-ui-kit";
+import { useWorkspaceUsersSearch } from "../../../../shared/hooks/useWorkspaceUsersSearch.js";
 import { convertUserToAutomationRecipient } from "../../../../shared/utils/automationUtils.js";
 import { createUser, matchRecipient } from "../../../utils/users.js";
 import { isEmail } from "../../../utils/validate.js";
 import { RecipientsSelectRenderer } from "./RecipientsSelectRenderer.js";
-import { useWorkspaceUsersSearch } from "./useWorkspaceUsersSearch.js";
 export function RecipientsSelect({ id, value, onChange, loggedUser, allowEmptySelection, allowExternalRecipients, allowOnlyLoggedUserRecipients, maxRecipients, className, notificationChannels, notificationChannelId, showLabel = true, onKeyDownSubmit, externalRecipientOverride, }) {
     const isServerSearch = !externalRecipientOverride && !allowOnlyLoggedUserRecipients;
     const { search, users, usersError, isLoading, onSearch, onActivate } = useWorkspaceUsersSearch({

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/SubjectForm/SubjectForm.d.ts

@@ -1,11 +1,3 @@
-import { type IAutomationMetadataObjectDefinition } from "@gooddata/sdk-model";
-interface ISubjectFormProps {
-    dashboardTitle: string;
-    editedAutomation: IAutomationMetadataObjectDefinition;
-    isSubmitDisabled?: boolean;
-    onChange: (value: string, isValid: boolean) => void;
-    onKeyDownSubmit: () => void;
-}
-export declare function SubjectForm({ dashboardTitle, editedAutomation, isSubmitDisabled, onChange, onKeyDownSubmit }: ISubjectFormProps): import("react/jsx-runtime").JSX.Element;
-export {};
+import { type IScheduledEmailDialogSubjectProps } from "../../../types.js";
+export declare function SubjectForm({ dashboardTitle, editedAutomation, isSubmitDisabled, onChange, onKeyDownSubmit }: IScheduledEmailDialogSubjectProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=SubjectForm.d.ts.map

package/esm/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/SubjectForm/SubjectForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SubjectForm.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/SubjectForm/SubjectForm.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,mCAAmC,EAAE,MAAM,qBAAqB,CAAC;AAc/E,UAAU,iBAAiB;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,mCAAmC,CAAC;IACtD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACpD,eAAe,EAAE,MAAM,IAAI,CAAC;CAC/B;AAED,wBAAgB,WAAW,CAAC,EACxB,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EACR,eAAe,EAClB,EAAE,iBAAiB,2CA8FnB"}
+{"version":3,"file":"SubjectForm.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/automations/scheduledEmail/DefaultScheduledEmailDialog/components/SubjectForm/SubjectForm.tsx"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,mBAAmB,CAAC;AAK3E,wBAAgB,WAAW,CAAC,EACxB,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EACR,eAAe,EAClB,EAAE,iCAAiC,2CA8FnC"}

package/esm/presentation/automations/scheduledEmail/blocks/DefaultLoadingScheduledEmailDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultLoadingScheduledEmailDialog.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/DefaultLoadingScheduledEmailDialog.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAarE,UAAU,wCAAwC;IAC9C,qBAAqB,CAAC,EAAE,yBAAyB,CAAC;IAClD,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB;AAED,wBAAgB,kCAAkC,CAAC,EAC/C,qBAAqB,EACrB,QAAQ,EACX,EAAE,wCAAwC,2CAkD1C"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogDashboardAttachments.d.ts

@@ -0,0 +1,16 @@
+import { type ReactElement } from "react";
+import { type IScheduledEmailDialogDashboardAttachmentsProps } from "../types.js";
+/**
+ * The scheduled-export dialog's dashboard-attachments field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogDashboardAttachments} with the props of
+ * {@link useScheduledEmailDialogDashboardAttachmentsProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true and when the dialog context has a `widget`
+ * (a widget schedule renders {@link ScheduledEmailDialogWidgetAttachments} instead), the same
+ * visibility the default dialog gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogDashboardAttachments(props: Partial<IScheduledEmailDialogDashboardAttachmentsProps>): ReactElement;
+//# sourceMappingURL=ScheduledEmailDialogDashboardAttachments.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogDashboardAttachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogDashboardAttachments.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogDashboardAttachments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAK1C,OAAO,EAAE,KAAK,8CAA8C,EAAE,MAAM,aAAa,CAAC;AAIlF;;;;;;;;;;;GAWG;AACH,wBAAgB,wCAAwC,CACpD,KAAK,EAAE,OAAO,CAAC,8CAA8C,CAAC,GAC/D,YAAY,CAMd"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogDashboardAttachments.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useScheduledEmailDialogContext } from "../../contexts/ScheduledEmailDialogContext.js";
+import { DefaultScheduledEmailDialogDashboardAttachments } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogDashboardAttachments.js";
+import { useScheduledEmailDialogDashboardAttachmentsProps } from "../state/useScheduledEmailDialogFieldProps.js";
+import { WhenScheduledEmailDialogLoaded } from "./WhenScheduledEmailDialogLoaded.js";
+/**
+ * The scheduled-export dialog's dashboard-attachments field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogDashboardAttachments} with the props of
+ * {@link useScheduledEmailDialogDashboardAttachmentsProps}; every prop passed here replaces the
+ * hook's value for that prop wholesale. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true and when the dialog context has a `widget`
+ * (a widget schedule renders {@link ScheduledEmailDialogWidgetAttachments} instead), the same
+ * visibility the default dialog gives the field.
+ *
+ * @alpha
+ */
+export function ScheduledEmailDialogDashboardAttachments(props) {
+    return (_jsx(WhenScheduledEmailDialogLoaded, { children: _jsx(ConnectedScheduledEmailDialogDashboardAttachments, { ...props }) }));
+}
+function ConnectedScheduledEmailDialogDashboardAttachments(overrides) {
+    const defaultProps = useScheduledEmailDialogDashboardAttachmentsProps();
+    const { widget } = useScheduledEmailDialogContext();
+    if (widget) {
+        return null;
+    }
+    return _jsx(DefaultScheduledEmailDialogDashboardAttachments, { ...defaultProps, ...overrides });
+}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogEvaluationMode.d.ts

@@ -0,0 +1,16 @@
+import { type ReactElement } from "react";
+import { type IScheduledEmailDialogEvaluationModeProps } from "../types.js";
+/**
+ * The scheduled-export dialog's evaluation-mode checkbox, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogEvaluationMode} with the props of
+ * {@link useScheduledEmailDialogEvaluationModeProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true and while
+ * `useAutomationsContext().features.enableAutomationEvaluationMode` is off, the same visibility the
+ * default dialog gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogEvaluationMode(props: Partial<IScheduledEmailDialogEvaluationModeProps>): ReactElement;
+//# sourceMappingURL=ScheduledEmailDialogEvaluationMode.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogEvaluationMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogEvaluationMode.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogEvaluationMode.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAK1C,OAAO,EAAE,KAAK,wCAAwC,EAAE,MAAM,aAAa,CAAC;AAI5E;;;;;;;;;;;GAWG;AACH,wBAAgB,kCAAkC,CAC9C,KAAK,EAAE,OAAO,CAAC,wCAAwC,CAAC,GACzD,YAAY,CAMd"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogEvaluationMode.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
+import { DefaultScheduledEmailDialogEvaluationMode } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogEvaluationMode.js";
+import { useScheduledEmailDialogEvaluationModeProps } from "../state/useScheduledEmailDialogFieldProps.js";
+import { WhenScheduledEmailDialogLoaded } from "./WhenScheduledEmailDialogLoaded.js";
+/**
+ * The scheduled-export dialog's evaluation-mode checkbox, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogEvaluationMode} with the props of
+ * {@link useScheduledEmailDialogEvaluationModeProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true and while
+ * `useAutomationsContext().features.enableAutomationEvaluationMode` is off, the same visibility the
+ * default dialog gives the field.
+ *
+ * @alpha
+ */
+export function ScheduledEmailDialogEvaluationMode(props) {
+    return (_jsx(WhenScheduledEmailDialogLoaded, { children: _jsx(ConnectedScheduledEmailDialogEvaluationMode, { ...props }) }));
+}
+function ConnectedScheduledEmailDialogEvaluationMode(overrides) {
+    const defaultProps = useScheduledEmailDialogEvaluationModeProps();
+    const { features: { enableAutomationEvaluationMode }, } = useAutomationsContext();
+    if (!enableAutomationEvaluationMode) {
+        return null;
+    }
+    return _jsx(DefaultScheduledEmailDialogEvaluationMode, { ...defaultProps, ...overrides });
+}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogMessage.d.ts

@@ -0,0 +1,15 @@
+import { type ReactElement } from "react";
+import { type IScheduledEmailDialogMessageProps } from "../types.js";
+/**
+ * The scheduled-export dialog's message field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogMessage} with the props of
+ * {@link useScheduledEmailDialogMessageProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale. Renders nothing while `useScheduledEmailDialogContext().isLoading` is true
+ * and for an in-platform notification channel (which has no e-mail message), the same visibility
+ * the default dialog gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogMessage(props: Partial<IScheduledEmailDialogMessageProps>): ReactElement;
+//# sourceMappingURL=ScheduledEmailDialogMessage.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogMessage.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogMessage.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAK1C,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,aAAa,CAAC;AAIrE;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,CAAC,iCAAiC,CAAC,GAAG,YAAY,CAM3G"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogMessage.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DefaultScheduledEmailDialogMessage } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogMessage.js";
+import { useIsInPlatformChannel } from "../state/useIsInPlatformChannel.js";
+import { useScheduledEmailDialogMessageProps } from "../state/useScheduledEmailDialogFieldProps.js";
+import { WhenScheduledEmailDialogLoaded } from "./WhenScheduledEmailDialogLoaded.js";
+/**
+ * The scheduled-export dialog's message field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogMessage} with the props of
+ * {@link useScheduledEmailDialogMessageProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale. Renders nothing while `useScheduledEmailDialogContext().isLoading` is true
+ * and for an in-platform notification channel (which has no e-mail message), the same visibility
+ * the default dialog gives the field.
+ *
+ * @alpha
+ */
+export function ScheduledEmailDialogMessage(props) {
+    return (_jsx(WhenScheduledEmailDialogLoaded, { children: _jsx(ConnectedScheduledEmailDialogMessage, { ...props }) }));
+}
+function ConnectedScheduledEmailDialogMessage(overrides) {
+    const defaultProps = useScheduledEmailDialogMessageProps();
+    const isInPlatformChannel = useIsInPlatformChannel();
+    if (isInPlatformChannel) {
+        return null;
+    }
+    return _jsx(DefaultScheduledEmailDialogMessage, { ...defaultProps, ...overrides });
+}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogRecurrence.d.ts

@@ -0,0 +1,16 @@
+import { type ReactElement } from "react";
+import { type IScheduledEmailDialogRecurrenceProps } from "../types.js";
+/**
+ * The scheduled-export dialog's recurrence field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogRecurrence} with the props of
+ * {@link useScheduledEmailDialogRecurrenceProps}; every prop passed here replaces the hook's value
+ * for that prop wholesale. Pass `onKeyDownSubmit` to submit on Enter from the recurrence inputs —
+ * the default dialog passes its save action; without it Enter does nothing here. Renders nothing
+ * while `useScheduledEmailDialogContext().isLoading` is true; otherwise ungated, unlike the other
+ * General-tab fields.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogRecurrence(props: Partial<IScheduledEmailDialogRecurrenceProps>): ReactElement;
+//# sourceMappingURL=ScheduledEmailDialogRecurrence.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogRecurrence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogRecurrence.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogRecurrence.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAI1C,OAAO,EAAE,KAAK,oCAAoC,EAAE,MAAM,aAAa,CAAC;AAMxE;;;;;;;;;;;GAWG;AACH,wBAAgB,8BAA8B,CAC1C,KAAK,EAAE,OAAO,CAAC,oCAAoC,CAAC,GACrD,YAAY,CAMd"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogRecurrence.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DefaultScheduledEmailDialogRecurrence } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogRecurrence.js";
+import { useScheduledEmailDialogRecurrenceProps } from "../state/useScheduledEmailDialogFieldProps.js";
+import { WhenScheduledEmailDialogLoaded } from "./WhenScheduledEmailDialogLoaded.js";
+const noop = () => { };
+/**
+ * The scheduled-export dialog's recurrence field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogRecurrence} with the props of
+ * {@link useScheduledEmailDialogRecurrenceProps}; every prop passed here replaces the hook's value
+ * for that prop wholesale. Pass `onKeyDownSubmit` to submit on Enter from the recurrence inputs —
+ * the default dialog passes its save action; without it Enter does nothing here. Renders nothing
+ * while `useScheduledEmailDialogContext().isLoading` is true; otherwise ungated, unlike the other
+ * General-tab fields.
+ *
+ * @alpha
+ */
+export function ScheduledEmailDialogRecurrence(props) {
+    return (_jsx(WhenScheduledEmailDialogLoaded, { children: _jsx(ConnectedScheduledEmailDialogRecurrence, { ...props }) }));
+}
+function ConnectedScheduledEmailDialogRecurrence({ onKeyDownSubmit, ...overrides }) {
+    const defaultProps = useScheduledEmailDialogRecurrenceProps({ onKeyDownSubmit: onKeyDownSubmit ?? noop });
+    return _jsx(DefaultScheduledEmailDialogRecurrence, { ...defaultProps, ...overrides });
+}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogShell.d.ts

@@ -0,0 +1,59 @@
+import { type ReactElement } from "react";
+import { type IScheduledEmailDialogShellProps } from "../types.js";
+/**
+ * The scheduled-export dialog's chrome, connected to the dialog's state: the modal overlay, the dialog
+ * frame with the header row (the back button and the title input) and the action bar, the General and
+ * Filters tabs, the scrollable content area around the selected tab's content, the body's error and
+ * validation messages, the stale-filters confirmation step shown before the dialog when the saved filters
+ * or schedule timezone no longer match the dashboard, and the delete confirmation reached from the
+ * action bar in edit mode. While `useScheduledEmailDialogContext().isLoading` is true — on scheduled
+ * email the ordinary path while a widget export's filters load — it renders the loading skeleton and
+ * none of its children.
+ *
+ * The default dialog is `<ScheduledEmailDialogShell>` around the region blocks and form; a custom
+ * `ScheduledEmailDialogComponent` that keeps this chrome and arranges the blocks differently renders the
+ * shell itself. The shell does not own the save: call {@link useSaveScheduledEmailToBackend} and pass its
+ * `handleSaveScheduledEmail`, `isSavingScheduledEmail` and `savingErrorMessage`; build Enter handlers for
+ * the blocks you place with {@link useScheduledEmailSubmitOnEnter} over the same `handleSaveScheduledEmail`.
+ * Call that hook only once `useScheduledEmailDialogContext().isLoading` is false — the state hooks throw
+ * while the dialog loads — and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as
+ * the example does.
+ *
+ * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
+ *
+ * @example
+ * ```tsx
+ * function MyScheduledEmailDialog(props: IScheduledEmailDialogProps) {
+ *     const { isLoading } = useScheduledEmailDialogContext();
+ *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     if (isLoading) {
+ *         return <ScheduledEmailDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
+ *     }
+ *     return <MyScheduledEmailDialogBody {...props} />;
+ * }
+ *
+ * function MyScheduledEmailDialogBody(props: IScheduledEmailDialogProps) {
+ *     const { handleSaveScheduledEmail, isSavingScheduledEmail, savingErrorMessage } =
+ *         useSaveScheduledEmailToBackend(props);
+ *     const submitOnEnter = useScheduledEmailSubmitOnEnter({
+ *         onSubmit: handleSaveScheduledEmail,
+ *         isSaving: isSavingScheduledEmail,
+ *     });
+ *     return (
+ *         <ScheduledEmailDialogShell
+ *             {...props}
+ *             onSubmit={handleSaveScheduledEmail}
+ *             isSaving={isSavingScheduledEmail}
+ *             savingErrorMessage={savingErrorMessage}
+ *         >
+ *             <ScheduledEmailDialogDestination />
+ *             <ScheduledEmailDialogRecipients onKeyDownSubmit={submitOnEnter} />
+ *         </ScheduledEmailDialogShell>
+ *     );
+ * }
+ * ```
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogShell(props: IScheduledEmailDialogShellProps): ReactElement;
+//# sourceMappingURL=ScheduledEmailDialogShell.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogShell.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogShell.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAA0C,MAAM,OAAO,CAAC;AA4ClF,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,aAAa,CAAC;AAMnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,+BAA+B,GAAG,YAAY,CAW9F"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogShell.js

@@ -0,0 +1,195 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useMemo, useRef, useState } from "react";
+import cx from "classnames";
+import { useIntl } from "react-intl";
+import { ValidationContextStore, createInvalidNode, useValidationContextValue } from "@gooddata/sdk-ui";
+import { ConfirmDialogBase, Message, Overlay, OverlayController, OverlayControllerProvider, ScrollablePanel, UiTabs, useIdPrefixed, } from "@gooddata/sdk-ui-kit";
+import { DASHBOARD_DIALOG_OVERS_Z_INDEX } from "../../../constants/zIndex.js";
+import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
+import { useScheduledEmailDialogContext } from "../../contexts/ScheduledEmailDialogContext.js";
+import { ApplyCurrentFiltersConfirmDialog } from "../../shared/automationFilters/components/ApplyLatestFiltersConfirmDialog.js";
+import { DefaultAutomationDialogActionBar } from "../../shared/slots/DefaultAutomationDialogActionBar.js";
+import { DefaultScheduledEmailDialogFilters } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogFilters.js";
+import { DefaultScheduledEmailDialogHeader } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogHeader.js";
+import { SCHEDULED_EMAIL_DIALOG_ID } from "../DefaultScheduledEmailDialog/constants.js";
+import { useElementHeightSnapshot } from "../DefaultScheduledEmailDialog/hooks/useElementHeightSnapshot.js";
+import { DeleteScheduleConfirmDialog } from "../DefaultScheduledEmailManagementDialog/components/DeleteScheduleConfirmDialog.js";
+import { useScheduleEmailDialogAccessibility } from "../hooks/useScheduleEmailDialogAccessibility.js";
+import { useScheduledExportActions } from "../state/ScheduledExportActionsContext.js";
+import { useScheduledExportDraft } from "../state/ScheduledExportDraftContext.js";
+import { useScheduledExportFilters } from "../state/ScheduledExportFiltersContext.js";
+import { useScheduledEmailDialogActionBarProps, useScheduledEmailDialogFiltersProps, useScheduledEmailDialogHeaderProps, } from "../state/useScheduledEmailDialogRegionProps.js";
+import { useScheduledEmailSubmitOnEnter } from "../state/useScheduledEmailSubmitOnEnter.js";
+import { useScheduledExportAttachments } from "../state/useScheduledExportAttachments.js";
+import { useScheduledExportDialogValidity } from "../state/useScheduledExportDialogValidity.js";
+import { DefaultLoadingScheduledEmailDialog } from "./DefaultLoadingScheduledEmailDialog.js";
+const overlayController = OverlayController.getInstance(DASHBOARD_DIALOG_OVERS_Z_INDEX);
+/**
+ * The scheduled-export dialog's chrome, connected to the dialog's state: the modal overlay, the dialog
+ * frame with the header row (the back button and the title input) and the action bar, the General and
+ * Filters tabs, the scrollable content area around the selected tab's content, the body's error and
+ * validation messages, the stale-filters confirmation step shown before the dialog when the saved filters
+ * or schedule timezone no longer match the dashboard, and the delete confirmation reached from the
+ * action bar in edit mode. While `useScheduledEmailDialogContext().isLoading` is true — on scheduled
+ * email the ordinary path while a widget export's filters load — it renders the loading skeleton and
+ * none of its children.
+ *
+ * The default dialog is `<ScheduledEmailDialogShell>` around the region blocks and form; a custom
+ * `ScheduledEmailDialogComponent` that keeps this chrome and arranges the blocks differently renders the
+ * shell itself. The shell does not own the save: call {@link useSaveScheduledEmailToBackend} and pass its
+ * `handleSaveScheduledEmail`, `isSavingScheduledEmail` and `savingErrorMessage`; build Enter handlers for
+ * the blocks you place with {@link useScheduledEmailSubmitOnEnter} over the same `handleSaveScheduledEmail`.
+ * Call that hook only once `useScheduledEmailDialogContext().isLoading` is false — the state hooks throw
+ * while the dialog loads — and render the shell alone (any `onSubmit`, `isSaving: false`) until then, as
+ * the example does.
+ *
+ * Needs an ambient `IntlProvider`; inside a `Dashboard` the dashboard's provider covers it.
+ *
+ * @example
+ * ```tsx
+ * function MyScheduledEmailDialog(props: IScheduledEmailDialogProps) {
+ *     const { isLoading } = useScheduledEmailDialogContext();
+ *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     if (isLoading) {
+ *         return <ScheduledEmailDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
+ *     }
+ *     return <MyScheduledEmailDialogBody {...props} />;
+ * }
+ *
+ * function MyScheduledEmailDialogBody(props: IScheduledEmailDialogProps) {
+ *     const { handleSaveScheduledEmail, isSavingScheduledEmail, savingErrorMessage } =
+ *         useSaveScheduledEmailToBackend(props);
+ *     const submitOnEnter = useScheduledEmailSubmitOnEnter({
+ *         onSubmit: handleSaveScheduledEmail,
+ *         isSaving: isSavingScheduledEmail,
+ *     });
+ *     return (
+ *         <ScheduledEmailDialogShell
+ *             {...props}
+ *             onSubmit={handleSaveScheduledEmail}
+ *             isSaving={isSavingScheduledEmail}
+ *             savingErrorMessage={savingErrorMessage}
+ *         >
+ *             <ScheduledEmailDialogDestination />
+ *             <ScheduledEmailDialogRecipients onKeyDownSubmit={submitOnEnter} />
+ *         </ScheduledEmailDialogShell>
+ *     );
+ * }
+ * ```
+ *
+ * @alpha
+ */
+export function ScheduledEmailDialogShell(props) {
+    const { isLoading, scheduledExportToEdit } = useScheduledEmailDialogContext();
+    if (isLoading) {
+        return (_jsx(DefaultLoadingScheduledEmailDialog, { onCancel: props.onCancel, scheduledExportToEdit: scheduledExportToEdit }));
+    }
+    return _jsx(LoadedScheduledEmailDialogShell, { ...props });
+}
+function LoadedScheduledEmailDialogShell({ onBack, onCancel, onDeleteSuccess, onDeleteError, onSubmit, isSaving, savingErrorMessage, slots, topContent, bottomContent, children, filtersTabContent, }) {
+    const HeaderSlot = slots?.Header;
+    const FiltersSlot = slots?.Filters;
+    const ActionBarSlot = slots?.ActionBar;
+    const intl = useIntl();
+    const dialogTitleRef = useRef(null);
+    const generalTabContentRef = useRef(null);
+    const [scheduledEmailToDelete, setScheduledEmailToDelete] = useState(null);
+    const [selectedTabId, setSelectedTabId] = useState("general");
+    const { tabIds } = useAutomationsContext();
+    const { widget } = useScheduledEmailDialogContext();
+    const handleScheduleDeleteSuccess = () => {
+        onDeleteSuccess?.();
+        setScheduledEmailToDelete(null);
+    };
+    const { editedAutomation, scheduleTimezoneIsStale } = useScheduledExportDraft();
+    const { applyCurrentScheduleTimezone } = useScheduledExportActions();
+    const { onApplyCurrentFilters, automationIsValid, applyLatest: applyLatestParameters, } = useScheduledExportFilters();
+    const { selectedAttachments } = useScheduledExportAttachments();
+    const { validationErrorMessage } = useScheduledExportDialogValidity();
+    // a stale schedule timezone repairs through the same consent dialog as stale filters
+    const [isApplyCurrentFiltersDialogOpen, setIsApplyCurrentFiltersDialogOpen] = useState(!automationIsValid || scheduleTimezoneIsStale);
+    const { returnFocusTo } = useScheduleEmailDialogAccessibility();
+    const missingAttachmentsErrorMessage = selectedAttachments.length === 0 &&
+        intl.formatMessage({ id: "scheduledEmail.attachments.error.noAttachmentsSelected" });
+    const validationContextValue = useValidationContextValue(createInvalidNode({ id: "ScheduledEmailDialog" }));
+    const { getInvalidDatapoints } = validationContextValue;
+    const errorMessage = savingErrorMessage ?? validationErrorMessage ?? missingAttachmentsErrorMessage;
+    const titleElementId = useIdPrefixed("title");
+    const submitOnEnter = useScheduledEmailSubmitOnEnter({ onSubmit, isSaving });
+    const actionBarDefaultProps = useScheduledEmailDialogActionBarProps({
+        onCancel,
+        onSubmit,
+        isSaving,
+        onDelete: () => setScheduledEmailToDelete(editedAutomation),
+    });
+    const headerDefaultProps = useScheduledEmailDialogHeaderProps({
+        onBack,
+        onTitleKeyDown: submitOnEnter,
+        ref: dialogTitleRef,
+    });
+    const filtersDefaultProps = useScheduledEmailDialogFiltersProps();
+    const tabs = useMemo(() => [
+        {
+            id: "general",
+            label: intl.formatMessage({ id: "dialogs.schedule.email.tabs.general" }),
+        },
+        {
+            id: "filters",
+            label: intl.formatMessage({ id: "dialogs.schedule.email.tabs.filters" }),
+        },
+    ], [intl]);
+    const handleTabSelect = useCallback((tab) => {
+        setSelectedTabId(tab.id);
+    }, []);
+    // Measure General tab content height to maintain consistent dialog size. Re-measures on
+    // content-size changes within the General tab itself (e.g. validation messages
+    // appearing/disappearing), not just on tab switch - otherwise the Filters tab could
+    // inherit a stale minHeight from before the change. The last measured value is kept
+    // internally so it survives the General tab unmounting when the user switches to Filters.
+    const tabContentHeight = useElementHeightSnapshot(generalTabContentRef, selectedTabId);
+    if (isApplyCurrentFiltersDialogOpen) {
+        return (_jsx(ApplyCurrentFiltersConfirmDialog, { automationType: "schedule", filtersChanged: !automationIsValid, timezoneChanged: scheduleTimezoneIsStale, onCancel: () => onCancel?.(), onEdit: () => {
+                // each repair only fixes its own staleness: a timezone-only repair must not
+                // replace intentionally snapshotted, still-valid filters (and vice versa)
+                if (!automationIsValid) {
+                    onApplyCurrentFilters();
+                    applyLatestParameters();
+                }
+                applyCurrentScheduleTimezone();
+                setIsApplyCurrentFiltersDialogOpen(false);
+            } }));
+    }
+    const filtersTab = filtersTabContent === undefined ? (FiltersSlot ? (_jsx(FiltersSlot, { Default: DefaultScheduledEmailDialogFilters, defaultProps: filtersDefaultProps })) : (_jsx(DefaultScheduledEmailDialogFilters, { ...filtersDefaultProps }))) : (filtersTabContent);
+    return (_jsxs(_Fragment, { children: [
+            _jsx(Overlay, { className: "gd-notifications-channels-dialog-overlay", isModal: true, positionType: "fixed", ensureVisibility: true, children: _jsx(OverlayControllerProvider, { overlayController: overlayController, children: _jsx(ValidationContextStore, { value: validationContextValue, children: _jsxs(ConfirmDialogBase, { className: "gd-notifications-channels-dialog s-gd-notifications-channels-dialog gd-dialog--wide gd-notifications-channels-dialog--wide", accessibilityConfig: {
+                                closeButton: {
+                                    ariaLabel: intl.formatMessage({
+                                        id: "dialogs.schedule.email.closeLabel",
+                                    }),
+                                },
+                                titleElementId,
+                                dialogId: SCHEDULED_EMAIL_DIALOG_ID,
+                            }, returnFocusTo: returnFocusTo, returnFocusAfterClose: false, footerRenderer: () => ActionBarSlot ? (_jsx(ActionBarSlot, { Default: DefaultAutomationDialogActionBar, defaultProps: actionBarDefaultProps })) : (_jsx(DefaultAutomationDialogActionBar, { ...actionBarDefaultProps })), isSubmitDisabled: actionBarDefaultProps.isSubmitDisabled, initialFocus: dialogTitleRef, submitOnEnterKey: false, onCancel: onCancel, onSubmit: actionBarDefaultProps.onSubmit, headline: undefined, headerLeftButtonRenderer: () => HeaderSlot ? (_jsx(HeaderSlot, { Default: DefaultScheduledEmailDialogHeader, defaultProps: headerDefaultProps })) : (_jsx(DefaultScheduledEmailDialogHeader, { ...headerDefaultProps })), children: [
+                                _jsx("h2", { className: "sr-only", id: titleElementId, children: intl.formatMessage({ id: "dialogs.schedule.email.accessibilityTitle" }) }), tabs.length > 1 ? (_jsx(UiTabs, { tabs: tabs, selectedTabId: selectedTabId, onTabSelect: handleTabSelect, size: "medium", accessibilityConfig: {
+                                        role: "tablist",
+                                        tabRole: "tab",
+                                        ariaLabel: intl.formatMessage({
+                                            id: "dialogs.schedule.email.accessibilityTitle",
+                                        }),
+                                    }, disableBottomBorder: true })) : null, _jsxs(ScrollablePanel, { className: cx("gd-notifications-channel-dialog-content-wrapper", {
+                                        "gd-notification-channel-dialog-with-automation-filters": true,
+                                        "gd-notification-channel-dialog-with-tabs": tabs.length > 1,
+                                    }), children: [topContent, _jsx("div", { className: "gd-divider-with-margin" }), selectedTabId === "filters" ? (_jsx("div", { className: "gd-schedule-dialog-tab-content", style: tabContentHeight
+                                                ? { minHeight: `${tabContentHeight}px` }
+                                                : undefined, children: filtersTab })) : (_jsxs("div", { ref: generalTabContentRef, className: "gd-schedule-dialog-tab-content", children: [!widget && tabIds.length > 1 ? (_jsx(Message, { type: "progress", className: "gd-schedule-dialog-tab-content-info", children: intl.formatMessage({
+                                                        id: "dialogs.schedule.email.tabs.info",
+                                                    }) })) : null, children, errorMessage ? (_jsx(Message, { type: "error", className: cx("gd-notifications-channels-dialog-error", {
+                                                        "gd-notifications-channels-dialog-error-scrollable": true,
+                                                    }), children: errorMessage })) : null, getInvalidDatapoints()
+                                                    .filter((invalidDatapoint) => invalidDatapoint.severity === "error")
+                                                    .map((invalidDatapoint) => (_jsx(Message, { id: invalidDatapoint.id, type: "error", className: cx("gd-notifications-channels-dialog-error", {
+                                                        "gd-notifications-channels-dialog-error-scrollable": true,
+                                                    }), children: invalidDatapoint.message }, invalidDatapoint.id)))] })), bottomContent] })
+                            ] }) }) }) }), scheduledEmailToDelete ? (_jsx(DeleteScheduleConfirmDialog, { scheduledEmail: scheduledEmailToDelete, onCancel: () => setScheduledEmailToDelete(null), onSuccess: handleScheduleDeleteSuccess, onError: onDeleteError })) : null] }));
+}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogSubject.d.ts

@@ -0,0 +1,16 @@
+import { type ReactElement } from "react";
+import { type IScheduledEmailDialogSubjectProps } from "../types.js";
+/**
+ * The scheduled-export dialog's subject field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogSubject} with the props of
+ * {@link useScheduledEmailDialogSubjectProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale. Pass `onKeyDownSubmit` to submit on Enter from the subject input — the
+ * default dialog passes its save action; without it Enter does nothing here. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true and for an in-platform notification channel
+ * (which has no e-mail subject), the same visibility the default dialog gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogSubject(props: Partial<IScheduledEmailDialogSubjectProps>): ReactElement;
+//# sourceMappingURL=ScheduledEmailDialogSubject.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogSubject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogSubject.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogSubject.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAK1C,OAAO,EAAE,KAAK,iCAAiC,EAAE,MAAM,aAAa,CAAC;AAMrE;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,CAAC,iCAAiC,CAAC,GAAG,YAAY,CAM3G"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogSubject.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DefaultScheduledEmailDialogSubject } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogSubject.js";
+import { useIsInPlatformChannel } from "../state/useIsInPlatformChannel.js";
+import { useScheduledEmailDialogSubjectProps } from "../state/useScheduledEmailDialogFieldProps.js";
+import { WhenScheduledEmailDialogLoaded } from "./WhenScheduledEmailDialogLoaded.js";
+const noop = () => { };
+/**
+ * The scheduled-export dialog's subject field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogSubject} with the props of
+ * {@link useScheduledEmailDialogSubjectProps}; every prop passed here replaces the hook's value for
+ * that prop wholesale. Pass `onKeyDownSubmit` to submit on Enter from the subject input — the
+ * default dialog passes its save action; without it Enter does nothing here. Renders nothing while
+ * `useScheduledEmailDialogContext().isLoading` is true and for an in-platform notification channel
+ * (which has no e-mail subject), the same visibility the default dialog gives the field.
+ *
+ * @alpha
+ */
+export function ScheduledEmailDialogSubject(props) {
+    return (_jsx(WhenScheduledEmailDialogLoaded, { children: _jsx(ConnectedScheduledEmailDialogSubject, { ...props }) }));
+}
+function ConnectedScheduledEmailDialogSubject({ onKeyDownSubmit, ...overrides }) {
+    const defaultProps = useScheduledEmailDialogSubjectProps({ onKeyDownSubmit: onKeyDownSubmit ?? noop });
+    const isInPlatformChannel = useIsInPlatformChannel();
+    if (isInPlatformChannel) {
+        return null;
+    }
+    return _jsx(DefaultScheduledEmailDialogSubject, { ...defaultProps, ...overrides });
+}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogWidgetAttachments.d.ts

@@ -0,0 +1,16 @@
+import { type ReactElement } from "react";
+import { type IScheduledEmailDialogWidgetAttachmentsProps } from "../types.js";
+/**
+ * The scheduled-export dialog's widget-attachments field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogWidgetAttachments} with the props of
+ * {@link useScheduledEmailDialogWidgetAttachmentsProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. Renders nothing while `useScheduledEmailDialogContext().isLoading`
+ * is true and when the dialog context has no `widget` (a dashboard schedule renders
+ * {@link ScheduledEmailDialogDashboardAttachments} instead), the same visibility the default dialog
+ * gives the field.
+ *
+ * @alpha
+ */
+export declare function ScheduledEmailDialogWidgetAttachments(props: Partial<IScheduledEmailDialogWidgetAttachmentsProps>): ReactElement;
+//# sourceMappingURL=ScheduledEmailDialogWidgetAttachments.d.ts.map

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogWidgetAttachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduledEmailDialogWidgetAttachments.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogWidgetAttachments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAK1C,OAAO,EAAE,KAAK,2CAA2C,EAAE,MAAM,aAAa,CAAC;AAI/E;;;;;;;;;;;GAWG;AACH,wBAAgB,qCAAqC,CACjD,KAAK,EAAE,OAAO,CAAC,2CAA2C,CAAC,GAC5D,YAAY,CAMd"}

package/esm/presentation/automations/scheduledEmail/blocks/ScheduledEmailDialogWidgetAttachments.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useScheduledEmailDialogContext } from "../../contexts/ScheduledEmailDialogContext.js";
+import { DefaultScheduledEmailDialogWidgetAttachments } from "../DefaultScheduledEmailDialog/components/DefaultScheduledEmailDialogWidgetAttachments.js";
+import { useScheduledEmailDialogWidgetAttachmentsProps } from "../state/useScheduledEmailDialogFieldProps.js";
+import { WhenScheduledEmailDialogLoaded } from "./WhenScheduledEmailDialogLoaded.js";
+/**
+ * The scheduled-export dialog's widget-attachments field, connected to the dialog's state.
+ *
+ * Renders {@link DefaultScheduledEmailDialogWidgetAttachments} with the props of
+ * {@link useScheduledEmailDialogWidgetAttachmentsProps}; every prop passed here replaces the hook's
+ * value for that prop wholesale. Renders nothing while `useScheduledEmailDialogContext().isLoading`
+ * is true and when the dialog context has no `widget` (a dashboard schedule renders
+ * {@link ScheduledEmailDialogDashboardAttachments} instead), the same visibility the default dialog
+ * gives the field.
+ *
+ * @alpha
+ */
+export function ScheduledEmailDialogWidgetAttachments(props) {
+    return (_jsx(WhenScheduledEmailDialogLoaded, { children: _jsx(ConnectedScheduledEmailDialogWidgetAttachments, { ...props }) }));
+}
+function ConnectedScheduledEmailDialogWidgetAttachments(overrides) {
+    const defaultProps = useScheduledEmailDialogWidgetAttachmentsProps();
+    const { widget } = useScheduledEmailDialogContext();
+    if (!widget) {
+        return null;
+    }
+    return _jsx(DefaultScheduledEmailDialogWidgetAttachments, { ...defaultProps, ...overrides });
+}

package/esm/presentation/automations/scheduledEmail/state/useIsInPlatformChannel.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whether the draft's selected notification channel delivers in-platform only.
+ * The subject and message fields hide for such a channel.
+ */
+export declare function useIsInPlatformChannel(): boolean;
+//# sourceMappingURL=useIsInPlatformChannel.d.ts.map

package/esm/presentation/automations/scheduledEmail/state/useIsInPlatformChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsInPlatformChannel.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/scheduledEmail/state/useIsInPlatformChannel.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAOhD"}