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

package/esm/__version.d.ts

@@ -1,4 +1,4 @@
-export declare const LIB_VERSION = "11.48.0-alpha.2";
+export declare const LIB_VERSION = "11.48.0-alpha.3";
 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.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.48.0-alpha.2";
+export const LIB_VERSION = "11.48.0-alpha.3";
 export const LIB_DESCRIPTION = "GoodData SDK - Dashboard Component";
 export const LIB_NAME = "@gooddata/sdk-ui-dashboard";

package/esm/kdaDialog/composition/KdaAttributesDropdown.d.ts

@@ -0,0 +1,15 @@
+import { type ICatalogAttribute } from "@gooddata/sdk-model";
+import { type IKdaItemGroup } from "../internalTypes.js";
+export interface IKdaAttributesDropdownProps {
+    buttonLabel: string;
+    attributesCount: number;
+    validAttributes: ICatalogAttribute[];
+    initialAttributes: ICatalogAttribute[];
+    mapAttributes: Map<string, IKdaItemGroup | undefined>;
+    isSearchBarVisible: boolean;
+    onApply: (selected: ICatalogAttribute[]) => void;
+    onOpen: () => void;
+    onClose: () => void;
+}
+export declare function KdaAttributesDropdown({ buttonLabel, attributesCount, validAttributes, initialAttributes, mapAttributes, isSearchBarVisible, onApply, onOpen, onClose }: IKdaAttributesDropdownProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=KdaAttributesDropdown.d.ts.map

package/esm/kdaDialog/composition/KdaAttributesDropdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KdaAttributesDropdown.d.ts","sourceRoot":"","sources":["../../../src/kdaDialog/composition/KdaAttributesDropdown.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAW7D,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAYzD,MAAM,WAAW,2BAA2B;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,iBAAiB,EAAE,CAAC;IACrC,iBAAiB,EAAE,iBAAiB,EAAE,CAAC;IACvC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS,CAAC,CAAC;IACtD,kBAAkB,EAAE,OAAO,CAAC;IAC5B,OAAO,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,KAAK,IAAI,CAAC;IACjD,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,OAAO,EAAE,MAAM,IAAI,CAAC;CACvB;AAED,wBAAgB,qBAAqB,CAAC,EAClC,WAAW,EACX,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,kBAAkB,EAClB,OAAO,EACP,MAAM,EACN,OAAO,EACV,EAAE,2BAA2B,2CA0K7B"}

package/esm/kdaDialog/composition/KdaAttributesDropdown.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2025-2026 GoodData Corporation
+import { useId } from "react";
+import { FormattedMessage, useIntl } from "react-intl";
+import { Dropdown, InvertableSelectSearchBar, InvertableSelectVirtualised, SeparatorLine, UiButton, useIdPrefixed, } from "@gooddata/sdk-ui-kit";
+import { getAttributeKey, getAttributeTitle, useKdaAttributesSelection, } from "./hooks/useKdaAttributesSelection.js";
+import { KdaAttributesSelectItem } from "./KdaAttributesSelectItem.js";
+const ITEM_HEIGHT = 28;
+const ALIGN_POINTS = [{ align: "tl bl" }];
+export function KdaAttributesDropdown({ buttonLabel, attributesCount, validAttributes, initialAttributes, mapAttributes, isSearchBarVisible, onApply, onOpen, onClose, }) {
+    const intl = useIntl();
+    const labelKeyDriversId = useId();
+    const dropdownButtonId = useIdPrefixed("kda-attributes-dropdown-button");
+    const { searchString, setSearchString, selection, isInverted, filteredOptions, resolvedSelection, isApplyDisabled, onSelect, resetSelection, } = useKdaAttributesSelection(validAttributes, initialAttributes);
+    const popupLabel = intl.formatMessage({
+        id: "kdaDialog.dialog.keyDrives.overview.summary.drivers.popupLabel",
+    });
+    return (_jsx(Dropdown, { className: "gd-kda-attributes-dropdown", closeOnEscape: true, autofocusOnOpen: true, overlayPositionType: "sameAsTarget", alignPoints: ALIGN_POINTS, returnFocusTo: dropdownButtonId, onOpenStateChanged: (isOpen) => {
+            if (isOpen) {
+                resetSelection();
+                onOpen();
+            }
+            else {
+                onClose();
+            }
+        }, renderButton: ({ toggleDropdown, isOpen, buttonRef, dropdownId }) => (_jsx(UiButton, { id: dropdownButtonId, dataTestId: `${attributesCount}_attributes`, ref: buttonRef, variant: "tertiary", iconAfter: "settings", isSelected: isOpen, label: buttonLabel, onClick: toggleDropdown, accessibilityConfig: {
+                ariaHaspopup: "dialog",
+                ariaExpanded: isOpen,
+                ariaControls: isOpen ? dropdownId : undefined,
+            } })), renderBody: ({ closeDropdown, ariaAttributes }) => {
+            const handleApply = () => {
+                onApply(resolvedSelection);
+                closeDropdown();
+            };
+            return (_jsxs("div", { ...ariaAttributes, "aria-labelledby": undefined, "aria-label": popupLabel, className: "gd-kda-attributes-dropdown__body", children: [
+                    _jsx("div", { className: "gd-kda-attributes-dropdown__header", children: popupLabel }), _jsx(InvertableSelectVirtualised, { className: "gd-kda-attributes-select", adaptiveWidth: true, items: filteredOptions, totalItemsCount: filteredOptions.length, itemHeight: ITEM_HEIGHT, getItemKey: getAttributeKey, getItemTitle: getAttributeTitle, isItemQuestionMarkEnabled: () => false, isInverted: isInverted, selectedItems: selection, canSubmitOnKeyDown: !isApplyDisabled, onApplyButtonClick: handleApply, onSelect: onSelect, searchString: searchString, onSearch: setSearchString, renderItem: (itemProps) => {
+                            const group = mapAttributes.get(itemProps.item.attribute.id);
+                            const driverCount = group?.significantDrivers.length ?? 0;
+                            const count = driverCount > 0 ? `(${driverCount})` : "-";
+                            const countAriaLabel = driverCount > 0
+                                ? intl.formatMessage({
+                                    id: "kdaDialog.dialog.keyDrives.overview.summary.drivers.countLabel",
+                                }, { count: driverCount })
+                                : intl.formatMessage({
+                                    id: "kdaDialog.dialog.keyDrives.overview.summary.drivers.noDrivers",
+                                });
+                            return (_jsx(KdaAttributesSelectItem, { ...itemProps, right: _jsx("span", { className: "gd-kda-attributes-dropdown__key_drivers", "aria-label": countAriaLabel, children: count }) }));
+                        }, renderSearchBar: isSearchBarVisible
+                            ? ({ onSearch, searchString: search, searchPlaceholder }) => (_jsx(InvertableSelectSearchBar, { onSearch: onSearch, searchString: search, searchPlaceholder: searchPlaceholder, isSmall: true, onEscKeyPress: (e) => {
+                                    if (search) {
+                                        e.stopPropagation();
+                                    }
+                                    else {
+                                        closeDropdown();
+                                    }
+                                } }))
+                            : () => _jsx("div", { className: "gd-kda-attributes-dropdown__no-search" }), renderActions: () => (_jsxs("div", { className: "gd-kda-attributes-dropdown__subheader", children: [
+                                _jsx("div", { className: "gd-kda-attributes-dropdown__subheader__attribute", children: _jsx(FormattedMessage, { id: "kdaDialog.dialog.keyDrives.overview.detail.table.attribute" }) }), _jsx("div", { className: "gd-kda-attributes-dropdown__subheader__key_drivers", id: labelKeyDriversId, children: _jsx(FormattedMessage, { id: "kdaDialog.dialog.keyDrives.overview.detail.table.drivers" }) })
+                            ] })) }), _jsxs("div", { className: "gd-kda-attributes-dropdown__actions", children: [
+                            _jsx(SeparatorLine, {}), _jsxs("div", { className: "gd-kda-attributes-dropdown__actions-buttons", children: [
+                                    _jsx(UiButton, { variant: "secondary", size: "small", onClick: closeDropdown, label: intl.formatMessage({ id: "gs.list.cancel" }) }), _jsx(UiButton, { variant: "primary", size: "small", isDisabled: isApplyDisabled, onClick: handleApply, label: intl.formatMessage({ id: "gs.list.apply" }) })
+                                ] })
+                        ] })
+                ] }));
+        } }));
+}

package/esm/kdaDialog/composition/KdaAttributesSelectItem.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+export interface IKdaAttributesSelectItemProps<T> {
+    item: T;
+    title: string;
+    isSelected: boolean;
+    focusedAction?: string;
+    index?: number;
+    onSelect: () => void;
+    onDeselect: () => void;
+    onSelectOnly: () => void;
+    right?: ReactNode;
+}
+export declare function KdaAttributesSelectItem<T>({ item, title, isSelected, focusedAction, index, onSelect, onDeselect, onSelectOnly, right }: IKdaAttributesSelectItemProps<T>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=KdaAttributesSelectItem.d.ts.map

package/esm/kdaDialog/composition/KdaAttributesSelectItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KdaAttributesSelectItem.d.ts","sourceRoot":"","sources":["../../../src/kdaDialog/composition/KdaAttributesSelectItem.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAmB,KAAK,SAAS,EAAe,MAAM,OAAO,CAAC;AASrE,MAAM,WAAW,6BAA6B,CAAC,CAAC;IAC5C,IAAI,EAAE,CAAC,CAAC;IACR,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,KAAK,CAAC,EAAE,SAAS,CAAC;CACrB;AAED,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,EACvC,IAAI,EACJ,KAAK,EACL,UAAU,EACV,aAAa,EACb,KAAK,EACL,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,KAAK,EACR,EAAE,6BAA6B,CAAC,CAAC,CAAC,2CAkFlC"}

package/esm/kdaDialog/composition/KdaAttributesSelectItem.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2025-2026 GoodData Corporation
+import { useCallback } from "react";
+import cx from "classnames";
+import { FormattedMessage, useIntl } from "react-intl";
+import { SELECT_ITEM_ACTION, ScopedIdStore, UiLink } from "@gooddata/sdk-ui-kit";
+const ONLY_ACTION = "only";
+export function KdaAttributesSelectItem({ item, title, isSelected, focusedAction, index, onSelect, onDeselect, onSelectOnly, right, }) {
+    const intl = useIntl();
+    const makeId = ScopedIdStore.useContextStoreOptional((ctx) => ctx.makeId);
+    const onItemClick = useCallback(() => {
+        if (isSelected) {
+            onDeselect();
+        }
+        else {
+            onSelect();
+        }
+    }, [isSelected, onSelect, onDeselect]);
+    const onOnlyClick = useCallback((event) => {
+        event.stopPropagation();
+        onSelectOnly();
+    }, [onSelectOnly]);
+    const classes = cx("gd-kda-attributes-select-item", "gd-attribute-filter-elements-select-item__next", "gd-list-item", "has-only-visible", { "is-selected": isSelected }, {
+        "gd-attribute-filter-list-item--isFocused": !!focusedAction,
+        "gd-attribute-filter-list-item--isFocusedSelectItem": focusedAction === SELECT_ITEM_ACTION,
+    });
+    return (_jsxs("div", { className: classes, onClick: onItemClick, role: "row", tabIndex: -1, "aria-rowindex": index, "aria-label": title, children: [
+            _jsx("div", { role: "gridcell", className: "gd-attribute-filter-list-item-label", children: _jsxs("label", { className: "input-checkbox-label", children: [
+                        _jsx("input", { tabIndex: focusedAction === SELECT_ITEM_ACTION ? 0 : -1, id: makeId?.({ item, specifier: SELECT_ITEM_ACTION }), type: "checkbox", className: "input-checkbox", readOnly: true, checked: isSelected }), _jsx("span", { className: "input-label-text", children: title })
+                    ] }) }), _jsx("div", { className: cx("gd-list-item-only", {
+                    "gd-list-item-only--isFocusedSelectItem": focusedAction === ONLY_ACTION,
+                }), role: "gridcell", children: _jsx(UiLink, { onClick: onOnlyClick, id: makeId?.({ item, specifier: ONLY_ACTION }), variant: "primary", flipUnderline: true, role: "button", "aria-label": intl.formatMessage({ id: "attributesDropdown.onlyLabel" }, { itemTitle: title }), tabIndex: focusedAction === ONLY_ACTION ? 0 : -1, children: _jsx(FormattedMessage, { id: "gs.list.only" }) }) }), right ? (_jsx("div", { role: "gridcell", className: "gd-kda-attributes-select-item__right", children: right })) : null] }));
+}

package/esm/kdaDialog/composition/KeyDriversFooter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KeyDriversFooter.d.ts","sourceRoot":"","sources":["../../../src/kdaDialog/composition/KeyDriversFooter.tsx"],"names":[],"mappings":"AAkBA,wBAAgB,gBAAgB,mDAyM/B"}
+{"version":3,"file":"KeyDriversFooter.d.ts","sourceRoot":"","sources":["../../../src/kdaDialog/composition/KeyDriversFooter.tsx"],"names":[],"mappings":"AAgBA,wBAAgB,gBAAgB,mDA2E/B"}

package/esm/kdaDialog/composition/KeyDriversFooter.js

@@ -1,19 +1,16 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 // (C) 2025-2026 GoodData Corporation
-import { useId, useMemo } from "react";
-import { FormattedMessage, useIntl } from "react-intl";
+import { useCallback } from "react";
+import { FormattedMessage } from "react-intl";
 import { areObjRefsEqual } from "@gooddata/sdk-model";
-import { DropdownInvertableSelect, InvertableSelectItem, UiButton, UiSkeleton } from "@gooddata/sdk-ui-kit";
+import { UiSkeleton } from "@gooddata/sdk-ui-kit";
 import { useDashboardSelector } from "../../model/react/DashboardStoreProvider.js";
-import { selectCatalogAttributes, selectCatalogIsLoaded, } from "../../model/store/catalog/catalogSelectors.js";
-import { useSummaryDrivers } from "../hooks/useSummaryDrivers.js";
+import { selectCatalogIsLoaded } from "../../model/store/catalog/catalogSelectors.js";
 import { useKdaState } from "../providers/KdaState.js";
+import { useKdaValidAttributes } from "./hooks/useKdaValidAttributes.js";
+import { KdaAttributesDropdown } from "./KdaAttributesDropdown.js";
 export function KeyDriversFooter() {
     const { state, setState } = useKdaState();
-    const list = useSummaryDrivers();
-    const intl = useIntl();
-    const labelAttributeId = useId();
-    const labelKeyDriversId = useId();
     const isCatalogLoaded = useDashboardSelector(selectCatalogIsLoaded);
     const isLoading = !isCatalogLoaded ||
         state.itemsStatus === "pending" ||
@@ -21,34 +18,22 @@ export function KeyDriversFooter() {
         state.relevantStatus === "pending" ||
         state.relevantStatus === "loading";
     const isError = state.itemsStatus === "error";
-    const allAttributes = useDashboardSelector(selectCatalogAttributes);
-    const { validAttributes, mapAttributes } = useMemo(() => {
-        const mapAttributes = new Map();
-        const validAttributes = allAttributes
-            .filter((a) => {
-            return state.relevantAttributes.some((attr) => areObjRefsEqual(attr, a.attribute.ref));
-        })
-            .map((a) => {
-            const group = list.find((item) => a.displayForms.some((df) => areObjRefsEqual(df.ref, item.displayForm)));
-            mapAttributes.set(a.attribute.ref, group);
-            return [a, group];
-        })
-            .sort(([, a], [, b]) => {
-            const aIndex = a ? list.indexOf(a) : Number.MAX_VALUE;
-            const bIndex = b ? list.indexOf(b) : Number.MAX_VALUE;
-            return aIndex - bIndex;
-        })
-            .map(([a]) => a);
-        return { validAttributes, mapAttributes };
-    }, [allAttributes, list, state.relevantAttributes]);
-    const initialAttributes = useMemo(() => {
-        return state.selectedAttributes
-            .map((attr) => {
-            return validAttributes.find((a) => a.displayForms.some((df) => areObjRefsEqual(df.ref, attr)));
-        })
-            .filter(Boolean);
-    }, [state.selectedAttributes, validAttributes]);
-    const isSearchBarVisible = validAttributes.length > 7;
+    const { validAttributes, mapAttributes, initialAttributes, isSearchBarVisible } = useKdaValidAttributes();
+    const onApply = useCallback((selected) => {
+        setState({
+            selectedAttributes: selected.map((item) => {
+                const existingRef = state.selectedAttributes.find((ref) => item.displayForms.some((df) => areObjRefsEqual(df.ref, ref)));
+                return existingRef ?? item.defaultDisplayForm.ref;
+            }),
+            selectedUpdated: Date.now(),
+        });
+    }, [setState, state.selectedAttributes]);
+    const onOpen = useCallback(() => {
+        setState({ attributesDropdownOpen: true });
+    }, [setState]);
+    const onClose = useCallback(() => {
+        setState({ attributesDropdownOpen: false });
+    }, [setState]);
     //Do not show footer when kda is not loaded at all
     if (isError) {
         return null;
@@ -60,46 +45,7 @@ export function KeyDriversFooter() {
                     const buttonLabel = chunks
                         .filter((chunk) => typeof chunk === "string")
                         .join("");
-                    return (_jsx(DropdownInvertableSelect, { closeOnEscape: true, accessibilityConfig: {
-                            triggerRole: "button",
-                            popupRole: "dialog",
-                            popupLabel: intl.formatMessage({
-                                id: "kdaDialog.dialog.keyDrives.overview.summary.drivers.popupLabel",
-                            }),
-                        }, className: "gd-kda-attributes-dropdown", initialValue: initialAttributes, overlayPositionType: "sameAsTarget", initialIsInverted: false, options: validAttributes, onOpen: () => {
-                            setState({
-                                attributesDropdownOpen: true,
-                            });
-                        }, onClose: () => {
-                            setState({
-                                attributesDropdownOpen: false,
-                            });
-                        }, alignPoints: [{ align: "tl bl" }], getItemTitle: (item) => item.attribute.title, getItemKey: (item) => item.attribute.id, onChange: (selectedItems, isInverted) => {
-                            const selected = isInverted
-                                ? validAttributes.filter((a) => !selectedItems.includes(a))
-                                : selectedItems;
-                            setState({
-                                selectedAttributes: selected.map((item) => item.defaultDisplayForm.ref),
-                                selectedUpdated: Date.now(),
-                            });
-                        }, header: _jsx("div", { className: "gd-kda-attributes-dropdown__header", children: _jsx(FormattedMessage, { id: "kdaDialog.dialog.keyDrives.overview.summary.drivers.attributes" }) }), renderSearchBar: isSearchBarVisible
-                            ? undefined
-                            : () => _jsx("div", { className: "gd-kda-attributes-dropdown__no-search" }), renderItem: (props) => (_jsx(InvertableSelectItem, { title: props.title, isSelected: props.isSelected, onClick: props.isSelected ? props.onDeselect : props.onSelect, onOnly: props.onSelectOnly, accessibilityConfig: {
-                                ariaLabelledBy: labelAttributeId,
-                            }, renderRight: () => {
-                                const group = mapAttributes.get(props.item.attribute.ref);
-                                if (!group || group.significantDrivers.length === 0) {
-                                    return (_jsx("span", { className: "gd-kda-attributes-dropdown__key_drivers", "aria-labelledby": labelKeyDriversId, children: "-" }));
-                                }
-                                return (_jsxs("span", { className: "gd-kda-attributes-dropdown__key_drivers", "aria-labelledby": labelKeyDriversId, children: ["(", group.significantDrivers.length, ")"] }));
-                            } })), renderButton: ({ buttonRef, isOpen, toggleDropdown, accessibilityConfig, }) => (_jsx(UiButton, { ref: buttonRef, variant: "tertiary", iconAfter: "settings", isSelected: isOpen, label: buttonLabel, onClick: toggleDropdown, accessibilityConfig: {
-                                ...accessibilityConfig,
-                                ariaHaspopup: "dialog",
-                            } })), renderListActions: () => {
-                            return (_jsx(_Fragment, { children: _jsxs("div", { className: "gd-kda-attributes-dropdown__subheader", children: [
-                                        _jsx("div", { className: "gd-kda-attributes-dropdown__subheader__attribute", id: labelAttributeId, children: _jsx(FormattedMessage, { id: "kdaDialog.dialog.keyDrives.overview.detail.table.attribute" }) }), _jsx("div", { className: "gd-kda-attributes-dropdown__subheader__key_drivers", id: labelKeyDriversId, children: _jsx(FormattedMessage, { id: "kdaDialog.dialog.keyDrives.overview.detail.table.drivers" }) })
-                                    ] }) }));
-                        } }));
+                    return (_jsx(KdaAttributesDropdown, { buttonLabel: buttonLabel, attributesCount: state.selectedAttributes.length, validAttributes: validAttributes, initialAttributes: initialAttributes, mapAttributes: mapAttributes, isSearchBarVisible: isSearchBarVisible, onApply: onApply, onOpen: onOpen, onClose: onClose }));
                 },
             } })) }));
 }

