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

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

@@ -196,6 +196,14 @@ export function isGatedStringEntry(entry, isStringEnabled) {
 export function isGatedStringValue(value, isStringEnabled) {
     return typeof value === "string" && !isStringEnabled;
 }
+/**
+ * The tab's parameter entries without the gated-off STRING entries.
+ *
+ * @internal
+ */
+export function ungatedTabEntries(tab, isStringEnabled) {
+    return (tab.parameters?.parameters ?? parametersInitialState.parameters).filter((entry) => !isGatedStringEntry(entry, isStringEnabled));
+}
 /**
  * The insight-authored parameter values that pass the string gate — the single home of
  * insight-level gating for both the widget-execution hook path and the selector path.
@@ -371,58 +379,21 @@ export function computeParameterResetTargets(entries, workspaceParameters, isInE
     return result;
 }
 /**
- * Folds per-tab ref selections into the wire shape, dropping entries without a
- * `runtimeOverride`. Each selection pairs a tab with an optional ref restriction:
- * `allowedRefs === undefined` selects all refs (whole-dashboard scope); a defined set restricts
- * entries to those refs (widget scope). Tabs that yield no rows are omitted from the result.
+ * Folds the parameter entries of the given tabs into the wire shape, dropping entries without a
+ * `runtimeOverride`. Tabs that yield no rows are omitted from the result.
  *
  * @internal
  */
-export function collectExportOverrides(tabRefSelections, workspaceParameterByRef, isStringEnabled) {
+export function collectExportOverrides(tabs, workspaceParameterByRef, isStringEnabled) {
     const result = {};
-    for (const { tab, allowedRefs } of tabRefSelections) {
-        const entries = (tab.parameters?.parameters ?? parametersInitialState.parameters).filter((entry) => !isGatedStringEntry(entry, isStringEnabled));
-        const scoped = allowedRefs
-            ? entries.filter((entry) => allowedRefs.has(objRefToString(entry.parameter.ref)))
-            : entries;
-        const rows = formatEntries(scoped, workspaceParameterByRef);
+    for (const tab of tabs) {
+        const rows = formatEntries(ungatedTabEntries(tab, isStringEnabled), workspaceParameterByRef);
         if (rows.length > 0) {
             result[tab.localIdentifier] = rows;
         }
     }
     return Object.keys(result).length === 0 ? EMPTY_EXPORT_PARAMETERS_BY_TAB : result;
 }
-/**
- * Builds per-tab ref selections for a widget-scope export: each widget's owning tab is restricted
- * to refs referenced by the widget's insight metrics. Multiple widgets on the same tab union their
- * refs.
- *
- * @internal
- */
-export function buildWidgetScopeTabRefSelections(widgetContexts, widgetIds, insights, measureParameters) {
-    const byTab = new Map();
-    for (const widgetId of widgetIds) {
-        const context = widgetContexts.find((ctx) => ctx.widget.identifier === widgetId);
-        if (!context) {
-            continue;
-        }
-        const insight = insights.get(context.widget.insight);
-        if (!insight) {
-            continue;
-        }
-        const referencedRefs = collectReferencedParameterRefs(insight, measureParameters);
-        if (referencedRefs.length === 0) {
-            continue;
-        }
-        const tabId = context.tab.localIdentifier;
-        const existing = byTab.get(tabId) ?? { tab: context.tab, allowedRefs: new Set() };
-        for (const ref of referencedRefs) {
-            existing.allowedRefs.add(objRefToString(ref));
-        }
-        byTab.set(tabId, existing);
-    }
-    return [...byTab.values()];
-}
 function formatEntries(entries, workspaceParameterByRef) {
     const rows = [];
     for (const entry of entries) {

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

@@ -183,23 +183,21 @@ export declare const selectReferencedInsightParameterValuesForWidget: (ref: ObjR
  */
 export declare const selectEffectiveDashboardParametersForWidget: (ref: ObjRef | undefined) => DashboardSelector<IDashboardParameter[]>;
 /**
- * Returns the per-tab parameter overrides to send on dashboard tabular export, keyed by
- * tab `localIdentifier`. The shape matches the backend's `dashboardTabsParametersOverrides`
+ * Returns the per-tab parameter overrides to send on dashboard export, keyed by tab
+ * `localIdentifier`. The shape matches the backend's `dashboardTabsParametersOverrides`
  * field directly.
  *
  * @remarks
- * Scope rules:
- * - When `widgetIds` is empty/undefined (whole-dashboard export), every tab in scope contributes
- *   parameter entries with a `runtimeOverride`.
- * - When `widgetIds` is non-empty, each widget's owning tab contributes only entries with a
- *   `runtimeOverride` whose ref is referenced by the widget's insight metrics via the dashboard-wide
- *   metric → parameter dependency map. Multi-widget across distinct owning tabs yields one
- *   map entry per owning tab; entries for the same tab are unioned and deduplicated by ref.
+ * The request sends every `runtimeOverride` entry of each tab in scope; the query drops the
+ * parameters a widget's metrics do not use.
+ * - When `widgetIds` is empty/undefined (whole-dashboard export), every tab is in scope.
+ * - When `widgetIds` is non-empty, only the owning tabs of those widgets are in scope. Send only
+ *   these tabs. A non-empty map tells the backend that the map is complete, and the backend then
+ *   does not resolve pinned values for any tab.
  *
  * Returns `{}` (signalling "omit the field on the wire") when:
  * - `enableParameters` is off,
  * - the workspace catalog parameters are not loaded,
- * - (widget scope only) the `measureParameters` dependency map is not loaded,
  * - or no in-scope parameter has a `runtimeOverride`.
  *
  * @alpha

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

@@ -1 +1 @@
-{"version":3,"file":"parametersSelectors.d.ts","sourceRoot":"","sources":["../../../../../src/model/store/tabs/parameters/parametersSelectors.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"parametersSelectors.d.ts","sourceRoot":"","sources":["../../../../../src/model/store/tabs/parameters/parametersSelectors.ts"],"names":[],"mappings":"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"}

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

@@ -1,16 +1,16 @@
 // (C) 2026 GoodData Corporation
 import { createSelector } from "@reduxjs/toolkit";
-import { isEqual } from "lodash-es";
+import { isEqual, uniq } from "lodash-es";
 import { areObjRefsEqual, objRefToString, } from "@gooddata/sdk-model";
 import { createMemoizedSelector } from "../../_infra/selectors.js";
 import { selectCatalogMeasureParameters, selectCatalogMeasureParametersStatus, selectCatalogParameterByRef, selectCatalogParameters, selectCatalogParametersIsLoaded, } from "../../catalog/catalogSelectors.js";
 import { selectEnableParameters, selectEnableStringParameters } from "../../config/configSelectors.js";
 import { selectInsightsMap } from "../../insights/insightsSelectors.js";
 import { selectIsInEditMode } from "../../renderMode/renderModeSelectors.js";
-import { selectAllTabsInsightWidgetContexts } from "../layout/layoutSelectors.js";
+import { selectAllTabsInsightWidgetContexts, selectAllTabsWidgetContexts, } from "../layout/layoutSelectors.js";
 import { selectActiveOrDefaultTabLocalIdentifier, selectActiveTab, selectTabs } from "../tabsSelectors.js";
 import { DEFAULT_TAB_ID } from "../tabsState.js";
-import { EMPTY_EXPORT_PARAMETERS_BY_TAB, applyDisplayOverride, applyRuntimeOverride, buildPersistedByTabAndRef, buildWidgetScopeTabRefSelections, buildWorkspaceParametersByRef, classifyParameterReconciliation, collectExportOverrides, collectParameterReconciliations, collectReferencedParameterRefs, computeParameterResetTargets, computeParameterResetValue, displayOverride, isGatedStringEntry, resolveEffectiveParameterValuesForRefs, smartPersistResolvedEntry, ungatedInsightParameterValues, } from "./parametersHelpers.js";
+import { EMPTY_EXPORT_PARAMETERS_BY_TAB, applyDisplayOverride, applyRuntimeOverride, buildPersistedByTabAndRef, buildWorkspaceParametersByRef, classifyParameterReconciliation, collectExportOverrides, collectParameterReconciliations, collectReferencedParameterRefs, computeParameterResetTargets, computeParameterResetValue, displayOverride, isGatedStringEntry, resolveEffectiveParameterValuesForRefs, smartPersistResolvedEntry, ungatedInsightParameterValues, ungatedTabEntries, } from "./parametersHelpers.js";
 import { parametersInitialState, pickTabParametersSource, } from "./parametersState.js";
 const EMPTY_PARAMETERS = [];
 const EMPTY_EXPORT_PARAMETERS = [];
@@ -222,9 +222,7 @@ export const selectParameterReconciliations = createSelector(selectTabs, selectC
     if (!isEnabled || !isCatalogLoaded || !tabs) {
         return EMPTY_RECONCILIATIONS;
     }
-    const entries = tabs
-        .flatMap((tab) => tab.parameters?.parameters ?? [])
-        .filter((entry) => !isGatedStringEntry(entry, isStringEnabled));
+    const entries = tabs.flatMap((tab) => ungatedTabEntries(tab, isStringEnabled));
     const result = collectParameterReconciliations(entries, workspaceParameters);
     return result.length === 0 ? EMPTY_RECONCILIATIONS : result;
 });
@@ -254,9 +252,8 @@ export const selectWidgetParameterContext = createMemoizedSelector((ref) => crea
     if (!context) {
         return undefined;
     }
-    const entries = (context.tab.parameters?.parameters ?? parametersInitialState.parameters).filter((entry) => !isGatedStringEntry(entry, isStringEnabled));
     return {
-        entries,
+        entries: ungatedTabEntries(context.tab, isStringEnabled),
         measureParameters,
         workspaceParameterByRef,
         widgetInsightRef: context.widget.insight,
@@ -337,46 +334,39 @@ export const selectEffectiveDashboardParametersForWidget = createMemoizedSelecto
     return (owningTabEntries ?? parametersInitialState.parameters).map(applyRuntimeOverride);
 }));
 /**
- * Returns the per-tab parameter overrides to send on dashboard tabular export, keyed by
- * tab `localIdentifier`. The shape matches the backend's `dashboardTabsParametersOverrides`
+ * Returns the per-tab parameter overrides to send on dashboard export, keyed by tab
+ * `localIdentifier`. The shape matches the backend's `dashboardTabsParametersOverrides`
  * field directly.
  *
  * @remarks
- * Scope rules:
- * - When `widgetIds` is empty/undefined (whole-dashboard export), every tab in scope contributes
- *   parameter entries with a `runtimeOverride`.
- * - When `widgetIds` is non-empty, each widget's owning tab contributes only entries with a
- *   `runtimeOverride` whose ref is referenced by the widget's insight metrics via the dashboard-wide
- *   metric → parameter dependency map. Multi-widget across distinct owning tabs yields one
- *   map entry per owning tab; entries for the same tab are unioned and deduplicated by ref.
+ * The request sends every `runtimeOverride` entry of each tab in scope; the query drops the
+ * parameters a widget's metrics do not use.
+ * - When `widgetIds` is empty/undefined (whole-dashboard export), every tab is in scope.
+ * - When `widgetIds` is non-empty, only the owning tabs of those widgets are in scope. Send only
+ *   these tabs. A non-empty map tells the backend that the map is complete, and the backend then
+ *   does not resolve pinned values for any tab.
  *
  * Returns `{}` (signalling "omit the field on the wire") when:
  * - `enableParameters` is off,
  * - the workspace catalog parameters are not loaded,
- * - (widget scope only) the `measureParameters` dependency map is not loaded,
  * - or no in-scope parameter has a `runtimeOverride`.
  *
  * @alpha
  */
-export const selectExportEffectiveParameters = (widgetIds) => widgetIds?.length
-    ? selectExportEffectiveParametersForWidgets(widgetIds)
-    : selectExportEffectiveParametersDashboardScope;
-const selectExportEffectiveParametersDashboardScope = createSelector(selectTabs, selectEnableParameters, selectEnableStringParameters, selectWorkspaceParametersByRef, selectCatalogParametersIsLoaded, (tabs, isEnabled, isStringEnabled, workspaceParameterByRef, isCatalogLoaded) => {
-    if (!isEnabled || !isCatalogLoaded || !tabs?.length) {
+export const selectExportEffectiveParameters = createMemoizedSelector((widgetIds) => createSelector(selectTabs, selectAllTabsWidgetContexts, selectEnableParameters, selectEnableStringParameters, selectWorkspaceParametersByRef, selectCatalogParametersIsLoaded, (tabs, widgetContexts, isEnabled, isStringEnabled, workspaceParameterByRef, isCatalogLoaded) => {
+    if (!isEnabled || !isCatalogLoaded) {
         return EMPTY_EXPORT_PARAMETERS_BY_TAB;
     }
-    return collectExportOverrides(tabs.map((tab) => ({ tab })), workspaceParameterByRef, isStringEnabled);
-});
-const selectExportEffectiveParametersForWidgets = createMemoizedSelector((widgetIds) => createSelector(selectAllTabsInsightWidgetContexts, selectInsightsMap, selectEnableParameters, selectEnableStringParameters, selectWorkspaceParametersByRef, selectCatalogParametersIsLoaded, selectCatalogMeasureParameters, selectCatalogMeasureParametersStatus, (widgetContexts, insights, isEnabled, isStringEnabled, workspaceParameterByRef, isCatalogLoaded, measureParameters, measureParametersStatus) => {
-    if (!isEnabled || !isCatalogLoaded || measureParametersStatus !== "loaded") {
-        return EMPTY_EXPORT_PARAMETERS_BY_TAB;
-    }
-    const tabRefSelections = buildWidgetScopeTabRefSelections(widgetContexts, widgetIds, insights, measureParameters);
-    return collectExportOverrides(tabRefSelections, workspaceParameterByRef, isStringEnabled);
+    const scopedTabs = widgetIds?.length
+        ? uniq(widgetContexts
+            .filter((ctx) => widgetIds.includes(ctx.widget.identifier))
+            .map((ctx) => ctx.tab))
+        : (tabs ?? []);
+    return collectExportOverrides(scopedTabs, workspaceParameterByRef, isStringEnabled);
 }));
 /**
  * Active-tab slice of {@link selectExportEffectiveParameters}.
  *
  * @internal
  */
-export const selectActiveTabExportParameters = createSelector(selectExportEffectiveParametersDashboardScope, selectActiveOrDefaultTabLocalIdentifier, (parametersByTab, activeTabId) => parametersByTab[activeTabId] ?? EMPTY_EXPORT_PARAMETERS);
+export const selectActiveTabExportParameters = createSelector(selectExportEffectiveParameters(undefined), selectActiveOrDefaultTabLocalIdentifier, (parametersByTab, activeTabId) => parametersByTab[activeTabId] ?? EMPTY_EXPORT_PARAMETERS);

package/esm/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialog.d.ts

@@ -1,5 +1,5 @@
+import { type ReactElement } from "react";
 import { type IDefaultAlertingDialogProps } from "../types.js";
-export declare function AlertingDialogRenderer({ onCancel, onDeleteSuccess, onDeleteError, onError, onSuccess, onSaveError, onSaveSuccess, slots, topContent, bottomContent }: IDefaultAlertingDialogProps): import("react/jsx-runtime").JSX.Element;
 /**
  * Default implementation of the alerting create/edit dialog.
  *
@@ -17,25 +17,25 @@ export declare function AlertingDialogRenderer({ onCancel, onDeleteSuccess, onDe
  * that is what lets a wholesale replacement receive the same contexts. Rendering this component
  * outside those providers throws at runtime.
  *
- * The dialog is composed from the exported region renders — {@link DefaultAlertingDialogHeader},
- * {@link DefaultAlertingDialogFilters}, {@link DefaultAlertingDialogDestination},
- * {@link DefaultAlertingDialogRecipients}, {@link DefaultAutomationDialogActionBar} — fed by the
- * matching `use*Props` hooks ({@link useAlertingDialogFiltersProps} and siblings), and from the
- * connected field blocks — {@link AlertingDialogMeasure}, {@link AlertingDialogAttribute},
- * {@link AlertingDialogComparisonOperator}, {@link AlertingDialogThreshold},
- * {@link AlertingDialogComparisonPeriod}, {@link AlertingDialogSensitivity},
- * {@link AlertingDialogGranularity}, {@link AlertingDialogTriggerMode},
- * {@link AlertingDialogTriggerInterval} — each a labelled {@link AutomationDialogFormField} row; the
- * conditional ones (Attribute, Threshold, ComparisonPeriod, Sensitivity, Granularity, TriggerInterval)
- * gate themselves on the draft. A custom `AlertingDialogComponent` that keeps our regions and fields
- * but owns the markup places the connected blocks ({@link AlertingDialogFilters},
- * {@link AlertingDialogThreshold} and siblings) instead of this component, and reads or writes the
- * same draft through {@link useAlertDraft} and {@link useAlertActions}.
+ * The dialog is {@link AlertingDialogShell} — the chrome: overlay, frame, header row, action bar, the
+ * dialog's messages, the stale-filters and delete confirmation steps, the loading skeleton — around the
+ * exported region renders ({@link DefaultAlertingDialogFilters}, {@link DefaultAlertingDialogDestination},
+ * {@link DefaultAlertingDialogRecipients}, fed by {@link useAlertingDialogFiltersProps} and siblings; the
+ * header and action bar are the shell's) and the connected field blocks — {@link AlertingDialogMeasure},
+ * {@link AlertingDialogAttribute}, {@link AlertingDialogComparisonOperator}, {@link AlertingDialogThreshold},
+ * {@link AlertingDialogComparisonPeriod}, {@link AlertingDialogSensitivity}, {@link AlertingDialogGranularity},
+ * {@link AlertingDialogTriggerMode}, {@link AlertingDialogTriggerInterval} — grouped under the "When" and
+ * "Do" headings by {@link AlertingDialogFormFieldGroup}; each field is a labelled
+ * {@link AutomationDialogFormField} row and the conditional ones gate themselves on the draft. A custom
+ * `AlertingDialogComponent` that keeps this chrome but owns the arrangement renders
+ * {@link AlertingDialogShell} around the blocks it wants (see its example); one that owns the chrome too
+ * places the blocks in its own markup and reads or writes the same draft through {@link useAlertDraft} and
+ * {@link useAlertActions}.
  *
  * Slots render only in the fully rendered dialog: not while the dialog context reports loading,
  * and not while the stale-filters confirmation step is shown.
  *
  * @alpha
  */
-export declare function DefaultAlertingDialog(props: IDefaultAlertingDialogProps): import("react/jsx-runtime").JSX.Element;
+export declare function DefaultAlertingDialog(props: IDefaultAlertingDialogProps): ReactElement;
 //# sourceMappingURL=DefaultAlertingDialog.d.ts.map

package/esm/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DefaultAlertingDialog.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialog.tsx"],"names":[],"mappings":"AAsDA,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAW/D,wBAAgB,sBAAsB,CAAC,EACnC,QAAQ,EACR,eAAe,EACf,aAAa,EACb,OAAO,EACP,SAAS,EACT,WAAW,EACX,aAAa,EACb,KAAK,EACL,UAAU,EACV,aAAa,EAChB,EAAE,2BAA2B,2CAiO7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,2BAA2B,2CAcvE"}
+{"version":3,"file":"DefaultAlertingDialog.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialog.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AA2B1C,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAM/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,2BAA2B,GAAG,YAAY,CActF"}

package/esm/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialog.js

@@ -1,110 +1,26 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// (C) 2019-2026 GoodData Corporation
-import { useEffect, useRef, useState } from "react";
-import { FormattedMessage, useIntl } from "react-intl";
-import { ValidationContextStore, createInvalidDatapoint, createInvalidNode, useValidationContextValue, } from "@gooddata/sdk-ui";
-import { ConfirmDialogBase, ContentDivider, Message, Overlay, OverlayController, OverlayControllerProvider, ScrollablePanel, useId, } from "@gooddata/sdk-ui-kit";
-import { DASHBOARD_DIALOG_OVERS_Z_INDEX } from "../../../constants/zIndex.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { FormattedMessage } from "react-intl";
+import { ContentDivider } from "@gooddata/sdk-ui-kit";
 import { IntlWrapper } from "../../../localization/IntlWrapper.js";
 import { useAlertingDialogContext } from "../../contexts/AlertingDialogContext.js";
 import { useAutomationsContext } from "../../contexts/AutomationsContext.js";
-import { ApplyCurrentFiltersConfirmDialog } from "../../shared/automationFilters/components/ApplyLatestFiltersConfirmDialog.js";
-import { AutomationDialogFooterLeft, DefaultAutomationDialogActionBar, } from "../../shared/slots/DefaultAutomationDialogActionBar.js";
 import { AlertingDialogAttribute } from "../blocks/AlertingDialogAttribute.js";
 import { AlertingDialogComparisonOperator } from "../blocks/AlertingDialogComparisonOperator.js";
 import { AlertingDialogComparisonPeriod } from "../blocks/AlertingDialogComparisonPeriod.js";
+import { AlertingDialogFormFieldGroup } from "../blocks/AlertingDialogFormFieldGroup.js";
 import { AlertingDialogGranularity } from "../blocks/AlertingDialogGranularity.js";
 import { AlertingDialogMeasure } from "../blocks/AlertingDialogMeasure.js";
 import { AlertingDialogSensitivity } from "../blocks/AlertingDialogSensitivity.js";
+import { AlertingDialogShell } from "../blocks/AlertingDialogShell.js";
 import { AlertingDialogThreshold } from "../blocks/AlertingDialogThreshold.js";
 import { AlertingDialogTriggerInterval } from "../blocks/AlertingDialogTriggerInterval.js";
 import { AlertingDialogTriggerMode } from "../blocks/AlertingDialogTriggerMode.js";
-import { DeleteAlertConfirmDialog } from "../DefaultAlertingManagementDialog/components/DeleteAlertConfirmDialog.js";
-import { useAlertDraft } from "../state/AlertDraftContext.js";
-import { useAlertFilters } from "../state/AlertFiltersContext.js";
-import { useAlertDialogValidity } from "../state/useAlertDialogValidity.js";
-import { useAlertingDialogActionBarProps, useAlertingDialogDestinationProps, useAlertingDialogFiltersProps, useAlertingDialogHeaderProps, useAlertingDialogRecipientsProps, } from "../state/useAlertingDialogRegionProps.js";
+import { DefaultLoadingAlertingDialog } from "../blocks/DefaultLoadingAlertingDialog.js";
+import { useAlertingDialogDestinationProps, useAlertingDialogFiltersProps, useAlertingDialogRecipientsProps, } from "../state/useAlertingDialogRegionProps.js";
 import { useAlertSubmit } from "../state/useAlertSubmit.js";
-import { ALERTING_DIALOG_ID } from "./constants.js";
 import { DefaultAlertingDialogDestination } from "./DefaultAlertingDialogDestination.js";
 import { DefaultAlertingDialogFilters } from "./DefaultAlertingDialogFilters.js";
-import { DefaultAlertingDialogHeader } from "./DefaultAlertingDialogHeader.js";
 import { DefaultAlertingDialogRecipients } from "./DefaultAlertingDialogRecipients.js";
-import { DefaultLoadingAlertingDialog } from "./DefaultLoadingAlertingDialog.js";
-const overlayController = OverlayController.getInstance(DASHBOARD_DIALOG_OVERS_Z_INDEX);
-export function AlertingDialogRenderer({ onCancel, onDeleteSuccess, onDeleteError, onError, onSuccess, onSaveError, onSaveSuccess, slots, topContent, bottomContent, }) {
-    const HeaderSlot = slots?.Header;
-    const FiltersSlot = slots?.Filters;
-    const DestinationSlot = slots?.Destination;
-    const RecipientsSlot = slots?.Recipients;
-    const ActionBarSlot = slots?.ActionBar;
-    const intl = useIntl();
-    const dialogTitleRef = useRef(null);
-    const { alertToEdit, notificationChannels } = useAlertingDialogContext();
-    const [alertToDelete, setAlertToDelete] = useState(null);
-    const handleAlertDeleteSuccess = (alert) => {
-        onDeleteSuccess?.(alert);
-        setAlertToDelete(null);
-    };
-    const { warningMessage } = useAlertDraft();
-    const { onApplyCurrentFilters, automationIsValid, filtersAreStale, dropStaleParameters } = useAlertFilters();
-    const { validationErrorMessage, isInvalidConnectionToInsight } = useAlertDialogValidity();
-    const [isApplyCurrentFiltersDialogOpen, setIsApplyCurrentFiltersDialogOpen] = useState(!automationIsValid);
-    const { isSaving, submit } = useAlertSubmit({ onSuccess, onError, onSaveSuccess, onSaveError });
-    const headerDefaultProps = useAlertingDialogHeaderProps({ onCancel, ref: dialogTitleRef });
-    const filtersDefaultProps = useAlertingDialogFiltersProps();
-    const destinationDefaultProps = useAlertingDialogDestinationProps();
-    const recipientsDefaultProps = useAlertingDialogRecipientsProps();
-    const actionBarDefaultProps = useAlertingDialogActionBarProps({
-        onCancel,
-        onSubmit: () => void submit(),
-        isSaving,
-        onDelete: () => setAlertToDelete(alertToEdit),
-    });
-    const validationContextValue = useValidationContextValue(createInvalidNode({ id: "AlertingDialog" }));
-    const { setInvalidDatapoints, getInvalidDatapoints } = validationContextValue;
-    const invalidDatapoints = getInvalidDatapoints();
-    useEffect(() => {
-        setInvalidDatapoints(() => [
-            !!validationErrorMessage &&
-                createInvalidDatapoint({
-                    message: validationErrorMessage,
-                    severity: isInvalidConnectionToInsight ? "error" : "warning",
-                }),
-        ]);
-    }, [validationErrorMessage, isInvalidConnectionToInsight, setInvalidDatapoints]);
-    const titleElementId = useId();
-    if (isApplyCurrentFiltersDialogOpen) {
-        return (_jsx(ApplyCurrentFiltersConfirmDialog, { automationType: "alert", onCancel: () => onCancel?.(), onEdit: () => {
-                // Repair only what is actually stale: replace filters when they are invalid, and
-                // drop catalog-absent parameters. A valid saved filter set survives a param-only fix.
-                if (filtersAreStale) {
-                    onApplyCurrentFilters();
-                }
-                dropStaleParameters();
-                setIsApplyCurrentFiltersDialogOpen(false);
-            } }));
-    }
-    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", isPositive: true, cancelButtonText: actionBarDefaultProps.cancelButtonText, submitButtonText: actionBarDefaultProps.submitButtonText, accessibilityConfig: {
-                                closeButton: {
-                                    ariaLabel: intl.formatMessage({ id: "dialogs.alert.closeLabel" }),
-                                },
-                                titleElementId,
-                                dialogId: ALERTING_DIALOG_ID,
-                            }, showProgressIndicator: actionBarDefaultProps.isSaving, returnFocusAfterClose: false, footerLeftRenderer: ActionBarSlot
-                                ? undefined
-                                : () => (_jsx(AutomationDialogFooterLeft, { helpLinkText: actionBarDefaultProps.helpLinkText, helpLinkHref: actionBarDefaultProps.helpLinkHref, deleteButtonText: actionBarDefaultProps.deleteButtonText, onDelete: actionBarDefaultProps.onDelete, isDeleteDisabled: actionBarDefaultProps.isSaving })), footerRenderer: ActionBarSlot
-                                ? () => (_jsx(ActionBarSlot, { Default: DefaultAutomationDialogActionBar, defaultProps: actionBarDefaultProps }))
-                                : undefined, isSubmitDisabled: actionBarDefaultProps.isSubmitDisabled, submitButtonTooltipText: actionBarDefaultProps.submitButtonTooltipText, initialFocus: dialogTitleRef, submitOnEnterKey: false, onCancel: onCancel, onSubmit: actionBarDefaultProps.onSubmit, headline: undefined, headerLeftButtonRenderer: () => {
-                                return HeaderSlot ? (_jsx(HeaderSlot, { Default: DefaultAlertingDialogHeader, defaultProps: headerDefaultProps })) : (_jsx(DefaultAlertingDialogHeader, { ...headerDefaultProps }));
-                            }, children: [
-                                _jsx("h2", { className: "sr-only", id: titleElementId, children: intl.formatMessage({ id: "dialogs.alert.accessibility.label.title" }) }), _jsxs(ScrollablePanel, { className: "gd-notifications-channel-dialog-content-wrapper gd-notification-channel-dialog-with-automation-filters", children: [topContent, _jsx("div", { className: "gd-divider-with-margin" }), _jsxs(_Fragment, { children: [FiltersSlot ? (_jsx(FiltersSlot, { Default: DefaultAlertingDialogFilters, defaultProps: filtersDefaultProps })) : (_jsx(DefaultAlertingDialogFilters, { ...filtersDefaultProps })), _jsx(ContentDivider, { className: "gd-divider-with-margin" })
-                                            ] }), _jsxs(FormFieldGroup, { label: _jsx(FormattedMessage, { id: "insightAlert.config.when" }), children: [
-                                                _jsx(AlertingDialogMeasure, {}), _jsx(AlertingDialogAttribute, {}), _jsx(AlertingDialogComparisonOperator, {}), _jsx(AlertingDialogThreshold, {}), _jsx(AlertingDialogComparisonPeriod, {}), _jsx(AlertingDialogSensitivity, {}), _jsx(AlertingDialogGranularity, {})
-                                            ] }), _jsx(ContentDivider, { className: "gd-divider-with-margin" }), _jsxs(FormFieldGroup, { label: _jsx(FormattedMessage, { id: "insightAlert.config.do" }), children: [notificationChannels.length > 1 ? (DestinationSlot ? (_jsx(DestinationSlot, { Default: DefaultAlertingDialogDestination, defaultProps: destinationDefaultProps })) : (_jsx(DefaultAlertingDialogDestination, { ...destinationDefaultProps }))) : null, _jsx(AlertingDialogTriggerMode, {}), _jsx(AlertingDialogTriggerInterval, {}), RecipientsSlot ? (_jsx(RecipientsSlot, { Default: DefaultAlertingDialogRecipients, defaultProps: recipientsDefaultProps })) : (_jsx(DefaultAlertingDialogRecipients, { ...recipientsDefaultProps }))] }), warningMessage ? (_jsx(Message, { type: "warning", className: "gd-notifications-channels-dialog-error", children: warningMessage })) : null, invalidDatapoints.map((datapoint) => (_jsx(Message, { id: datapoint.id, type: datapoint.severity === "info" ? "progress" : datapoint.severity, className: "gd-notifications-channels-dialog-error gd-notifications-channels-dialog-error-scrollable", children: datapoint.message }, datapoint.id))), bottomContent] })
-                            ] }) }) }) }), alertToDelete ? (_jsx(DeleteAlertConfirmDialog, { alert: alertToDelete, onCancel: () => setAlertToDelete(null), onSuccess: handleAlertDeleteSuccess, onError: onDeleteError })) : null] }));
-}
 /**
  * Default implementation of the alerting create/edit dialog.
  *
@@ -122,20 +38,20 @@ export function AlertingDialogRenderer({ onCancel, onDeleteSuccess, onDeleteErro
  * that is what lets a wholesale replacement receive the same contexts. Rendering this component
  * outside those providers throws at runtime.
  *
- * The dialog is composed from the exported region renders — {@link DefaultAlertingDialogHeader},
- * {@link DefaultAlertingDialogFilters}, {@link DefaultAlertingDialogDestination},
- * {@link DefaultAlertingDialogRecipients}, {@link DefaultAutomationDialogActionBar} — fed by the
- * matching `use*Props` hooks ({@link useAlertingDialogFiltersProps} and siblings), and from the
- * connected field blocks — {@link AlertingDialogMeasure}, {@link AlertingDialogAttribute},
- * {@link AlertingDialogComparisonOperator}, {@link AlertingDialogThreshold},
- * {@link AlertingDialogComparisonPeriod}, {@link AlertingDialogSensitivity},
- * {@link AlertingDialogGranularity}, {@link AlertingDialogTriggerMode},
- * {@link AlertingDialogTriggerInterval} — each a labelled {@link AutomationDialogFormField} row; the
- * conditional ones (Attribute, Threshold, ComparisonPeriod, Sensitivity, Granularity, TriggerInterval)
- * gate themselves on the draft. A custom `AlertingDialogComponent` that keeps our regions and fields
- * but owns the markup places the connected blocks ({@link AlertingDialogFilters},
- * {@link AlertingDialogThreshold} and siblings) instead of this component, and reads or writes the
- * same draft through {@link useAlertDraft} and {@link useAlertActions}.
+ * The dialog is {@link AlertingDialogShell} — the chrome: overlay, frame, header row, action bar, the
+ * dialog's messages, the stale-filters and delete confirmation steps, the loading skeleton — around the
+ * exported region renders ({@link DefaultAlertingDialogFilters}, {@link DefaultAlertingDialogDestination},
+ * {@link DefaultAlertingDialogRecipients}, fed by {@link useAlertingDialogFiltersProps} and siblings; the
+ * header and action bar are the shell's) and the connected field blocks — {@link AlertingDialogMeasure},
+ * {@link AlertingDialogAttribute}, {@link AlertingDialogComparisonOperator}, {@link AlertingDialogThreshold},
+ * {@link AlertingDialogComparisonPeriod}, {@link AlertingDialogSensitivity}, {@link AlertingDialogGranularity},
+ * {@link AlertingDialogTriggerMode}, {@link AlertingDialogTriggerInterval} — grouped under the "When" and
+ * "Do" headings by {@link AlertingDialogFormFieldGroup}; each field is a labelled
+ * {@link AutomationDialogFormField} row and the conditional ones gate themselves on the draft. A custom
+ * `AlertingDialogComponent` that keeps this chrome but owns the arrangement renders
+ * {@link AlertingDialogShell} around the blocks it wants (see its example); one that owns the chrome too
+ * places the blocks in its own markup and reads or writes the same draft through {@link useAlertDraft} and
+ * {@link useAlertActions}.
  *
  * Slots render only in the fully rendered dialog: not while the dialog context reports loading,
  * and not while the stale-filters confirmation step is shown.
@@ -149,10 +65,19 @@ export function DefaultAlertingDialog(props) {
     if (isLoading) {
         return _jsx(DefaultLoadingAlertingDialog, { onCancel: onCancel, alertToEdit: alertToEdit });
     }
-    return (_jsx(IntlWrapper, { locale: locale, children: _jsx(AlertingDialogRenderer, { ...props }) }));
+    return (_jsx(IntlWrapper, { locale: locale, children: _jsx(DefaultAlertingDialogBody, { ...props }) }));
 }
-function FormFieldGroup({ label, children }) {
-    return (_jsxs("div", { className: "gd-input-component gd-input-component--no-last-child-margin gd-dashboard-alerting-dialog-form-field-group", children: [
-            _jsx("div", { className: "gd-dashboard-alerting-dialog-form-field-group__label-container", children: _jsx("label", { className: "gd-label gd-dashboard-alerting-dialog-form-field-group__label", children: label }) }), _jsx("div", { className: "gd-dashboard-alerting-dialog-form-field-group__content-container", children: children })
+function DefaultAlertingDialogBody({ onCancel, onDeleteSuccess, onDeleteError, onError, onSuccess, onSaveError, onSaveSuccess, slots, topContent, bottomContent, }) {
+    const FiltersSlot = slots?.Filters;
+    const DestinationSlot = slots?.Destination;
+    const RecipientsSlot = slots?.Recipients;
+    const { notificationChannels } = useAlertingDialogContext();
+    const { isSaving, submit } = useAlertSubmit({ onSuccess, onError, onSaveSuccess, onSaveError });
+    const filtersDefaultProps = useAlertingDialogFiltersProps();
+    const destinationDefaultProps = useAlertingDialogDestinationProps();
+    const recipientsDefaultProps = useAlertingDialogRecipientsProps();
+    return (_jsxs(AlertingDialogShell, { onCancel: onCancel, onDeleteSuccess: onDeleteSuccess, onDeleteError: onDeleteError, onSubmit: () => void submit(), isSaving: isSaving, slots: slots, topContent: topContent, bottomContent: bottomContent, children: [FiltersSlot ? (_jsx(FiltersSlot, { Default: DefaultAlertingDialogFilters, defaultProps: filtersDefaultProps })) : (_jsx(DefaultAlertingDialogFilters, { ...filtersDefaultProps })), _jsx(ContentDivider, { className: "gd-divider-with-margin" }), _jsxs(AlertingDialogFormFieldGroup, { label: _jsx(FormattedMessage, { id: "insightAlert.config.when" }), children: [
+                    _jsx(AlertingDialogMeasure, {}), _jsx(AlertingDialogAttribute, {}), _jsx(AlertingDialogComparisonOperator, {}), _jsx(AlertingDialogThreshold, {}), _jsx(AlertingDialogComparisonPeriod, {}), _jsx(AlertingDialogSensitivity, {}), _jsx(AlertingDialogGranularity, {})
+                ] }), _jsx(ContentDivider, { className: "gd-divider-with-margin" }), _jsxs(AlertingDialogFormFieldGroup, { label: _jsx(FormattedMessage, { id: "insightAlert.config.do" }), children: [notificationChannels.length > 1 ? (DestinationSlot ? (_jsx(DestinationSlot, { Default: DefaultAlertingDialogDestination, defaultProps: destinationDefaultProps })) : (_jsx(DefaultAlertingDialogDestination, { ...destinationDefaultProps }))) : null, _jsx(AlertingDialogTriggerMode, {}), _jsx(AlertingDialogTriggerInterval, {}), RecipientsSlot ? (_jsx(RecipientsSlot, { Default: DefaultAlertingDialogRecipients, defaultProps: recipientsDefaultProps })) : (_jsx(DefaultAlertingDialogRecipients, { ...recipientsDefaultProps }))] })
         ] }));
 }

package/esm/presentation/automations/alerting/blocks/AlertingDialogFormFieldGroup.d.ts

@@ -0,0 +1,10 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogFormFieldGroupProps } from "../types.js";
+/**
+ * A heading with a column of field rows under it — the default alerting dialog's "When" (the condition
+ * fields) and "Do" (the action fields) groups. Layout only; reads no dialog context.
+ *
+ * @alpha
+ */
+export declare function AlertingDialogFormFieldGroup({ label, children }: IAlertingDialogFormFieldGroupProps): ReactElement;
+//# sourceMappingURL=AlertingDialogFormFieldGroup.d.ts.map

