@gooddata/sdk-ui-dashboard 11.55.0-alpha.1 → 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,18 +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). A custom
- * `AlertingDialogComponent` that keeps our regions but owns the markup places the connected blocks
- * ({@link AlertingDialogFilters} 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":"AAkDA,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,aAAa,CAAC;AA6B/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,2CA6d7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;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,152 +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, UiIconButton, UiTooltip, 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 { DeleteAlertConfirmDialog } from "../DefaultAlertingManagementDialog/components/DeleteAlertConfirmDialog.js";
-import { useAlertActions } from "../state/AlertActionsContext.js";
-import { useAlertData } from "../state/AlertDataContext.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 { useAlertSelectedValues } from "../state/useAlertSelectedValues.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 { DefaultLoadingAlertingDialog } from "../blocks/DefaultLoadingAlertingDialog.js";
+import { useAlertingDialogDestinationProps, useAlertingDialogFiltersProps, useAlertingDialogRecipientsProps, } from "../state/useAlertingDialogRegionProps.js";
 import { useAlertSubmit } from "../state/useAlertSubmit.js";
-import { getValueSuffix } from "../utils/getters.js";
-import { isAnomalyDetection, isChangeOrDifferenceOperator } from "../utils/guards.js";
-import { AlertAttributeSelect } from "./components/AlertAttributeSelect.js";
-import { AlertComparisonOperatorSelect } from "./components/AlertComparisonOperatorSelect.js";
-//
-//
-import { AlertComparisonPeriodSelect } from "./components/AlertComparisonPeriodSelect.js";
-import { AlertGranularitySelect } from "./components/AlertGranularitySelect.js";
-import { AlertMeasureSelect } from "./components/AlertMeasureSelect.js";
-import { AlertSensitivitySelect } from "./components/AlertSensitivitySelect.js";
-import { AlertThresholdInput } from "./components/AlertThresholdInput.js";
-import { AlertTriggerIntervalSelect } from "./components/AlertTriggerIntervalSelect.js";
-import { AlertTriggerModeSelect } from "./components/AlertTriggerModeSelect.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";
-import { FormField } from "./FormField.js";
-import { useAlertThreshold } from "./hooks/useAlertThreshold.js";
-const OVERLAY_POSITION_TYPE = "sameAsTarget";
-const CLOSE_ON_PARENT_SCROLL = true;
-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 { features: { enableAlertOncePerInterval, enableAnomalyDetectionAlert, canUseAiAssistant: enableAiAssistant, }, catalogAttributes, catalogDateDatasets, allowHourlyRecurrence, } = useAutomationsContext();
-    const { alertToEdit, notificationChannels } = useAlertingDialogContext();
-    const [alertToDelete, setAlertToDelete] = useState(null);
-    const handleAlertDeleteSuccess = (alert) => {
-        onDeleteSuccess?.(alert);
-        setAlertToDelete(null);
-    };
-    const { editedAutomation, warningMessage } = useAlertDraft();
-    const { onMeasureChange, onAttributeChange, onComparisonOperatorChange, onRelativeOperatorChange, onAnomalyDetectionChange, onComparisonTypeChange, onTriggerModeChange, onTriggerIntervalChange, onSensitivityChange, onGranularityChange, setEditedAutomation, } = useAlertActions();
-    const { supportedMeasures, supportedAttributes, isResultLoading, getAttributeValues, getMetricValue } = useAlertData();
-    const { onApplyCurrentFilters, automationIsValid, filtersAreStale, dropStaleParameters } = useAlertFilters();
-    const { selectedMeasure, selectedComparisonOperator, selectedRelativeOperator, selectedAiOperator, selectedComparator, selectedSensitivity, selectedGranularity, selectedAttribute, selectedValue, } = useAlertSelectedValues();
-    const { value, onChange, onBlur, thresholdErrorMessage } = useAlertThreshold({
-        setEditedAutomation,
-        editedAutomation,
-        getMetricValue,
-        isNewAlert: !alertToEdit,
-        selectedRelativeOperator,
-        selectedMeasure,
-        selectedAttribute,
-        selectedValue,
-    });
-    const { validationErrorMessage, canChangeMeasure, 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(FormField, { label: intl.formatMessage({ id: "insightAlert.config.metric" }), htmlFor: "alert.measure", children: _jsx(AlertMeasureSelect, { selectedMeasure: selectedMeasure, onMeasureChange: onMeasureChange, measures: supportedMeasures, disabled: !canChangeMeasure, overlayPositionType: OVERLAY_POSITION_TYPE, id: "alert.measure", closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) }), supportedAttributes.filter((a) => a.type === "attribute").length > 0 && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.for" }), htmlFor: "alert.attribute", children: _jsx(AlertAttributeSelect, { id: "alert.attribute", disabled: !canChangeMeasure, selectedAttribute: selectedAttribute, selectedValue: selectedValue, onAttributeChange: onAttributeChange, attributes: supportedAttributes, catalogAttributes: catalogAttributes, catalogDateDatasets: catalogDateDatasets, getAttributeValues: getAttributeValues, isResultLoading: isResultLoading, showLabel: false, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })), _jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.condition" }), htmlFor: "alert.condition", children: _jsx(AlertComparisonOperatorSelect, { id: "alert.condition", measure: selectedMeasure, enableAnomalyDetectionAlert: enableAnomalyDetectionAlert ? enableAiAssistant : false, selectedComparisonOperator: selectedComparisonOperator, selectedRelativeOperator: selectedRelativeOperator, selectedAiOperator: selectedAiOperator, onAnomalyDetectionChange: onAnomalyDetectionChange, onComparisonOperatorChange: onComparisonOperatorChange, onRelativeOperatorChange: onRelativeOperatorChange, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) }), !isAnomalyDetection(editedAutomation?.alert) && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.threshold" }), htmlFor: "alert.value", children: _jsx(AlertThresholdInput, { id: "alert.value", value: value, onChange: onChange, onBlur: onBlur, suffix: getValueSuffix(editedAutomation?.alert), errorMessage: thresholdErrorMessage }) })), isChangeOrDifferenceOperator(editedAutomation?.alert) && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.comparison" }), htmlFor: "alert.comparison", children: _jsx(AlertComparisonPeriodSelect, { id: "alert.comparison", measure: selectedMeasure, alert: editedAutomation, selectedComparison: selectedComparator?.comparator, selectedGranularity: selectedComparator?.granularity, onComparisonChange: (comparisonType, granularity) => {
-                                                            onComparisonTypeChange(selectedMeasure, selectedRelativeOperator, comparisonType, granularity);
-                                                        }, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })), isAnomalyDetection(editedAutomation?.alert) && (_jsxs(_Fragment, { children: [
-                                                        _jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.sensitivity" }), htmlFor: "alert.sensitivity", children: _jsx(AlertSensitivitySelect, { id: "alert.sensitivity", selectedSensitivity: selectedSensitivity, onSensitivityChange: onSensitivityChange, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) }), _jsx(FormField, { label: _jsxs("div", { className: "gd-dashboard-alerting-dialog-form-field__content-container-tooltip", children: [
-                                                                    _jsx(FormattedMessage, { id: "insightAlert.config.granularity" }), _jsx(UiTooltip, { anchor: _jsx(UiIconButton, { icon: "question", variant: "tertiary", size: "xsmall", accessibilityConfig: {
-                                                                                ariaLabel: intl.formatMessage({
-                                                                                    id: "insightAlert.config.granularity",
-                                                                                }),
-                                                                            } }), content: _jsx(FormattedMessage, { id: "insightAlert.config.granularity.tooltip" }), arrowPlacement: "left", optimalPlacement: true, offset: 10, width: 280, triggerBy: ["hover", "click"] })
-                                                                ] }), htmlFor: "alert.granularity", children: _jsx(AlertGranularitySelect, { id: "alert.granularity", allowHourlyRecurrence: allowHourlyRecurrence, selectedGranularity: selectedGranularity, onGranularityChange: (granularity) => {
-                                                                    onGranularityChange(selectedMeasure, granularity);
-                                                                }, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })
-                                                    ] }))] }), _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(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.trigger" }), htmlFor: "alert.trigger", children: _jsx(AlertTriggerModeSelect, { id: "alert.trigger", selectedTriggerMode: editedAutomation?.alert?.trigger.mode ?? "ALWAYS", onTriggerModeChange: onTriggerModeChange, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL, enableAlertOncePerInterval: enableAlertOncePerInterval }) }), editedAutomation?.alert?.trigger.mode === "ONCE_PER_INTERVAL" ? (_jsx(FormField, { label: _jsxs("div", { className: "gd-dashboard-alerting-dialog-form-field__content-container-tooltip", children: [
-                                                            _jsx(FormattedMessage, { id: "insightAlert.config.interval" }), _jsx(UiTooltip, { anchor: _jsx(UiIconButton, { icon: "question", variant: "tertiary", size: "xsmall", accessibilityConfig: {
-                                                                        ariaLabel: intl.formatMessage({
-                                                                            id: "insightAlert.config.interval",
-                                                                        }),
-                                                                    } }), content: _jsx(FormattedMessage, { id: "insightAlert.config.interval.tooltip" }), arrowPlacement: "left", optimalPlacement: true, offset: 10, width: 280, triggerBy: ["hover", "click"] })
-                                                        ] }), htmlFor: "alert.interval", children: _jsx(AlertTriggerIntervalSelect, { id: "alert.interval", selectedTriggerInterval: editedAutomation?.alert?.trigger.interval ?? "DAY", onTriggerIntervalChange: onTriggerIntervalChange, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })) : null, 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.
  *