package/esm/kdaDialog/composition/hooks/useKdaAttributesSelection.d.ts

@@ -0,0 +1,15 @@
+import { type ICatalogAttribute } from "@gooddata/sdk-model";
+export declare const getAttributeKey: (item: ICatalogAttribute) => string;
+export declare const getAttributeTitle: (item: ICatalogAttribute) => string;
+export declare function useKdaAttributesSelection(validAttributes: ICatalogAttribute[], initialAttributes: ICatalogAttribute[]): {
+    searchString: string;
+    setSearchString: import("react").Dispatch<import("react").SetStateAction<string>>;
+    selection: ICatalogAttribute[];
+    isInverted: boolean;
+    filteredOptions: ICatalogAttribute[];
+    resolvedSelection: ICatalogAttribute[];
+    isApplyDisabled: boolean;
+    onSelect: (selectedItems: ICatalogAttribute[], inverted: boolean) => void;
+    resetSelection: () => void;
+};
+//# sourceMappingURL=useKdaAttributesSelection.d.ts.map

package/esm/kdaDialog/composition/hooks/useKdaAttributesSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKdaAttributesSelection.d.ts","sourceRoot":"","sources":["../../../../src/kdaDialog/composition/hooks/useKdaAttributesSelection.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,eAAO,MAAM,eAAe,qCAAiD,CAAC;AAC9E,eAAO,MAAM,iBAAiB,qCAAoD,CAAC;AAEnF,wBAAgB,yBAAyB,CACrC,eAAe,EAAE,iBAAiB,EAAE,EACpC,iBAAiB,EAAE,iBAAiB,EAAE;;;;;;;;;;EAuDzC"}