package/esm/presentation/automations/alerting/blocks/AlertingDialogFormFieldGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogFormFieldGroup.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogFormFieldGroup.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAE1C,OAAO,EAAE,KAAK,kCAAkC,EAAE,MAAM,aAAa,CAAC;AAEtE;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,EACzC,KAAK,EACL,QAAQ,EACX,EAAE,kCAAkC,GAAG,YAAY,CAWnD"}

package/esm/presentation/automations/alerting/blocks/AlertingDialogFormFieldGroup.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * A heading with a column of field rows under it — the default alerting dialog's "When" (the condition
+ * fields) and "Do" (the action fields) groups. Layout only; reads no dialog context.
+ *
+ * @alpha
+ */
+export function AlertingDialogFormFieldGroup({ label, children, }) {
+    return (_jsxs("div", { className: "gd-input-component gd-input-component--no-last-child-margin gd-dashboard-alerting-dialog-form-field-group", children: [
+            _jsx("div", { className: "gd-dashboard-alerting-dialog-form-field-group__label-container", children: _jsx("label", { className: "gd-label gd-dashboard-alerting-dialog-form-field-group__label", children: label }) }), _jsx("div", { className: "gd-dashboard-alerting-dialog-form-field-group__content-container", children: children })
+        ] }));
+}