@@ -164,13 +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). A custom
- * `AlertingDialogComponent` that keeps our regions but owns the markup places the connected blocks
- * ({@link AlertingDialogFilters} 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.
@@ -184,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/DefaultAlertingDialog/DefaultAlertingDialogAttribute.d.ts

@@ -0,0 +1,13 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogAttributeProps } from "../types.js";
+/**
+ * Default render of the alerting dialog's attribute field: the dropdown slicing the condition by an
+ * attribute value; renders nothing when the insight has no non-date attribute. Props-driven — the
+ * bare control without its label; reads no dialog context (only `useIntl`). The default dialog and
+ * {@link AlertingDialogAttribute} render it with {@link useAlertingDialogAttributeProps} inside
+ * {@link AutomationDialogFormField}.
+ *
+ * @alpha
+ */
+export declare function DefaultAlertingDialogAttribute({ id, disabled, selectedAttribute: selectedAttributeProp, getAttributeValues, isResultLoading, selectedValue, onAttributeChange, attributes, catalogAttributes, catalogDateDatasets, showLabel, closeOnParentScroll }: IAlertingDialogAttributeProps): ReactElement | null;
+//# sourceMappingURL=DefaultAlertingDialogAttribute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultAlertingDialogAttribute.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialogAttribute.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,YAAY,EAAkC,MAAM,OAAO,CAAC;AAkBjG,OAAO,EAAuB,KAAK,6BAA6B,EAAE,MAAM,aAAa,CAAC;AA2HtF;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAAC,EAC3C,EAAE,EACF,QAAQ,EACR,iBAAiB,EAAE,qBAAqB,EACxC,kBAAkB,EAClB,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,iBAAiB,EACjB,mBAAmB,EACnB,SAAgB,EAChB,mBAAmB,EACtB,EAAE,6BAA6B,GAAG,YAAY,GAAG,IAAI,CA8MrD"}