package/esm/kdaDialog/composition/hooks/useKdaAttributesSelection.js

@@ -0,0 +1,51 @@
+// (C) 2025-2026 GoodData Corporation
+import { useCallback, useMemo, useState } from "react";
+export const getAttributeKey = (item) => item.attribute.id;
+export const getAttributeTitle = (item) => item.attribute.title;
+export function useKdaAttributesSelection(validAttributes, initialAttributes) {
+    const [searchString, setSearchString] = useState("");
+    const [selection, setSelection] = useState(initialAttributes);
+    const [isInverted, setIsInverted] = useState(false);
+    const resetSelection = useCallback(() => {
+        setSelection(initialAttributes);
+        setIsInverted(false);
+        setSearchString("");
+    }, [initialAttributes]);
+    const filteredOptions = useMemo(() => {
+        if (!searchString) {
+            return validAttributes;
+        }
+        const lowerSearch = searchString.toLowerCase();
+        return validAttributes.filter((option) => getAttributeTitle(option).toLowerCase().includes(lowerSearch));
+    }, [validAttributes, searchString]);
+    const resolvedSelection = useMemo(() => {
+        if (!isInverted) {
+            return selection;
+        }
+        const selectedIds = new Set(selection.map(getAttributeKey));
+        return validAttributes.filter((a) => !selectedIds.has(getAttributeKey(a)));
+    }, [isInverted, selection, validAttributes]);
+    const isApplyDisabled = useMemo(() => {
+        if (resolvedSelection.length === 0) {
+            return true;
+        }
+        const currentIds = new Set(resolvedSelection.map(getAttributeKey));
+        const committedIds = new Set(initialAttributes.map(getAttributeKey));
+        return currentIds.size === committedIds.size && [...currentIds].every((id) => committedIds.has(id));
+    }, [resolvedSelection, initialAttributes]);
+    const onSelect = useCallback((selectedItems, inverted) => {
+        setSelection(selectedItems);
+        setIsInverted(inverted);
+    }, []);
+    return {
+        searchString,
+        setSearchString,
+        selection,
+        isInverted,
+        filteredOptions,
+        resolvedSelection,
+        isApplyDisabled,
+        onSelect,
+        resetSelection,
+    };
+}