package/esm/presentation/automations/alerting/blocks/AlertingDialogShell.d.ts

@@ -0,0 +1,49 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogShellProps } from "../types.js";
+/**
+ * The alerting dialog's chrome, connected to the dialog's state: the modal overlay, the dialog frame
+ * with the header row (the title input) and the action bar, the scrollable content area around
+ * `children`, the dialog's warning and validation messages, the stale-filters confirmation step shown
+ * before the dialog when the saved filters no longer match the dashboard, and the delete confirmation
+ * reached from the action bar in edit mode. While `useAlertingDialogContext().isLoading` is true it
+ * renders the loading skeleton and none of its children.
+ *
+ * The default dialog is `<AlertingDialogShell>` around the region and field blocks; a custom
+ * `AlertingDialogComponent` that keeps this chrome and arranges the blocks differently renders the shell
+ * itself. The shell does not own the submit: call {@link useAlertSubmit} and pass its `submit` and
+ * `isSaving`, so the footer button and any Enter handler in the body share one instance. Call that hook
+ * only once `useAlertingDialogContext().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 MyAlertingDialog(props: IAlertingDialogProps) {
+ *     const { isLoading } = useAlertingDialogContext();
+ *     // the state hooks throw while the dialog loads; the shell renders the loading skeleton
+ *     if (isLoading) {
+ *         return <AlertingDialogShell {...props} onSubmit={() => {}} isSaving={false} />;
+ *     }
+ *     return <MyAlertingDialogBody {...props} />;
+ * }
+ *
+ * function MyAlertingDialogBody(props: IAlertingDialogProps) {
+ *     const { isSaving, submit } = useAlertSubmit(props);
+ *     return (
+ *         <AlertingDialogShell {...props} onSubmit={() => void submit()} isSaving={isSaving}>
+ *             <AlertingDialogFormFieldGroup label="When">
+ *                 <AlertingDialogMeasure />
+ *                 <AlertingDialogComparisonOperator />
+ *                 <AlertingDialogThreshold />
+ *             </AlertingDialogFormFieldGroup>
+ *             <AlertingDialogRecipients />
+ *         </AlertingDialogShell>
+ *     );
+ * }
+ * ```
+ *
+ * @alpha
+ */
+export declare function AlertingDialogShell(props: IAlertingDialogShellProps): ReactElement;
+//# sourceMappingURL=AlertingDialogShell.d.ts.map

package/esm/presentation/automations/alerting/blocks/AlertingDialogShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlertingDialogShell.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/blocks/AlertingDialogShell.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAA+B,MAAM,OAAO,CAAC;AAmCvE,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAM7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,yBAAyB,GAAG,YAAY,CAMlF"}