package/esm/presentation/automations/alerting/DefaultAlertingDialog/{components/AlertAttributeSelect.js → DefaultAlertingDialogAttribute.js}

@@ -3,9 +3,9 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { useCallback, useMemo, useState } from "react";
 import cx from "classnames";
 import { FormattedMessage, useIntl } from "react-intl";
-import { areObjRefsEqual, } from "@gooddata/sdk-model";
+import { areObjRefsEqual } from "@gooddata/sdk-model";
 import { Dropdown, DropdownButton, InvertableSelectSearchBar, Item, Separator, UiMenu, } from "@gooddata/sdk-ui-kit";
-import { getSelectedCatalogAttribute, getSelectedCatalogAttributeValue } from "../../utils/getters.js";
+import { getSelectedCatalogAttribute, getSelectedCatalogAttributeValue } from "../utils/getters.js";
 const createInteractiveItem = (id, title, attribute, value, isSelected, subItems) => ({
     type: "interactive",
     id,
@@ -50,7 +50,16 @@ function AttributeValuesSearchContent({ attribute, values, isSelected, selectedA
                     }, children: _jsx("div", { className: "gd-alert-attribute-select__menu-item s-menu-alert-attribute-item-value", children: (value.title ?? value.name) || `(${intl.formatMessage({ id: "empty_value" })})` }) }, index))) })
         ] }));
 }