package/esm/kdaDialog/composition/hooks/useKdaValidAttributes.d.ts

@@ -0,0 +1,9 @@
+import { type ICatalogAttribute } from "@gooddata/sdk-model";
+import { type IKdaItemGroup } from "../../internalTypes.js";
+export declare function useKdaValidAttributes(): {
+    validAttributes: ICatalogAttribute[];
+    mapAttributes: Map<string, IKdaItemGroup | undefined>;
+    initialAttributes: ICatalogAttribute[];
+    isSearchBarVisible: boolean;
+};
+//# sourceMappingURL=useKdaValidAttributes.d.ts.map

package/esm/kdaDialog/composition/hooks/useKdaValidAttributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKdaValidAttributes.d.ts","sourceRoot":"","sources":["../../../../src/kdaDialog/composition/hooks/useKdaValidAttributes.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,iBAAiB,EAAmB,MAAM,qBAAqB,CAAC;AAK9E,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAK5D,wBAAgB,qBAAqB;;;;;EA4CpC"}

package/esm/kdaDialog/composition/hooks/useKdaValidAttributes.js

@@ -0,0 +1,45 @@
+// (C) 2025-2026 GoodData Corporation
+import { useMemo } from "react";
+import { areObjRefsEqual } from "@gooddata/sdk-model";
+import { useDashboardSelector } from "../../../model/react/DashboardStoreProvider.js";
+import { selectCatalogAttributes } from "../../../model/store/catalog/catalogSelectors.js";
+import { useSummaryDrivers } from "../../hooks/useSummaryDrivers.js";
+import { useKdaState } from "../../providers/KdaState.js";
+const SEARCH_BAR_THRESHOLD = 7;
+export function useKdaValidAttributes() {
+    const { state } = useKdaState();
+    const list = useSummaryDrivers();
+    const allAttributes = useDashboardSelector(selectCatalogAttributes);
+    const { validAttributes, mapAttributes } = useMemo(() => {
+        const mapAttributes = new Map();
+        const validAttributes = allAttributes
+            .filter((a) => {
+            return state.relevantAttributes.some((attr) => areObjRefsEqual(attr, a.attribute.ref));
+        })
+            .map((a) => {
+            const group = list.find((item) => a.displayForms.some((df) => areObjRefsEqual(df.ref, item.displayForm)));
+            mapAttributes.set(a.attribute.id, group);
+            return [a, group];
+        })
+            .sort(([, a], [, b]) => {
+            const aIndex = a ? list.indexOf(a) : Number.MAX_VALUE;
+            const bIndex = b ? list.indexOf(b) : Number.MAX_VALUE;
+            return aIndex - bIndex;
+        })
+            .map(([a]) => a);
+        return { validAttributes, mapAttributes };
+    }, [allAttributes, list, state.relevantAttributes]);
+    const initialAttributes = useMemo(() => {
+        return state.selectedAttributes
+            .map((attr) => {
+            return validAttributes.find((a) => a.displayForms.some((df) => areObjRefsEqual(df.ref, attr)));
+        })
+            .filter((a) => a !== undefined);
+    }, [state.selectedAttributes, validAttributes]);
+    return {
+        validAttributes,
+        mapAttributes,
+        initialAttributes,
+        isSearchBarVisible: validAttributes.length > SEARCH_BAR_THRESHOLD,
+    };
+}

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

