@gooddata/sdk-ui-dashboard 11.49.0-alpha.0 → 11.49.0

package/esm/__version.d.ts

@@ -1,4 +1,4 @@
-export declare const LIB_VERSION = "11.49.0-alpha.0";
+export declare const LIB_VERSION = "11.49.0";
 export declare const LIB_DESCRIPTION = "GoodData SDK - Dashboard Component";
 export declare const LIB_NAME = "@gooddata/sdk-ui-dashboard";
 //# sourceMappingURL=__version.d.ts.map

package/esm/__version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"__version.d.ts","sourceRoot":"","sources":["../src/__version.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,oBAAoB,CAAC;AAE7C,eAAO,MAAM,eAAe,uCAAuC,CAAC;AAEpE,eAAO,MAAM,QAAQ,+BAA+B,CAAC"}
+{"version":3,"file":"__version.d.ts","sourceRoot":"","sources":["../src/__version.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,YAAY,CAAC;AAErC,eAAO,MAAM,eAAe,uCAAuC,CAAC;AAEpE,eAAO,MAAM,QAAQ,+BAA+B,CAAC"}

package/esm/__version.js

@@ -1,5 +1,5 @@
 // (C) 2021 GoodData Corporation
 // DO NOT CHANGE THIS FILE, IT IS RE-GENERATED ON EVERY BUILD
-export const LIB_VERSION = "11.49.0-alpha.0";
+export const LIB_VERSION = "11.49.0";
 export const LIB_DESCRIPTION = "GoodData SDK - Dashboard Component";
 export const LIB_NAME = "@gooddata/sdk-ui-dashboard";

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

@@ -0,0 +1,64 @@
+import { type DateAttributeGranularity, type FilterContextItem, type IAlertAnomalyDetectionGranularity, type IAlertAnomalyDetectionSensitivity, type IAlertComparisonOperator, type IAlertRelativeArithmeticOperator, type IAlertRelativeOperator, type IAlertTriggerInterval, type IAlertTriggerMode, type IAutomationMetadataObject, type IAutomationMetadataObjectDefinition, type IAutomationRecipient, type IAutomationVisibleFilter, type IInsight, type INotificationChannelIdentifier, type INotificationChannelMetadataObject, type IWidget, type IWorkspaceUser } from "@gooddata/sdk-model";
+import { type AlertAttribute, type AlertMetric, type AlertMetricComparatorType } from "../../types.js";
+import { type IMeasureFormatMap } from "../utils/getters.js";
+/**
+ * Props for {@link useAlertFormState}.
+ * @internal
+ */
+export interface IUseAlertFormStateProps {
+    alertToEdit?: IAutomationMetadataObject;
+    insight?: IInsight;
+    widget?: IWidget;
+    notificationChannels: INotificationChannelIdentifier[] | INotificationChannelMetadataObject[];
+    users: IWorkspaceUser[];
+    editedAutomationFilters?: FilterContextItem[];
+    availableFiltersAsVisibleFilters?: IAutomationVisibleFilter[] | undefined;
+    externalRecipientOverride?: string;
+    supportedMeasures: AlertMetric[];
+    supportedAttributes: AlertAttribute[];
+    measureFormatMap: IMeasureFormatMap;
+}
+/**
+ * Owns the alerting dialog's editable state: the `editedAutomation` draft (initialized either
+ * from `alertToEdit` or via `createDefaultAlert`), its `originalAutomation` baseline, the
+ * automation's execution parameters, and the form's change-handlers and local UI state.
+ *
+ * Dashboard configuration (`weekStart`, `timezone`, `enableAlertOncePerInterval`, `currentUser`)
+ * is read from {@link useAutomationsContext} and {@link useAlertingDialogContext} rather than
+ * passed in as props. All other inputs are params, except `intl`, which is read via `useIntl()`.
+ *
+ * @internal
+ */
+export declare function useAlertFormState({ alertToEdit, insight, widget, notificationChannels, users, editedAutomationFilters, availableFiltersAsVisibleFilters, externalRecipientOverride, supportedMeasures, supportedAttributes, measureFormatMap }: IUseAlertFormStateProps): {
+    editedAutomation: IAutomationMetadataObjectDefinition | undefined;
+    setEditedAutomation: import("react").Dispatch<import("react").SetStateAction<IAutomationMetadataObjectDefinition | undefined>>;
+    originalAutomation: IAutomationMetadataObjectDefinition | undefined;
+    defaultUser: IWorkspaceUser;
+    defaultRecipient: IAutomationRecipient;
+    automationParameters: import("../../../shared/automationFilters/automationParameters.js").IAutomationParameter[];
+    availableParameters: import("../../../shared/automationFilters/automationParameters.js").IAutomationParameter[];
+    onParameterChange: (ref: import("@gooddata/sdk-model").IdentifierRef, value: string | number) => void;
+    onParameterDelete: (ref: import("@gooddata/sdk-model").IdentifierRef) => void;
+    onParameterAdd: (ref: import("@gooddata/sdk-model").IdentifierRef) => void;
+    dropStaleParameters: () => void;
+    onTitleChange: (value: string, isValid: boolean) => void;
+    onMeasureChange: (measure: AlertMetric) => void;
+    onAttributeChange: (attribute: AlertAttribute | undefined, value: {
+        title: string;
+        value: string;
+        name: string;
+    } | undefined) => void;
+    onComparisonOperatorChange: (measure: AlertMetric, comparisonOperator: IAlertComparisonOperator) => void;
+    onRelativeOperatorChange: (measure: AlertMetric, relativeOperator: IAlertRelativeOperator, arithmeticOperator: IAlertRelativeArithmeticOperator) => void;
+    onAnomalyDetectionChange: (measure: AlertMetric) => void;
+    onComparisonTypeChange: (measure: AlertMetric | undefined, relativeOperator: [IAlertRelativeOperator, IAlertRelativeArithmeticOperator] | undefined, comparisonType: AlertMetricComparatorType, granularity?: DateAttributeGranularity | undefined) => void;
+    onSensitivityChange: (sensitivity: IAlertAnomalyDetectionSensitivity) => void;
+    onTriggerIntervalChange: (triggerInterval: IAlertTriggerInterval, dirty?: boolean) => void;
+    onGranularityChange: (measure: AlertMetric | undefined, granularity: IAlertAnomalyDetectionGranularity) => void;
+    onDestinationChange: (destinationId: string) => void;
+    onTriggerModeChange: (triggerMode: IAlertTriggerMode) => void;
+    onRecipientsChange: (updatedRecipients: IAutomationRecipient[]) => void;
+    warningMessage: string | undefined;
+    isTitleValid: boolean;
+};
+//# sourceMappingURL=useAlertFormState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAlertFormState.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/hooks/useAlertFormState.ts"],"names":[],"mappings":"AAMA,OAAO,EACH,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,iCAAiC,EACtC,KAAK,iCAAiC,EACtC,KAAK,wBAAwB,EAC7B,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAC9B,KAAK,mCAAmC,EACxC,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,QAAQ,EAEb,KAAK,8BAA8B,EACnC,KAAK,kCAAkC,EACvC,KAAK,OAAO,EACZ,KAAK,cAAc,EACtB,MAAM,qBAAqB,CAAC;AAgB7B,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAEvG,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAY7D;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACpC,WAAW,CAAC,EAAE,yBAAyB,CAAC;IACxC,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,oBAAoB,EAAE,8BAA8B,EAAE,GAAG,kCAAkC,EAAE,CAAC;IAC9F,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,uBAAuB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAC9C,gCAAgC,CAAC,EAAE,wBAAwB,EAAE,GAAG,SAAS,CAAC;IAC1E,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,iBAAiB,EAAE,WAAW,EAAE,CAAC;IACjC,mBAAmB,EAAE,cAAc,EAAE,CAAC;IACtC,gBAAgB,EAAE,iBAAiB,CAAC;CACvC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,EAC9B,WAAW,EACX,OAAO,EACP,MAAM,EACN,oBAAoB,EACpB,KAAK,EACL,uBAAuB,EACvB,gCAAgC,EAChC,yBAAyB,EACzB,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EACnB,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkZzB"}

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

@@ -0,0 +1,221 @@
+// (C) 2026 GoodData Corporation
+import { useCallback, useState } from "react";
+import { useIntl } from "react-intl";
+import { useAlertingDialogContext } from "../../../contexts/AlertingDialogContext.js";
+import { useAutomationsContext } from "../../../contexts/AutomationsContext.js";
+import { setAlertExecutionParameters } from "../../../shared/automationFilters/automationParameters.js";
+import { useAutomationAlertParameters } from "../../../shared/automationFilters/useAutomationAlertParameters.js";
+import { getAppliedWidgetFilters, getVisibleFiltersByFilters, resolveMvfDimensionalityLocalRefs, } from "../../../shared/automationFilters/utils.js";
+import { convertCurrentUserToAutomationRecipient, convertCurrentUserToWorkspaceUser, convertExternalRecipientToAutomationRecipient, } from "../../../shared/utils/automationUtils.js";
+import { createDefaultAlert } from "../utils/convertors.js";
+import { transformAlertByAnomalyDetection, transformAlertByAttribute, transformAlertByComparisonOperator, transformAlertByDestination, transformAlertByGranularity, transformAlertByMetric, transformAlertByRelativeOperator, transformAlertBySensitivity, } from "../utils/transformation.js";
+/**
+ * Owns the alerting dialog's editable state: the `editedAutomation` draft (initialized either
+ * from `alertToEdit` or via `createDefaultAlert`), its `originalAutomation` baseline, the
+ * automation's execution parameters, and the form's change-handlers and local UI state.
+ *
+ * Dashboard configuration (`weekStart`, `timezone`, `enableAlertOncePerInterval`, `currentUser`)
+ * is read from {@link useAutomationsContext} and {@link useAlertingDialogContext} rather than
+ * passed in as props. All other inputs are params, except `intl`, which is read via `useIntl()`.
+ *
+ * @internal
+ */
+export function useAlertFormState({ alertToEdit, insight, widget, notificationChannels, users, editedAutomationFilters, availableFiltersAsVisibleFilters, externalRecipientOverride, supportedMeasures, supportedAttributes, measureFormatMap, }) {
+    const intl = useIntl();
+    const { weekStart, timezone, settings, currentUser, features: { enableAlertOncePerInterval }, } = useAutomationsContext();
+    const { dashboardId, hiddenFilters: dashboardHiddenFilters, commonDateFilterId, dashboardEvaluationFrequency, widgetLocalIdToTabIdMap: widgetTabMap, parameterValues, } = useAlertingDialogContext();
+    // Determine target tab ID if widget is present
+    const targetTabIdentifier = widget?.localIdentifier ? widgetTabMap[widget.localIdentifier] : undefined;
+    // Default values
+    const defaultMeasure = supportedMeasures[0];
+    const defaultUser = convertCurrentUserToWorkspaceUser(users ?? [], currentUser);
+    const defaultRecipient = externalRecipientOverride
+        ? convertExternalRecipientToAutomationRecipient(externalRecipientOverride)
+        : convertCurrentUserToAutomationRecipient(users ?? [], currentUser);
+    const defaultNotificationChannelId = notificationChannels[0]?.id;
+    const resolvedAlertToEdit = (() => {
+        if (!alertToEdit) {
+            return undefined;
+        }
+        const filters = alertToEdit.alert?.execution?.filters;
+        if (!alertToEdit.alert || !filters?.length || !insight) {
+            return alertToEdit;
+        }
+        const resolvedFilters = resolveMvfDimensionalityLocalRefs(filters, insight);
+        if (resolvedFilters === filters) {
+            return alertToEdit;
+        }
+        return {
+            ...alertToEdit,
+            alert: {
+                ...alertToEdit.alert,
+                execution: {
+                    ...alertToEdit.alert.execution,
+                    filters: resolvedFilters,
+                },
+            },
+        };
+    })();
+    const [editedAutomation, setEditedAutomation] = useState(() => {
+        if (resolvedAlertToEdit) {
+            return resolvedAlertToEdit;
+        }
+        const defaultNewAlert = createDefaultAlert(getAppliedWidgetFilters(editedAutomationFilters ?? [], dashboardHiddenFilters, widget, insight, commonDateFilterId, true, false), supportedMeasures, defaultMeasure, defaultNotificationChannelId, defaultRecipient, measureFormatMap, undefined, dashboardEvaluationFrequency
+            ? {
+                cron: dashboardEvaluationFrequency,
+                timezone: settings?.alertDefault?.defaultTimezone,
+            }
+            : undefined, getVisibleFiltersByFilters(editedAutomationFilters, availableFiltersAsVisibleFilters, true), widget?.localIdentifier, dashboardId, widget?.title, targetTabIdentifier);
+        return defaultNewAlert && parameterValues.length > 0
+            ? setAlertExecutionParameters(defaultNewAlert, parameterValues)
+            : defaultNewAlert;
+    });
+    const [originalAutomation] = useState(editedAutomation);
+    const { automationParameters, availableParameters, onParameterChange, onParameterDelete, onParameterAdd, dropStaleParameters, } = useAutomationAlertParameters({ editedAutomation, setEditedAutomation, widgetRef: widget?.ref });
+    // Local state
+    const [warningMessage, setWarningMessage] = useState(undefined);
+    const [isTitleValid, setIsTitleValid] = useState(true);
+    const [triggerIntervalDirty, setTriggerIntervalDirty] = useState(false);
+    //
+    // Handlers
+    //
+    const onTitleChange = (value, isValid) => {
+        setIsTitleValid(isValid);
+        setEditedAutomation((s) => (s ? { ...s, title: value } : undefined));
+    };
+    const onMeasureChange = useCallback((measure) => {
+        setEditedAutomation((alert) => alert
+            ? transformAlertByMetric(supportedMeasures, alert, measure, measureFormatMap, weekStart, timezone)
+            : undefined);
+    }, [setEditedAutomation, measureFormatMap, supportedMeasures, weekStart, timezone]);
+    const onAttributeChange = useCallback((attribute, value) => {
+        setEditedAutomation((alert) => alert
+            ? transformAlertByAttribute(supportedAttributes, alert, attribute, value)
+            : undefined);
+    }, [setEditedAutomation, supportedAttributes]);
+    const onComparisonOperatorChange = useCallback((measure, comparisonOperator) => {
+        setEditedAutomation((alert) => alert
+            ? transformAlertByComparisonOperator(supportedMeasures, alert, measure, comparisonOperator)
+            : undefined);
+    }, [setEditedAutomation, supportedMeasures]);
+    const onRelativeOperatorChange = useCallback((measure, relativeOperator, arithmeticOperator) => {
+        setEditedAutomation((alert) => alert
+            ? transformAlertByRelativeOperator(supportedMeasures, alert, measure, relativeOperator, arithmeticOperator, measureFormatMap)
+            : undefined);
+    }, [setEditedAutomation, measureFormatMap, supportedMeasures]);
+    const onAnomalyDetectionChange = useCallback((measure) => {
+        setTriggerIntervalDirty(false);
+        setEditedAutomation((alert) => alert
+            ? transformAlertByAnomalyDetection(supportedMeasures, alert, measure, weekStart, timezone, enableAlertOncePerInterval)
+            : undefined);
+    }, [setEditedAutomation, supportedMeasures, weekStart, timezone, enableAlertOncePerInterval]);
+    const onComparisonTypeChange = useCallback((measure, relativeOperator, comparisonType, granularity) => {
+        if (!measure || !relativeOperator || !relativeOperator) {
+            return;
+        }
+        const [relativeOperatorValue, arithmeticOperator] = relativeOperator;
+        setEditedAutomation((alert) => alert
+            ? transformAlertByRelativeOperator(supportedMeasures, alert, measure, relativeOperatorValue, arithmeticOperator, measureFormatMap, comparisonType, granularity)
+            : undefined);
+    }, [setEditedAutomation, measureFormatMap, supportedMeasures]);
+    const onSensitivityChange = useCallback((sensitivity) => {
+        setEditedAutomation((alert) => alert
+            ? transformAlertBySensitivity(alert, sensitivity)
+            : undefined);
+    }, [setEditedAutomation]);
+    const onTriggerIntervalChange = useCallback((triggerInterval, dirty = true) => {
+        setTriggerIntervalDirty(dirty);
+        setEditedAutomation((s) => s
+            ? {
+                ...s,
+                alert: {
+                    ...s.alert,
+                    trigger: { ...s.alert.trigger, interval: triggerInterval },
+                },
+            }
+            : undefined);
+    }, [setEditedAutomation]);
+    const onGranularityChange = useCallback((measure, granularity) => {
+        if (!measure) {
+            return;
+        }
+        setEditedAutomation((alert) => alert
+            ? transformAlertByGranularity(supportedMeasures, alert, measure, granularity, weekStart)
+            : undefined);
+        if (!triggerIntervalDirty) {
+            onTriggerIntervalChange(granularity === "HOUR" ? "DAY" : granularity, false);
+        }
+    }, [setEditedAutomation, onTriggerIntervalChange, supportedMeasures, triggerIntervalDirty, weekStart]);
+    const onDestinationChange = useCallback((destinationId) => {
+        const previousDestination = notificationChannels.find((channel) => alertToEdit?.notificationChannel === channel.id);
+        const selectedDestination = notificationChannels.find((channel) => destinationId === channel.id);
+        /**
+         * When allowed recipients are changed from "ALL" to "CREATOR", show warning message
+         */
+        const showWarningMessage = selectedDestination?.allowedRecipients === "creator" &&
+            previousDestination?.allowedRecipients !== "creator";
+        setWarningMessage(showWarningMessage
+            ? intl.formatMessage({ id: "insightAlert.config.warning.destination" })
+            : undefined);
+        /**
+         * Reset recipients when new notification channel only allows the author/creator
+         */
+        const updatedRecipients = selectedDestination?.allowedRecipients === "creator"
+            ? [convertCurrentUserToAutomationRecipient(users ?? [], currentUser)]
+            : undefined;
+        setEditedAutomation((alert) => alert
+            ? transformAlertByDestination(alert, destinationId, updatedRecipients)
+            : undefined);
+    }, [
+        setEditedAutomation,
+        alertToEdit?.notificationChannel,
+        currentUser,
+        notificationChannels,
+        intl,
+        users,
+    ]);
+    const onTriggerModeChange = useCallback((triggerMode) => {
+        setEditedAutomation((s) => s
+            ? {
+                ...s,
+                alert: { ...s.alert, trigger: { ...s.alert.trigger, mode: triggerMode } },
+            }
+            : undefined);
+    }, [setEditedAutomation]);
+    const onRecipientsChange = useCallback((updatedRecipients) => {
+        setEditedAutomation((s) => s
+            ? {
+                ...s,
+                recipients: updatedRecipients,
+            }
+            : undefined);
+    }, [setEditedAutomation]);
+    return {
+        editedAutomation,
+        setEditedAutomation,
+        originalAutomation,
+        defaultUser,
+        defaultRecipient,
+        automationParameters,
+        availableParameters,
+        onParameterChange,
+        onParameterDelete,
+        onParameterAdd,
+        dropStaleParameters,
+        onTitleChange,
+        onMeasureChange,
+        onAttributeChange,
+        onComparisonOperatorChange,
+        onRelativeOperatorChange,
+        onAnomalyDetectionChange,
+        onComparisonTypeChange,
+        onSensitivityChange,
+        onTriggerIntervalChange,
+        onGranularityChange,
+        onDestinationChange,
+        onTriggerModeChange,
+        onRecipientsChange,
+        warningMessage,
+        isTitleValid,
+    };
+}

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

@@ -1,5 +1,4 @@
-import { type DateAttributeGranularity, type FilterContextItem, type IAlertAnomalyDetectionGranularity, type IAlertAnomalyDetectionSensitivity, type IAlertComparisonOperator, type IAlertRelativeArithmeticOperator, type IAlertRelativeOperator, type IAlertTriggerInterval, type IAlertTriggerMode, type IAutomationMetadataObject, type IAutomationMetadataObjectDefinition, type IAutomationRecipient, type IAutomationVisibleFilter, type IInsight, type INotificationChannelIdentifier, type INotificationChannelMetadataObject, type IWidget, type IWorkspaceUser } from "@gooddata/sdk-model";
-import { type AlertAttribute, type AlertMetric, type AlertMetricComparatorType } from "../../types.js";
+import { type FilterContextItem, type IAutomationMetadataObject, type IAutomationVisibleFilter, type IInsight, type INotificationChannelIdentifier, type INotificationChannelMetadataObject, type IWidget, type IWorkspaceUser } from "@gooddata/sdk-model";
 export interface IUseEditAlertProps {
     alertToEdit?: IAutomationMetadataObject;
     notificationChannels: INotificationChannelIdentifier[] | INotificationChannelMetadataObject[];
@@ -15,7 +14,7 @@ export interface IUseEditAlertProps {
 }
 export declare function useEditAlert({ alertToEdit, notificationChannels, insight, widget, users, editedAutomationFilters, maxAutomationsRecipients, setEditedAutomationFilters, availableFiltersAsVisibleFilters, filtersForNewAutomation, externalRecipientOverride }: IUseEditAlertProps): {
     onTitleChange: (value: string, isValid: boolean) => void;
-    onRecipientsChange: (updatedRecipients: IAutomationRecipient[]) => void;
+    onRecipientsChange: (updatedRecipients: import("@gooddata/sdk-model").IAutomationRecipient[]) => void;
     onFiltersChange: (filters: FilterContextItem[]) => void;
     onApplyCurrentFilters: () => void;
     automationParameters: import("../../../shared/automationFilters/automationParameters.js").IAutomationParameter[];
@@ -24,46 +23,46 @@ export declare function useEditAlert({ alertToEdit, notificationChannels, insigh
     onParameterDelete: (ref: import("@gooddata/sdk-model").IdentifierRef) => void;
     onParameterAdd: (ref: import("@gooddata/sdk-model").IdentifierRef) => void;
     dropStaleParameters: () => void;
-    onMeasureChange: (measure: AlertMetric) => void;
+    onMeasureChange: (measure: import("../../types.js").AlertMetric) => void;
     getAttributeValues: (attr: import("@gooddata/sdk-model").IAttributeMetadataObject) => import("./useAttributeValuesFromExecResults.js").AttributeValue[];
-    onAttributeChange: (attribute: AlertAttribute | undefined, value: {
+    onAttributeChange: (attribute: import("../../types.js").AlertAttribute | undefined, value: {
         title: string;
         value: string;
         name: string;
     } | undefined) => void;
-    onComparisonOperatorChange: (measure: AlertMetric, comparisonOperator: IAlertComparisonOperator) => void;
-    onRelativeOperatorChange: (measure: AlertMetric, relativeOperator: IAlertRelativeOperator, arithmeticOperator: IAlertRelativeArithmeticOperator) => void;
-    onAnomalyDetectionChange: (measure: AlertMetric) => void;
-    onSensitivityChange: (sensitivity: IAlertAnomalyDetectionSensitivity) => void;
-    onGranularityChange: (measure: AlertMetric | undefined, granularity: IAlertAnomalyDetectionGranularity) => void;
+    onComparisonOperatorChange: (measure: import("../../types.js").AlertMetric, comparisonOperator: import("@gooddata/sdk-model").IAlertComparisonOperator) => void;
+    onRelativeOperatorChange: (measure: import("../../types.js").AlertMetric, relativeOperator: import("@gooddata/sdk-model").IAlertRelativeOperator, arithmeticOperator: import("@gooddata/sdk-model").IAlertRelativeArithmeticOperator) => void;
+    onAnomalyDetectionChange: (measure: import("../../types.js").AlertMetric) => void;
+    onSensitivityChange: (sensitivity: import("@gooddata/sdk-model").IAlertAnomalyDetectionSensitivity) => void;
+    onGranularityChange: (measure: import("../../types.js").AlertMetric | undefined, granularity: import("@gooddata/sdk-model").IAlertAnomalyDetectionGranularity) => void;
     onChange: (e: string | number, event?: import("react").ChangeEvent<HTMLInputElement> | undefined) => void;
     onBlur: (event: import("react").FocusEvent<HTMLInputElement, Element>) => void;
-    onComparisonTypeChange: (measure: AlertMetric | undefined, relativeOperator: [IAlertRelativeOperator, IAlertRelativeArithmeticOperator] | undefined, comparisonType: AlertMetricComparatorType, granularity?: DateAttributeGranularity | undefined) => void;
+    onComparisonTypeChange: (measure: import("../../types.js").AlertMetric | undefined, relativeOperator: [import("@gooddata/sdk-model").IAlertRelativeOperator, import("@gooddata/sdk-model").IAlertRelativeArithmeticOperator] | undefined, comparisonType: import("../../types.js").AlertMetricComparatorType, granularity?: import("@gooddata/sdk-model").DateAttributeGranularity | undefined) => void;
     onDestinationChange: (destinationId: string) => void;
-    onTriggerModeChange: (triggerMode: IAlertTriggerMode) => void;
-    onTriggerIntervalChange: (triggerInterval: IAlertTriggerInterval, dirty?: boolean) => void;
-    selectedMeasure: AlertMetric | undefined;
+    onTriggerModeChange: (triggerMode: import("@gooddata/sdk-model").IAlertTriggerMode) => void;
+    onTriggerIntervalChange: (triggerInterval: import("@gooddata/sdk-model").IAlertTriggerInterval, dirty?: boolean) => void;
+    selectedMeasure: import("../../types.js").AlertMetric | undefined;
     canChangeMeasure: boolean;
-    supportedMeasures: AlertMetric[];
-    selectedAttribute: AlertAttribute | undefined;
+    supportedMeasures: import("../../types.js").AlertMetric[];
+    selectedAttribute: import("../../types.js").AlertAttribute | undefined;
     selectedValue: string | null | undefined;
-    supportedAttributes: AlertAttribute[];
+    supportedAttributes: import("../../types.js").AlertAttribute[];
     catalogAttributes: import("@gooddata/sdk-model").ICatalogAttribute[];
     catalogDateDatasets: import("@gooddata/sdk-model").ICatalogDateDataset[];
     isResultLoading: boolean;
     isInvalidConnectionToInsight: "" | boolean | undefined;
     selectedAiOperator: "AI.ANOMALY_DETECTION" | undefined;
-    selectedSensitivity: IAlertAnomalyDetectionSensitivity | undefined;
-    selectedGranularity: IAlertAnomalyDetectionGranularity | undefined;
-    selectedComparisonOperator: IAlertComparisonOperator | undefined;
-    selectedRelativeOperator: [IAlertRelativeOperator, IAlertRelativeArithmeticOperator] | undefined;
+    selectedSensitivity: import("@gooddata/sdk-model").IAlertAnomalyDetectionSensitivity | undefined;
+    selectedGranularity: import("@gooddata/sdk-model").IAlertAnomalyDetectionGranularity | undefined;
+    selectedComparisonOperator: import("@gooddata/sdk-model").IAlertComparisonOperator | undefined;
+    selectedRelativeOperator: [import("@gooddata/sdk-model").IAlertRelativeOperator, import("@gooddata/sdk-model").IAlertRelativeArithmeticOperator] | undefined;
     value: number | undefined;
     selectedComparator: import("../../types.js").AlertMetricComparator | undefined;
     separators: import("@gooddata/sdk-model").ISeparators;
     warningMessage: string | undefined;
     defaultUser: IWorkspaceUser;
-    originalAutomation: IAutomationMetadataObjectDefinition | undefined;
-    editedAutomation: IAutomationMetadataObjectDefinition | undefined;
+    originalAutomation: import("@gooddata/sdk-model").IAutomationMetadataObjectDefinition | undefined;
+    editedAutomation: import("@gooddata/sdk-model").IAutomationMetadataObjectDefinition | undefined;
     allowOnlyLoggedUserRecipients: boolean;
     allowExternalRecipients: boolean;
     validationErrorMessage: string | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"useEditAlert.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/hooks/useEditAlert.ts"],"names":[],"mappings":"AAMA,OAAO,EACH,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,iCAAiC,EACtC,KAAK,iCAAiC,EACtC,KAAK,wBAAwB,EAC7B,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAC9B,KAAK,mCAAmC,EACxC,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,QAAQ,EAEb,KAAK,8BAA8B,EACnC,KAAK,kCAAkC,EACvC,KAAK,OAAO,EACZ,KAAK,cAAc,EACtB,MAAM,qBAAqB,CAAC;AAgB7B,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAmBvG,MAAM,WAAW,kBAAkB;IAC/B,WAAW,CAAC,EAAE,yBAAyB,CAAC;IACxC,oBAAoB,EAAE,8BAA8B,EAAE,GAAG,kCAAkC,EAAE,CAAC;IAC9F,wBAAwB,EAAE,MAAM,CAAC;IACjC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,uBAAuB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAE9C,0BAA0B,EAAE,CAAC,OAAO,EAAE,iBAAiB,EAAE,KAAK,IAAI,CAAC;IACnE,gCAAgC,CAAC,EAAE,wBAAwB,EAAE,GAAG,SAAS,CAAC;IAC1E,uBAAuB,EAAE,iBAAiB,EAAE,CAAC;IAC7C,yBAAyB,CAAC,EAAE,MAAM,CAAC;CACtC;AAED,wBAAgB,YAAY,CAAC,EACzB,WAAW,EACX,oBAAoB,EACpB,OAAO,EACP,MAAM,EACN,KAAK,EACL,uBAAuB,EACvB,wBAAwB,EACxB,0BAA0B,EAC1B,gCAAgC,EAChC,uBAAuB,EACvB,yBAAyB,EAC5B,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqepB"}
+{"version":3,"file":"useEditAlert.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/hooks/useEditAlert.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,QAAQ,EACb,KAAK,8BAA8B,EACnC,KAAK,kCAAkC,EACvC,KAAK,OAAO,EACZ,KAAK,cAAc,EACtB,MAAM,qBAAqB,CAAC;AAY7B,MAAM,WAAW,kBAAkB;IAC/B,WAAW,CAAC,EAAE,yBAAyB,CAAC;IACxC,oBAAoB,EAAE,8BAA8B,EAAE,GAAG,kCAAkC,EAAE,CAAC;IAC9F,wBAAwB,EAAE,MAAM,CAAC;IACjC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,uBAAuB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAE9C,0BAA0B,EAAE,CAAC,OAAO,EAAE,iBAAiB,EAAE,KAAK,IAAI,CAAC;IACnE,gCAAgC,CAAC,EAAE,wBAAwB,EAAE,GAAG,SAAS,CAAC;IAC1E,uBAAuB,EAAE,iBAAiB,EAAE,CAAC;IAC7C,yBAAyB,CAAC,EAAE,MAAM,CAAC;CACtC;AAED,wBAAgB,YAAY,CAAC,EACzB,WAAW,EACX,oBAAoB,EACpB,OAAO,EACP,MAAM,EACN,KAAK,EACL,uBAAuB,EACvB,wBAAwB,EACxB,0BAA0B,EAC1B,gCAAgC,EAChC,uBAAuB,EACvB,yBAAyB,EAC5B,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsLpB"}

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

@@ -1,77 +1,30 @@
 // (C) 2019-2026 GoodData Corporation
-import { useCallback, useState } from "react";
-import { useIntl } from "react-intl";
 import { useAlertingDialogContext } from "../../../contexts/AlertingDialogContext.js";
 import { useAutomationsContext } from "../../../contexts/AutomationsContext.js";
-import { setAlertExecutionParameters } from "../../../shared/automationFilters/automationParameters.js";
-import { useAutomationAlertParameters } from "../../../shared/automationFilters/useAutomationAlertParameters.js";
-import { getAppliedWidgetFilters, getVisibleFiltersByFilters, resolveMvfDimensionalityLocalRefs, } from "../../../shared/automationFilters/utils.js";
-import { convertCurrentUserToAutomationRecipient, convertCurrentUserToWorkspaceUser, convertExternalRecipientToAutomationRecipient, } from "../../../shared/utils/automationUtils.js";
-import { createDefaultAlert } from "../utils/convertors.js";
-import { transformAlertByAnomalyDetection, transformAlertByAttribute, transformAlertByComparisonOperator, transformAlertByDestination, transformAlertByGranularity, transformAlertByMetric, transformAlertByRelativeOperator, transformAlertBySensitivity, } from "../utils/transformation.js";
 import { useAlertFilters } from "./useAlertFilters.js";
+import { useAlertFormState } from "./useAlertFormState.js";
 import { useAlertFormValidation } from "./useAlertFormValidation.js";
 import { useAlertSelectedValues } from "./useAlertSelectedValues.js";
 import { useAlertSupportedMetrics } from "./useAlertSupportedMetrics.js";
 import { useAlertThreshold } from "./useAlertThreshold.js";
 export function useEditAlert({ alertToEdit, notificationChannels, insight, widget, users, editedAutomationFilters, maxAutomationsRecipients, setEditedAutomationFilters, availableFiltersAsVisibleFilters, filtersForNewAutomation, externalRecipientOverride, }) {
-    const intl = useIntl();
-    const { catalogDateDatasets, catalogAttributes, currentUser, separators, weekStart, timezone, settings, allowHourlyRecurrence, features: { enableAlertOncePerInterval }, } = useAutomationsContext();
+    const { catalogDateDatasets, catalogAttributes, separators, weekStart, timezone, allowHourlyRecurrence } = useAutomationsContext();
     const isInvalidConnectionToInsight = alertToEdit?.metadata?.widget && !insight;
-    const { dashboardId, hiddenFilters: dashboardHiddenFilters, commonDateFilterId, dashboardEvaluationFrequency, widgetLocalIdToTabIdMap: widgetTabMap, parameterValues, } = useAlertingDialogContext();
-    // Determine target tab ID if widget is present
-    const targetTabIdentifier = widget?.localIdentifier ? widgetTabMap[widget.localIdentifier] : undefined;
+    const { hiddenFilters: dashboardHiddenFilters, commonDateFilterId } = useAlertingDialogContext();
     const { measureFormatMap, supportedMeasures, supportedAttributes, isResultLoading, getAttributeValues, getMetricValue, } = useAlertSupportedMetrics({ insight, widget, alertToEdit });
-    // Default values
-    const defaultMeasure = supportedMeasures[0];
-    const defaultUser = convertCurrentUserToWorkspaceUser(users ?? [], currentUser);
-    const defaultRecipient = externalRecipientOverride
-        ? convertExternalRecipientToAutomationRecipient(externalRecipientOverride)
-        : convertCurrentUserToAutomationRecipient(users ?? [], currentUser);
-    const defaultNotificationChannelId = notificationChannels[0]?.id;
-    // Local state
-    const [warningMessage, setWarningMessage] = useState(undefined);
-    const [isTitleValid, setIsTitleValid] = useState(true);
-    const [triggerIntervalDirty, setTriggerIntervalDirty] = useState(false);
-    const resolvedAlertToEdit = (() => {
-        if (!alertToEdit) {
-            return undefined;
-        }
-        const filters = alertToEdit.alert?.execution?.filters;
-        if (!alertToEdit.alert || !filters?.length || !insight) {
-            return alertToEdit;
-        }
-        const resolvedFilters = resolveMvfDimensionalityLocalRefs(filters, insight);
-        if (resolvedFilters === filters) {
-            return alertToEdit;
-        }
-        return {
-            ...alertToEdit,
-            alert: {
-                ...alertToEdit.alert,
-                execution: {
-                    ...alertToEdit.alert.execution,
-                    filters: resolvedFilters,
-                },
-            },
-        };
-    })();
-    const [editedAutomation, setEditedAutomation] = useState(() => {
-        if (resolvedAlertToEdit) {
-            return resolvedAlertToEdit;
-        }
-        const defaultNewAlert = createDefaultAlert(getAppliedWidgetFilters(editedAutomationFilters ?? [], dashboardHiddenFilters, widget, insight, commonDateFilterId, true, false), supportedMeasures, defaultMeasure, defaultNotificationChannelId, defaultRecipient, measureFormatMap, undefined, dashboardEvaluationFrequency
-            ? {
-                cron: dashboardEvaluationFrequency,
-                timezone: settings?.alertDefault?.defaultTimezone,
-            }
-            : undefined, getVisibleFiltersByFilters(editedAutomationFilters, availableFiltersAsVisibleFilters, true), widget?.localIdentifier, dashboardId, widget?.title, targetTabIdentifier);
-        return defaultNewAlert && parameterValues.length > 0
-            ? setAlertExecutionParameters(defaultNewAlert, parameterValues)
-            : defaultNewAlert;
+    const { editedAutomation, setEditedAutomation, originalAutomation, defaultUser, defaultRecipient, automationParameters, availableParameters, onParameterChange, onParameterDelete, onParameterAdd, dropStaleParameters, onTitleChange, onMeasureChange, onAttributeChange, onComparisonOperatorChange, onRelativeOperatorChange, onAnomalyDetectionChange, onComparisonTypeChange, onSensitivityChange, onTriggerIntervalChange, onGranularityChange, onDestinationChange, onTriggerModeChange, onRecipientsChange, warningMessage, isTitleValid, } = useAlertFormState({
+        alertToEdit,
+        insight,
+        widget,
+        notificationChannels,
+        users,
+        editedAutomationFilters,
+        availableFiltersAsVisibleFilters,
+        externalRecipientOverride,
+        supportedMeasures,
+        supportedAttributes,
+        measureFormatMap,
     });
-    const [originalAutomation] = useState(editedAutomation);
-    const { automationParameters, availableParameters, onParameterChange, onParameterDelete, onParameterAdd, dropStaleParameters, } = useAutomationAlertParameters({ editedAutomation, setEditedAutomation, widgetRef: widget?.ref });
     //
     // Selected values
     //
@@ -81,104 +34,6 @@ export function useEditAlert({ alertToEdit, notificationChannels, insight, widge
         supportedAttributes,
         notificationChannels,
     });
-    //
-    // Handlers
-    //
-    const onTitleChange = (value, isValid) => {
-        setIsTitleValid(isValid);
-        setEditedAutomation((s) => (s ? { ...s, title: value } : undefined));
-    };
-    const onMeasureChange = useCallback((measure) => {
-        setEditedAutomation((alert) => alert
-            ? transformAlertByMetric(supportedMeasures, alert, measure, measureFormatMap, weekStart, timezone)
-            : undefined);
-    }, [measureFormatMap, supportedMeasures, weekStart, timezone]);
-    const onAttributeChange = useCallback((attribute, value) => {
-        setEditedAutomation((alert) => alert
-            ? transformAlertByAttribute(supportedAttributes, alert, attribute, value)
-            : undefined);
-    }, [supportedAttributes]);
-    const onComparisonOperatorChange = useCallback((measure, comparisonOperator) => {
-        setEditedAutomation((alert) => alert
-            ? transformAlertByComparisonOperator(supportedMeasures, alert, measure, comparisonOperator)
-            : undefined);
-    }, [supportedMeasures]);
-    const onRelativeOperatorChange = useCallback((measure, relativeOperator, arithmeticOperator) => {
-        setEditedAutomation((alert) => alert
-            ? transformAlertByRelativeOperator(supportedMeasures, alert, measure, relativeOperator, arithmeticOperator, measureFormatMap)
-            : undefined);
-    }, [measureFormatMap, supportedMeasures]);
-    const onAnomalyDetectionChange = useCallback((measure) => {
-        setTriggerIntervalDirty(false);
-        setEditedAutomation((alert) => transformAlertByAnomalyDetection(supportedMeasures, alert, measure, weekStart, timezone, enableAlertOncePerInterval));
-    }, [supportedMeasures, weekStart, timezone, enableAlertOncePerInterval]);
-    const onComparisonTypeChange = useCallback((measure, relativeOperator, comparisonType, granularity) => {
-        if (!measure || !relativeOperator || !relativeOperator) {
-            return;
-        }
-        const [relativeOperatorValue, arithmeticOperator] = relativeOperator;
-        setEditedAutomation((alert) => alert
-            ? transformAlertByRelativeOperator(supportedMeasures, alert, measure, relativeOperatorValue, arithmeticOperator, measureFormatMap, comparisonType, granularity)
-            : undefined);
-    }, [measureFormatMap, supportedMeasures]);
-    const onSensitivityChange = useCallback((sensitivity) => {
-        setEditedAutomation((alert) => transformAlertBySensitivity(alert, sensitivity));
-    }, []);
-    const onTriggerIntervalChange = useCallback((triggerInterval, dirty = true) => {
-        setTriggerIntervalDirty(dirty);
-        setEditedAutomation((s) => s
-            ? {
-                ...s,
-                alert: { ...s.alert, trigger: { ...s.alert.trigger, interval: triggerInterval } },
-            }
-            : undefined);
-    }, []);
-    const onGranularityChange = useCallback((measure, granularity) => {
-        if (!measure) {
-            return;
-        }
-        setEditedAutomation((alert) => transformAlertByGranularity(supportedMeasures, alert, measure, granularity, weekStart));
-        if (!triggerIntervalDirty) {
-            onTriggerIntervalChange(granularity === "HOUR" ? "DAY" : granularity, false);
-        }
-    }, [onTriggerIntervalChange, supportedMeasures, triggerIntervalDirty, weekStart]);
-    const onDestinationChange = useCallback((destinationId) => {
-        const previousDestination = notificationChannels.find((channel) => alertToEdit?.notificationChannel === channel.id);
-        const selectedDestination = notificationChannels.find((channel) => destinationId === channel.id);
-        /**
-         * When allowed recipients are changed from "ALL" to "CREATOR", show warning message
-         */
-        const showWarningMessage = selectedDestination?.allowedRecipients === "creator" &&
-            previousDestination?.allowedRecipients !== "creator";
-        setWarningMessage(showWarningMessage
-            ? intl.formatMessage({ id: "insightAlert.config.warning.destination" })
-            : undefined);
-        /**
-         * Reset recipients when new notification channel only allows the author/creator
-         */
-        const updatedRecipients = selectedDestination?.allowedRecipients === "creator"
-            ? [convertCurrentUserToAutomationRecipient(users ?? [], currentUser)]
-            : undefined;
-        setEditedAutomation((alert) => alert
-            ? transformAlertByDestination(alert, destinationId, updatedRecipients)
-            : undefined);
-    }, [alertToEdit?.notificationChannel, currentUser, notificationChannels, intl, users]);
-    const onTriggerModeChange = useCallback((triggerMode) => {
-        setEditedAutomation((s) => s
-            ? {
-                ...s,
-                alert: { ...s.alert, trigger: { ...s.alert.trigger, mode: triggerMode } },
-            }
-            : undefined);
-    }, []);
-    const onRecipientsChange = useCallback((updatedRecipients) => {
-        setEditedAutomation((s) => s
-            ? {
-                ...s,
-                recipients: updatedRecipients,
-            }
-            : undefined);
-    }, []);
     const { onFiltersChange, onApplyCurrentFilters } = useAlertFilters({
         setEditedAutomation,
         setEditedAutomationFilters,

package/esm/presentation/localization/bundles/de-DE.localization-bundle.d.ts

@@ -143,6 +143,8 @@ export declare const de_DE: {
     "filters.configurationPanel.userFilterSave.toggle.tooltip": string;
     "filters.configurationPanel.filterViews.toggle": string;
     "filters.configurationPanel.filterViews.toggle.tooltip": string;
+    "filters.configurationPanel.persistentFiltersAcrossTabs.toggle": string;
+    "filters.configurationPanel.persistentFiltersAcrossTabs.toggle.tooltip": string;
     "settingsDashboardDialog.sectionHeaders.dateDataset": string;
     "settingsDashboardDialog.sectionHeaders.dateDataset.tooltip": string;
     "dateDataset.autoSelect": string;

package/esm/presentation/localization/bundles/de-DE.localization-bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"de-DE.localization-bundle.d.ts","sourceRoot":"","sources":["../../../../src/presentation/localization/bundles/de-DE.localization-bundle.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAs2BjB,CAAC"}
+{"version":3,"file":"de-DE.localization-bundle.d.ts","sourceRoot":"","sources":["../../../../src/presentation/localization/bundles/de-DE.localization-bundle.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAw2BjB,CAAC"}

package/esm/presentation/localization/bundles/de-DE.localization-bundle.js

@@ -145,6 +145,8 @@ export const de_DE = {
     "filters.configurationPanel.userFilterSave.toggle.tooltip": "Automatisches Speichern des letzten Status der Filter zulassen. Wenn Benutzer zurückkehren, bleiben ihre Filter so, wie sie sie verlassen haben.",
     "filters.configurationPanel.filterViews.toggle": "Gespeicherte Ansichten",
     "filters.configurationPanel.filterViews.toggle.tooltip": "<p>Ermöglicht Benutzern, den Filterstatus als persönliche Ansicht zu speichern, zu der sie später zurückkehren können.</p><p>Nur der Benutzer, der die Ansicht gespeichert hat, kann darauf zugreifen und sie als Standardansicht festlegen.</p>",
+    "filters.configurationPanel.persistentFiltersAcrossTabs.toggle": "Persistente Filter über Tabs hinweg",
+    "filters.configurationPanel.persistentFiltersAcrossTabs.toggle.tooltip": "Persistente Filter über Tabs hinweg zulassen. Wenn aktiviert, bleiben Filter über Tabs hinweg erhalten.",
     "settingsDashboardDialog.sectionHeaders.dateDataset": "Datumsbereich in Beschreibungen",
     "settingsDashboardDialog.sectionHeaders.dateDataset.tooltip": "Datumsdatensatz, der vom Datumsbereichsfilter für Metrikreferenzen in Abschnittsbeschreibungen verwendet wird.",
     "dateDataset.autoSelect": "Automatische Auswahl",