-export function AlertAttributeSelect({ id, disabled, selectedAttribute: selectedAttributeProp, getAttributeValues, isResultLoading, selectedValue, onAttributeChange, attributes, catalogAttributes, catalogDateDatasets, showLabel = true, closeOnParentScroll, }) {
+/**
+ * Default render of the alerting dialog's attribute field: the dropdown slicing the condition by an
+ * attribute value; renders nothing when the insight has no non-date attribute. Props-driven — the
+ * bare control without its label; reads no dialog context (only `useIntl`). The default dialog and
+ * {@link AlertingDialogAttribute} render it with {@link useAlertingDialogAttributeProps} inside
+ * {@link AutomationDialogFormField}.
+ *
+ * @alpha
+ */
+export function DefaultAlertingDialogAttribute({ id, disabled, selectedAttribute: selectedAttributeProp, getAttributeValues, isResultLoading, selectedValue, onAttributeChange, attributes, catalogAttributes, catalogDateDatasets, showLabel = true, closeOnParentScroll, }) {
     const intl = useIntl();
     const availableAttributes = useMemo(() => {
         return attributes.filter((attr) => attr.type === "attribute");

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

@@ -0,0 +1,13 @@
+import { type ReactElement } from "react";
+import { type IAlertingDialogComparisonOperatorProps } from "../types.js";
+/**
+ * Default render of the alerting dialog's comparison-operator field: the dropdown selecting the
+ * condition's operator (fixed threshold, change, difference, anomaly detection); renders nothing
+ * without a measure. Props-driven — the bare control without its label; reads no dialog context
+ * (only `useIntl`). The default dialog and {@link AlertingDialogComparisonOperator} render it with
+ * {@link useAlertingDialogComparisonOperatorProps} inside {@link AutomationDialogFormField}.
+ *
+ * @alpha
+ */
+export declare function DefaultAlertingDialogComparisonOperator(props: IAlertingDialogComparisonOperatorProps): ReactElement | null;
+//# sourceMappingURL=DefaultAlertingDialogComparisonOperator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultAlertingDialogComparisonOperator.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialogComparisonOperator.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,YAAY,EAAU,MAAM,OAAO,CAAC;AAazE,OAAO,EAAE,KAAK,sCAAsC,EAAE,MAAM,aAAa,CAAC;AAiB1E;;;;;;;;GAQG;AACH,wBAAgB,uCAAuC,CACnD,KAAK,EAAE,sCAAsC,GAC9C,YAAY,GAAG,IAAI,CA6MrB"}