@@ -0,0 +1,20 @@
+import { type Dispatch, type SetStateAction } from "react";
+import { type IAlertRelativeArithmeticOperator, type IAlertRelativeOperator, type IAttribute, type IAutomationMetadataObjectDefinition, type IMeasure } from "@gooddata/sdk-model";
+import { type AlertAttribute, type AlertMetric } from "../../types.js";
+export interface IUseAlertThresholdProps {
+    setEditedAutomation: Dispatch<SetStateAction<IAutomationMetadataObjectDefinition | undefined>>;
+    editedAutomation: IAutomationMetadataObjectDefinition | undefined;
+    getMetricValue: (measure?: IMeasure, attr?: IAttribute, value?: string | null) => number | undefined;
+    isNewAlert: boolean;
+    selectedRelativeOperator: [IAlertRelativeOperator, IAlertRelativeArithmeticOperator] | undefined;
+    selectedMeasure: AlertMetric | undefined;
+    selectedAttribute: AlertAttribute | undefined;
+    selectedValue: string | null | undefined;
+}
+export declare function useAlertThreshold({ setEditedAutomation, editedAutomation, getMetricValue, isNewAlert, selectedRelativeOperator, selectedMeasure, selectedAttribute, selectedValue }: IUseAlertThresholdProps): {
+    value: number | undefined;
+    onChange: (e: string | number, event?: import("react").ChangeEvent<HTMLInputElement> | undefined) => void;
+    onBlur: (event: import("react").FocusEvent<HTMLInputElement, Element>) => void;
+    thresholdErrorMessage: string | undefined;
+};
+//# sourceMappingURL=useAlertThreshold.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAlertThreshold.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/automations/alerting/DefaultAlertingDialog/hooks/useAlertThreshold.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAe,MAAM,OAAO,CAAC;AAExE,OAAO,EACH,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EAEf,KAAK,mCAAmC,EACxC,KAAK,QAAQ,EAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAKvE,MAAM,WAAW,uBAAuB;IACpC,mBAAmB,EAAE,QAAQ,CAAC,cAAc,CAAC,mCAAmC,GAAG,SAAS,CAAC,CAAC,CAAC;IAC/F,gBAAgB,EAAE,mCAAmC,GAAG,SAAS,CAAC;IAClE,cAAc,EAAE,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,GAAG,SAAS,CAAC;IACrG,UAAU,EAAE,OAAO,CAAC;IACpB,wBAAwB,EAAE,CAAC,sBAAsB,EAAE,gCAAgC,CAAC,GAAG,SAAS,CAAC;IACjG,eAAe,EAAE,WAAW,GAAG,SAAS,CAAC;IACzC,iBAAiB,EAAE,cAAc,GAAG,SAAS,CAAC;IAC9C,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAC5C;AAED,wBAAgB,iBAAiB,CAAC,EAC9B,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,UAAU,EACV,wBAAwB,EACxB,eAAe,EACf,iBAAiB,EACjB,aAAa,EAChB,EAAE,uBAAuB;;;;;EAgCzB"}

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

@@ -0,0 +1,16 @@
+// (C) 2026 GoodData Corporation
+import { useCallback } from "react";
+import { transformAlertByValue } from "../utils/transformation.js";
+import { useThresholdValue } from "./useThresholdValue.js";
+export function useAlertThreshold({ setEditedAutomation, editedAutomation, getMetricValue, isNewAlert, selectedRelativeOperator, selectedMeasure, selectedAttribute, selectedValue, }) {
+    const onValueChange = useCallback((value) => {
+        setEditedAutomation((alert) => alert ? transformAlertByValue(alert, value) : undefined);
+    }, [setEditedAutomation]);
+    const { value, onChange, onBlur, errorMessage: thresholdErrorMessage, } = useThresholdValue(onValueChange, getMetricValue, isNewAlert, editedAutomation?.alert, selectedRelativeOperator, selectedMeasure, selectedAttribute, selectedValue);
+    return {
+        value,
+        onChange,
+        onBlur,
+        thresholdErrorMessage,
+    };
+}

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAujBpB"}
+{"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;AAkBvG,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyiBpB"}

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

@@ -8,11 +8,11 @@ import { useAutomationAlertParameters } from "../../../shared/automationFilters/
 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, transformAlertByValue, } from "../utils/transformation.js";
+import { transformAlertByAnomalyDetection, transformAlertByAttribute, transformAlertByComparisonOperator, transformAlertByDestination, transformAlertByGranularity, transformAlertByMetric, transformAlertByRelativeOperator, transformAlertBySensitivity, } from "../utils/transformation.js";
 import { useAlertFormValidation } from "./useAlertFormValidation.js";
 import { useAlertSelectedValues } from "./useAlertSelectedValues.js";
 import { useAlertSupportedMetrics } from "./useAlertSupportedMetrics.js";
-import { useThresholdValue } from "./useThresholdValue.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();
@@ -20,8 +20,6 @@ export function useEditAlert({ alertToEdit, notificationChannels, insight, widge
     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;
-    // Computed values
-    const isNewAlert = !alertToEdit;
     const { measureFormatMap, supportedMeasures, supportedAttributes, isResultLoading, getAttributeValues, getMetricValue, } = useAlertSupportedMetrics({ insight, widget, alertToEdit });
     // Default values
     const defaultMeasure = supportedMeasures[0];
@@ -99,9 +97,6 @@ export function useEditAlert({ alertToEdit, notificationChannels, insight, widge
             ? transformAlertByAttribute(supportedAttributes, alert, attribute, value)
             : undefined);
     }, [supportedAttributes]);
-    const onValueChange = useCallback((value) => {
-        setEditedAutomation((alert) => alert ? transformAlertByValue(alert, value) : undefined);
-    }, []);
     const onComparisonOperatorChange = useCallback((measure, comparisonOperator) => {
         setEditedAutomation((alert) => alert
             ? transformAlertByComparisonOperator(supportedMeasures, alert, measure, comparisonOperator)
@@ -237,7 +232,16 @@ export function useEditAlert({ alertToEdit, notificationChannels, insight, widge
     const onApplyCurrentFilters = useCallback(() => {
         onFiltersChange(filtersForNewAutomation);
     }, [filtersForNewAutomation, onFiltersChange]);
-    const { value, onChange, onBlur, errorMessage: thresholdErrorMessage, } = useThresholdValue(onValueChange, getMetricValue, isNewAlert, editedAutomation?.alert, selectedRelativeOperator, selectedMeasure, selectedAttribute, selectedValue);
+    const { value, onChange, onBlur, thresholdErrorMessage } = useAlertThreshold({
+        setEditedAutomation,
+        editedAutomation,
+        getMetricValue,
+        isNewAlert: !alertToEdit,
+        selectedRelativeOperator,
+        selectedMeasure,
+        selectedAttribute,
+        selectedValue,
+    });
     const { isSubmitDisabled, validationErrorMessage, isParentValid } = useAlertFormValidation({
         editedAutomation,
         originalAutomation,

package/esm/presentation/filterBar/attributeFilter/dashboardDropdownBody/configuration/selectionMode/SelectionModeItem.js

@@ -9,5 +9,5 @@ export function SelectionModeItem({ item, itemTitle, tooltip, selected, disabled
     }, "s-selection-mode-dropdown-item", `s-selection-mode-dropdown-item-${item}`);
     const tooltipText = disabled ? disabledTooltip : tooltip;
     return (_jsxs("div", { className: className, onClick: () => !disabled && onClick(), children: [
-            _jsx("span", { className: "selection-kind-dropdown-item-title", children: itemTitle }), tooltipText ? (_jsx(UiTooltip, { anchor: _jsx("span", { className: "selection-kind-dropdown-item-help gd-icon-circle-question" }), content: tooltipText, arrowPlacement: "left", triggerBy: ["hover"], width: TOOLTIP_WIDTH_MEDIUM, anchorWrapperStyles: { display: "flex", alignItems: "center" } })) : null] }));
+            _jsx("span", { className: "selection-kind-dropdown-item-title", children: itemTitle }), tooltipText ? (_jsx(UiTooltip, { anchor: _jsx("span", { className: "selection-kind-dropdown-item-help gd-icon-circle-question" }), content: tooltipText, arrowPlacement: "left", triggerBy: ["hover"], width: TOOLTIP_WIDTH_MEDIUM, inlineAnchor: true })) : null] }));
 }

package/esm/presentation/filterBar/attributeFilter/dashboardDropdownBody/configuration/selectionType/SelectionTypeItem.js

@@ -8,7 +8,7 @@ export function SelectionTypeItem({ item, itemTitle, tooltip, selected, disabled
         "is-disabled": disabled,
     }, "s-selection-kind-dropdown-item", `s-selection-kind-dropdown-item-${item}`);
     const itemContent = (_jsxs("div", { className: className, onClick: () => !disabled && onClick(), children: [
-            _jsx("span", { className: "selection-kind-dropdown-item-title", children: itemTitle }), disabled ? null : (_jsx(UiTooltip, { anchor: _jsx("span", { className: "selection-kind-dropdown-item-help gd-icon-circle-question" }), content: _jsx("span", { style: { whiteSpace: "pre-line", maxWidth: 240 }, children: tooltip }), arrowPlacement: "left", triggerBy: ["hover"], anchorWrapperStyles: { display: "flex", alignItems: "center" } }))] }));
+            _jsx("span", { className: "selection-kind-dropdown-item-title", children: itemTitle }), disabled ? null : (_jsx(UiTooltip, { anchor: _jsx("span", { className: "selection-kind-dropdown-item-help gd-icon-circle-question" }), content: _jsx("span", { style: { whiteSpace: "pre-line", maxWidth: 240 }, children: tooltip }), arrowPlacement: "left", triggerBy: ["hover"], inlineAnchor: true }))] }));
     if (disabled && disabledTooltip) {
         return (_jsx(UiTooltip, { anchor: itemContent, content: _jsx("span", { style: { maxWidth: 240 }, children: disabledTooltip }), arrowPlacement: "left", triggerBy: ["hover"], anchorWrapperStyles: { width: "100%", height: "100%" } }));
     }

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

@@ -4,6 +4,8 @@ export declare const de_DE: {
     empty_value: string;
     "gs.list.cancel": string;
     "gs.list.apply": string;
+    "gs.list.only": string;
+    "attributesDropdown.onlyLabel": string;
     "messages.dashboardSaveSuccess": string;
     "options.menu.save.as": string;
     "options.menu.save.as.tooltip": string;
@@ -829,7 +831,8 @@ export declare const de_DE: {
     "kdaDialog.dialog.keyDrives.overview.summary.title": string;
     "kdaDialog.dialog.keyDrives.overview.summary.drivers.description": string;
     "kdaDialog.dialog.keyDrives.overview.summary.drivers.popupLabel": string;
-    "kdaDialog.dialog.keyDrives.overview.summary.drivers.attributes": string;
+    "kdaDialog.dialog.keyDrives.overview.summary.drivers.countLabel": string;
+    "kdaDialog.dialog.keyDrives.overview.summary.drivers.noDrivers": string;
     "kdaDialog.dialog.keyDrives.overview.diff.title": string;
     "kdaDialog.dialog.keyDrives.overview.detail.tip": string;
     "kdaDialog.dialog.keyDrives.overview.detail.title": 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAm2BjB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAs2BjB,CAAC"}

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

@@ -6,6 +6,8 @@ export const de_DE = {
     "empty_value": "leerer Wert",
     "gs.list.cancel": "Abbrechen",
     "gs.list.apply": "Anwenden",
+    "gs.list.only": "Nur",
+    "attributesDropdown.onlyLabel": "Nur {itemTitle} auswählen",
     "messages.dashboardSaveSuccess": "Großartig. Wir haben Ihr Dashboard gespeichert.",
     "options.menu.save.as": "Als neu speichern",
     "options.menu.save.as.tooltip": "Ein leeres Dashboard kann nicht gespeichert werden.",
@@ -831,7 +833,8 @@ export const de_DE = {
     "kdaDialog.dialog.keyDrives.overview.summary.title": "Analysezusammenfassung",
     "kdaDialog.dialog.keyDrives.overview.summary.drivers.description": "Getestete {combinations} Varianten mit <button>{attributes} Attributen</button>",
     "kdaDialog.dialog.keyDrives.overview.summary.drivers.popupLabel": "Attributauswahl ändern",
-    "kdaDialog.dialog.keyDrives.overview.summary.drivers.attributes": "Attribute",
+    "kdaDialog.dialog.keyDrives.overview.summary.drivers.countLabel": "{count, plural, one {# Treiber} other {# Treiber}}",
+    "kdaDialog.dialog.keyDrives.overview.summary.drivers.noDrivers": "Keine Treiber",
     "kdaDialog.dialog.keyDrives.overview.diff.title": "Diff",
     "kdaDialog.dialog.keyDrives.overview.detail.tip": "Klicken Sie auf die Spalte, um die wichtigsten Treiber für die angegebene {category}",
     "kdaDialog.dialog.keyDrives.overview.detail.title": "Änderung in {title} bis {category}",