@gooddata/sdk-ui-analytical-designer 0.0.0-stage → 11.65.0-alpha.6

package/esm/components/buckets/measureDateFilterOption.js

@@ -0,0 +1,54 @@
+// (C) 2026 GoodData Corporation
+import { isEmpty } from "lodash-es";
+import { isAllTimeDateFilterOption } from "@gooddata/sdk-model";
+import { DateFilterHelpers } from "@gooddata/sdk-ui-filters";
+import { normalizeSelectedFilterOption } from "@gooddata/sdk-ui-filters/internal";
+import { ALL_TIME } from "../../constants/presets.js";
+import { buildDateFilterValueFromDateFilterOption, matchDateFilterValueToDateFilterOption, } from "../filterBar/dateFilter/dateFilterOptionFactory.js";
+// Stored absolute metric filters carry `type: "absolute"` without a name, so the type is kept as stored
+// rather than derived from the name like `asDateFilterConfig` does. Relative bounds may be stored as
+// numeric strings, which the preset matching compares strictly, so they are coerced to numbers.
+const toDateFilterConfig = ({ name, type, granularity, interval, boundedFilter, }) => {
+    const isAbsolute = type === "absolute";
+    return {
+        name,
+        granularity,
+        interval: isAbsolute ? interval : [Number(interval[0]), Number(interval[1])],
+        type: isAbsolute ? "absolute" : "relative",
+        ...(boundedFilter ? { boundedFilter } : {}),
+    };
+};
+/**
+ * Converts the stored metric date filter into the option the shared date filter components work with.
+ * Returns undefined when the metric has no date filter yet.
+ */
+export function measureDateFilterToOption(filter) {
+    const stored = filter?.interval?.original;
+    if (!stored || isEmpty(stored)) {
+        return undefined;
+    }
+    // the legacy All time filter is stored as the bare preset name, without an interval
+    if (stored.name === ALL_TIME) {
+        return matchDateFilterValueToDateFilterOption({
+            name: ALL_TIME,
+            granularity: undefined,
+            interval: undefined,
+        });
+    }
+    if (!stored.interval) {
+        return undefined;
+    }
+    return matchDateFilterValueToDateFilterOption(toDateFilterConfig(stored));
+}
+/**
+ * Converts the option picked in the shared date filter components into the interval stored on the metric filter.
+ * All time lands in the legacy shape, the bare preset name: it is stored in the visualization object like
+ * the filter bar's All time and, like it, dropped from the execution.
+ */
+export function optionToMeasureDateFilterInterval({ filterOption, excludeCurrentPeriod, }) {
+    if (isAllTimeDateFilterOption(filterOption)) {
+        return { name: ALL_TIME };
+    }
+    const normalized = normalizeSelectedFilterOption(filterOption);
+    return buildDateFilterValueFromDateFilterOption(DateFilterHelpers.applyExcludeCurrentPeriod(normalized, excludeCurrentPeriod));
+}

package/esm/components/buckets/measures/MeasureAddFilterDropdown.d.ts

@@ -0,0 +1,30 @@
+import { type IDecoratedBucketItem } from "../../../typings/buckets.js";
+import { type ITagsConfiguration } from "../../../typings/route.js";
+import { type IMeasureAttributeFilterItem } from "../MeasureAttributeListItemOrganized.js";
+export interface IMeasureAddFilterDropdownProps {
+    bucketLocalIdentifier: string;
+    bucketItem: IDecoratedBucketItem;
+    projectId: string;
+    tagsConfiguration: ITagsConfiguration;
+    isLocationIconEnabled?: boolean;
+    computedAttributesEnabled?: boolean;
+    /** whether the metric can take one more date filter */
+    isDateFilterAvailable: boolean;
+    /** explains a disabled Date entry */
+    dateFilterDisabledTooltip?: string;
+    /** whether the metric can take one more attribute filter */
+    isAttributeFilterAvailable: boolean;
+    /** explains a disabled Attribute values entry */
+    attributeFilterDisabledTooltip?: string;
+    onAddDateFilter: () => void;
+    /** the picked attributes, each getting its attribute filter on the metric, as one gesture */
+    onAddAttributeFilters: (items: IMeasureAttributeFilterItem[]) => void;
+}
+/**
+ * The metric's "Add filter" button and its "Add filter for" menu, offering a date filter and the
+ * attribute values the way the filter bar's does (minus the filters a metric cannot take). Date
+ * hands over to the date filter chip; Attribute values turns the same dropdown into the filter
+ * bar's attribute picker over the attributes valid for the metric.
+ */
+export declare function MeasureAddFilterDropdown(props: IMeasureAddFilterDropdownProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=MeasureAddFilterDropdown.d.ts.map

package/esm/components/buckets/measures/MeasureAddFilterDropdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeasureAddFilterDropdown.d.ts","sourceRoot":"","sources":["../../../../src/components/buckets/measures/MeasureAddFilterDropdown.tsx"],"names":[],"mappings":"AAcA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAKpE,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,yCAAyC,CAAC;AAK3F,MAAM,WAAW,8BAA8B;IAC3C,qBAAqB,EAAE,MAAM,CAAC;IAC9B,UAAU,EAAE,oBAAoB,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,kBAAkB,CAAC;IACtC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,uDAAuD;IACvD,qBAAqB,EAAE,OAAO,CAAC;IAC/B,qCAAqC;IACrC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,4DAA4D;IAC5D,0BAA0B,EAAE,OAAO,CAAC;IACpC,iDAAiD;IACjD,8BAA8B,CAAC,EAAE,MAAM,CAAC;IACxC,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,6FAA6F;IAC7F,qBAAqB,EAAE,CAAC,KAAK,EAAE,2BAA2B,EAAE,KAAK,IAAI,CAAC;CACzE;AA+HD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,8BAA8B,2CAkD7E"}

package/esm/components/buckets/measures/MeasureAddFilterDropdown.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useMemo, useState } from "react";
+import classNames from "classnames";
+import { useIntl } from "react-intl";
+import { Button, CatalogItemPicker, } from "@gooddata/sdk-ui-kit";
+import { CatalogDetailsBubble } from "../../catalog/item/CatalogDetailsBubble.js";
+import { AddFilterDropdownShell } from "../../filterBar/filterBarDropdown/AddFilterDropdownShell.js";
+import { AddFilterMenu } from "../../filterBar/filterBarDropdown/AddFilterMenu.js";
+import { isAttributeAlreadyFiltered } from "../isAttributeAlreadyFiltered.js";
+import { useMeasureAttributeFilterItems } from "../useMeasureAttributeFilterItems.js";
+/**
+ * The filter bar's attribute picker over the attributes valid for THIS metric (the insight's
+ * availability is the filter bar's input), minus the ones the metric already filters by.
+ */
+// defined at module scope so the picker's row component keeps its identity across renders
+const renderItemDetails = (item) => (_jsx(CatalogDetailsBubble, { item: item.payload }));
+function MeasureAttributePicker({ bucketItem, maxListHeight, onBack, onClose, onAdd, ...loadParams }) {
+    const { items, isLoading } = useMeasureAttributeFilterItems({ bucketItem, ...loadParams });
+    const attributeItems = useMemo(() => ({
+        insightItems: [],
+        catalogItems: items
+            .filter((item) => !isAttributeAlreadyFiltered(bucketItem, item))
+            .map((item) => ({
+            // the identifier alone can collide across the two namespaces
+            id: `${item.type}.${item.identifier}`,
+            title: item.title,
+            type: "attribute",
+            payload: item,
+            ref: item.ref,
+            dataset: item.dataset,
+        })),
+    }), [items, bucketItem]);
+    return (_jsx(CatalogItemPicker, { itemTypes: ["attribute"], selectionMode: "multiple", attributeItems: attributeItems, maxListHeight: maxListHeight, isOpen: true, isLoading: isLoading, onBack: onBack, onClose: onClose, onAdd: onAdd, variant: "addFilter", renderItemDetails: renderItemDetails }));
+}
+function MeasureAddFilterDropdownBody({ bucketItem, projectId, tagsConfiguration, isLocationIconEnabled, computedAttributesEnabled, isDateFilterAvailable, dateFilterDisabledTooltip, isAttributeFilterAvailable, attributeFilterDisabledTooltip, onAddDateFilter, onAddAttributeFilters, buttonNode, onClose, }) {
+    const [activeView, setActiveView] = useState("menu");
+    return (_jsx(AddFilterDropdownShell, { buttonNode: buttonNode, onClose: onClose, testClassName: "s-metric-add-filter-dropdown", children: (maxListHeight) => activeView === "menu" ? (_jsx(AddFilterMenu, { onClose: onClose, onAddDateFilter: onAddDateFilter, onOpenAttributePicker: () => setActiveView("attributes"), isDateItemAvailable: isDateFilterAvailable, dateDisabledTooltip: dateFilterDisabledTooltip, isAttributeItemAvailable: isAttributeFilterAvailable, attributeDisabledTooltip: attributeFilterDisabledTooltip, showMetricItem: false, showRankingItem: false })) : (_jsx(MeasureAttributePicker, { bucketItem: bucketItem, projectId: projectId, tagsConfiguration: tagsConfiguration, isLocationIconEnabled: isLocationIconEnabled, computedAttributesEnabled: computedAttributesEnabled, maxListHeight: maxListHeight, onBack: () => setActiveView("menu"), onClose: onClose, onAdd: onAddAttributeFilters })) }));
+}
+/**
+ * The metric's "Add filter" button and its "Add filter for" menu, offering a date filter and the
+ * attribute values the way the filter bar's does (minus the filters a metric cannot take). Date
+ * hands over to the date filter chip; Attribute values turns the same dropdown into the filter
+ * bar's attribute picker over the attributes valid for the metric.
+ */
+export function MeasureAddFilterDropdown(props) {
+    const { bucketLocalIdentifier, onAddDateFilter, onAddAttributeFilters } = props;
+    const intl = useIntl();
+    const [isOpen, setIsOpen] = useState(false);
+    const [buttonNode, setButtonNode] = useState(null);
+    const toggle = useCallback(() => setIsOpen((current) => !current), []);
+    const close = useCallback(() => setIsOpen(false), []);
+    const handleAddDateFilter = useCallback(() => {
+        close();
+        onAddDateFilter();
+    }, [close, onAddDateFilter]);
+    const handleAddAttributeFilters = useCallback((items) => {
+        close();
+        onAddAttributeFilters(items);
+    }, [close, onAddAttributeFilters]);
+    const buttonText = intl.formatMessage({ id: "dashboard.bucket.add_filter" });
+    const buttonClasses = classNames([
+        `s-${bucketLocalIdentifier}-bucket-id`,
+        "s-metric-add-filter-button",
+        "gd-button-link",
+        "gd-icon-plus",
+        "button-dropdown",
+        "gd-icon-right",
+        "metric-add-filter-button",
+        { "is-active": isOpen },
+    ]);
+    return (_jsxs("span", { children: [_jsx("span", { ref: setButtonNode, className: "adi-metric-add-filter-button-anchor", children: _jsx(Button, { className: buttonClasses, title: buttonText, value: buttonText, onClick: toggle }) }), isOpen && buttonNode ? (_jsx(MeasureAddFilterDropdownBody, { ...props, buttonNode: buttonNode, onClose: close, onAddDateFilter: handleAddDateFilter, onAddAttributeFilters: handleAddAttributeFilters })) : null] }));
+}

package/esm/components/buckets/measures/MeasureFilters.d.ts

@@ -0,0 +1,7 @@
+import { type IDecoratedBucketItem } from "../../../typings/buckets.js";
+export interface IMeasureFiltersProps {
+    bucketLocalIdentifier: string;
+    bucketItem?: IDecoratedBucketItem;
+}
+export declare const MeasureFilters: import("react").MemoExoticComponent<({ bucketLocalIdentifier, bucketItem, }: IMeasureFiltersProps) => import("react/jsx-runtime").JSX.Element>;
+//# sourceMappingURL=MeasureFilters.d.ts.map

package/esm/components/buckets/measures/MeasureFilters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeasureFilters.d.ts","sourceRoot":"","sources":["../../../../src/components/buckets/measures/MeasureFilters.tsx"],"names":[],"mappings":"AA6CA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAkBxE,MAAM,WAAW,oBAAoB;IACjC,qBAAqB,EAAE,MAAM,CAAC;IAC9B,UAAU,CAAC,EAAE,oBAAoB,CAAC;CACrC;AAED,eAAO,MAAM,cAAc,+EAGxB,oBAAoB,6CA6WrB,CAAC"}

package/esm/components/buckets/measures/MeasureFilters.js

@@ -0,0 +1,227 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { memo, useCallback, useEffect, useMemo, useState } from "react";
+import cx from "classnames";
+import { FormattedMessage, defineMessage, useIntl } from "react-intl";
+import { useDispatch, useSelector } from "react-redux";
+import { objRefToString } from "@gooddata/sdk-model";
+import { Button } from "@gooddata/sdk-ui-kit";
+import { addMessage } from "../../../actions/messages_actions.js";
+import { MEASURES } from "../../../constants/bucket.js";
+import { MAX_ATTRIBUTE_FILTERS_COUNT } from "../../../constants/catalog_filters.js";
+import { DATE_DATASET_ATTRIBUTE } from "../../../models/date_item.js";
+import { areGenericDateAttributeElementsSupported, selectSupportsMultipleDateFilters, } from "../../../selectors/backend_capabilities_selector.js";
+import { getProjectId } from "../../../selectors/bootstrap_selector.js";
+import { filterSupportedDisplayForms } from "../../../selectors/buckets_selector.js";
+import { enableComputedAttributes, enableImprovedMetricDateFilter, getAvailableSelectionTypes, } from "../../../selectors/feature_flag_selector.js";
+import { measureHasDerived } from "../../../selectors/measure_date_filter_selector.js";
+import { getTagsConfiguration } from "../../../selectors/route_selector.js";
+import { isLocationIconEnabled } from "../../../services/reference_point_service.js";
+import { setBucketItemAddMetricFilter, setBucketItemAddMetricFilters, setBucketItemApplyMetricDateFilter, setBucketItemRemoveMetricFilter, setBucketItemUpdateMetricFilter, setBucketItemUpdateMetricFilterDisplayForm, } from "../../../store/bucket_filters/bucket_filters_actions.js";
+import { isMetricAdditionalDateFilter } from "../../../store/bucket_filters/metric_additional_date_filters.js";
+import { getDateDatasetsMetaItems } from "../../../store/date_datasets_meta/date_datasets_meta_selectors.js";
+import { flattenDateDatasetAttributes } from "../../../store/filter_bar/filter_bar_helpers.js";
+import { isDecoratedDateFilter, isDecoratedMetricAttributeFilter, } from "../../../typings/measure_filters.js";
+import { getCssClass } from "../../../utils/css_class.js";
+import { AttributeFilter } from "../../AttributeFilter/AttributeFilter.js";
+import { MetricAttributeFilterButtonWithClassName } from "../../AttributeFilter/components/MetricAttributeFilterButton.js";
+import { MeasureAttributeFilterOrganized } from "../MeasureAttributeFilterOrganized.js";
+import { MeasureDateFilter } from "../MeasureDateFilter.js";
+import { MeasureAddFilterDropdown } from "./MeasureAddFilterDropdown.js";
+export const MeasureFilters = memo(function MeasureFilters({ bucketLocalIdentifier, bucketItem, }) {
+    const dispatch = useDispatch();
+    const intl = useIntl();
+    const projectId = useSelector(getProjectId);
+    const tagsConfiguration = useSelector(getTagsConfiguration);
+    const locationIconEnabled = useSelector(isLocationIconEnabled);
+    const availableSelectionTypes = useSelector(getAvailableSelectionTypes);
+    const computedAttributesEnabled = useSelector(enableComputedAttributes);
+    const improvedMetricDateFilterEnabled = useSelector(enableImprovedMetricDateFilter);
+    const additionalDateFiltersEditable = areGenericDateAttributeElementsSupported();
+    // several date filters per metric, as in the filter bar
+    const multipleDateFiltersEnabled = improvedMetricDateFilterEnabled && selectSupportsMultipleDateFilters();
+    const dateDatasetsMetaItems = useSelector(getDateDatasetsMetaItems);
+    // a metric with a derived (over time) measure cannot be filtered by date, as its chip says
+    const hasDerivedMeasure = useSelector((state) => measureHasDerived(state, { bucketItem }));
+    const dateDatasetAttributes = useMemo(() => flattenDateDatasetAttributes(dateDatasetsMetaItems), [dateDatasetsMetaItems]);
+    const [autoOpenAttributeFilterIdentifier, setAutoOpenAttributeFilterIdentifier] = useState("");
+    // The position of the date filter the "Add filter" menu is adding: its chip is mounted empty
+    // with its picker opening at once, which adds the All time filter the picker then edits. The
+    // chip stays as the filter lands at that position; the pending state is dropped then, or when
+    // the picker closes before the filter lands (its date datasets were still loading).
+    const [addingDateFilterIndex, setAddingDateFilterIndex] = useState(null);
+    const onAddFilter = useCallback((attribute, selectedDateDatasetIdentifier = undefined) => {
+        const item = bucketItem.original;
+        dispatch(setBucketItemAddMetricFilter(item, attribute, selectedDateDatasetIdentifier));
+        const identifier = attribute?.identifier;
+        if (identifier !== DATE_DATASET_ATTRIBUTE) {
+            setAutoOpenAttributeFilterIdentifier(identifier);
+        }
+    }, [bucketItem, dispatch]);
+    const nonDateFiltersCount = (bucketItem.filters || []).filter((filter) => !filter.isDate).length;
+    // The "Add filter" menu's picker is multi-select: the picked attributes land as one gesture,
+    // capped at the room left under the attribute filter maximum (the picker has no selection
+    // limit of its own, so the user is told when picks are left out), and a single one opens its
+    // element picker the way the legacy add did.
+    const onAddAttributeFilters = useCallback((pickedAttributes) => {
+        const attributes = pickedAttributes.slice(0, Math.max(0, MAX_ATTRIBUTE_FILTERS_COUNT - nonDateFiltersCount));
+        if (attributes.length === 0) {
+            return;
+        }
+        dispatch(setBucketItemAddMetricFilters(bucketItem.original, attributes));
+        setAutoOpenAttributeFilterIdentifier(attributes.length === 1 ? attributes[0].identifier : "");
+        if (attributes.length < pickedAttributes.length) {
+            dispatch(addMessage({
+                translationKey: defineMessage({
+                    id: "dashboard.bucket.add_filter.attribute_limit_reached",
+                }).id,
+                type: "warning",
+                values: {
+                    added: String(attributes.length),
+                    picked: String(pickedAttributes.length),
+                    max: String(MAX_ATTRIBUTE_FILTERS_COUNT),
+                },
+            }));
+        }
+    }, [bucketItem, dispatch, nonDateFiltersCount]);
+    const onUpdateFilter = useCallback(
+    // the payload is the attribute-filter changes OR the synthetic date filter the date path builds
+    (filter, payload) => {
+        const item = bucketItem.original;
+        setAutoOpenAttributeFilterIdentifier("");
+        dispatch(setBucketItemUpdateMetricFilter(item, filter.original, payload));
+    }, [bucketItem, dispatch]);
+    const onUpdateFilterDisplayForm = useCallback((filter) => {
+        const itemLocalIdentifier = bucketItem.original?.localIdentifier;
+        const filterAttribute = filter.original?.attribute;
+        return (dfRef, currentDisplayFormRef, selectedElements) => {
+            dispatch(setBucketItemUpdateMetricFilterDisplayForm({
+                itemLocalIdentifier,
+                filterAttribute,
+                filterLocalIdentifier: filter.original?.localIdentifier,
+                displayAsDfRef: dfRef,
+                primaryDfRef: currentDisplayFormRef,
+                selectedElements,
+            }));
+        };
+    }, [bucketItem, dispatch]);
+    const onCloseFilter = useCallback(() => {
+        setAutoOpenAttributeFilterIdentifier("");
+    }, []);
+    const onRemoveFilter = useCallback((filter, removeAdditionalDateFilters = false) => {
+        const item = bucketItem.original;
+        dispatch(setBucketItemRemoveMetricFilter(item, filter, removeAdditionalDateFilters));
+    }, [bucketItem, dispatch]);
+    const onApplyDateFilter = useCallback((payload) => {
+        dispatch(setBucketItemApplyMetricDateFilter(bucketItem.original, payload));
+    }, [bucketItem, dispatch]);
+    const onAddingDateFilterPickerClosed = useCallback(() => {
+        setAddingDateFilterIndex(null);
+    }, []);
+    // With the shared date filter picker, the metric's attribute filters on its date dataset's own
+    // attributes are edited inside that picker, like the filter bar's additional date filters.
+    const isAdditionalDateFilter = (filter) => improvedMetricDateFilterEnabled &&
+        isDecoratedMetricAttributeFilter(filter) &&
+        isMetricAdditionalDateFilter(filter.original, dateDatasetAttributes);
+    const renderAttributeFilter = (filter) => {
+        const onApply = (payload) => onUpdateFilter(filter, payload);
+        const onClick = () => onRemoveFilter(filter.original);
+        const allDisplayForms = filter.attribute?.displayForms || [];
+        const availableDisplayForms = filterSupportedDisplayForms(allDisplayForms);
+        const onDisplayFormChange = onUpdateFilterDisplayForm(filter);
+        const filterDefRef = filter.attribute?.dfRef;
+        const key = objRefToString(filterDefRef);
+        const attributeIdentifier = filter.attribute?.identifier;
+        const sClass = getCssClass(attributeIdentifier, "s-id-");
+        const removeButtonClass = getCssClass(attributeIdentifier, "s-remove-attribute-filter-id-");
+        const wrapperClass = getCssClass(attributeIdentifier, "s-attribute-filter-wrapper-id-");
+        const MetricButton = MetricAttributeFilterButtonWithClassName(sClass);
+        return (_jsxs("div", { className: cx("metric-filter-wrapper", "adi-attribute-filters-list", wrapperClass), children: [_jsx(AttributeFilter, { bucketType: MEASURES, autoOpen: attributeIdentifier === autoOpenAttributeFilterIdentifier, filter: filter, onApply: onApply, onClose: onCloseFilter, useAlternativeDisplayForms: true, onDisplayFormChange: onDisplayFormChange, availableDisplayForms: availableDisplayForms, availableSelectionTypes: availableSelectionTypes, dropdownButtonComponent: MetricButton }, key), _jsx(Button, { className: cx("gd-button-link gd-button-icon-only gd-icon-cross remove-filter s-remove-attribute-filter", removeButtonClass), onClick: onClick })] }, `wrapper-${key}`));
+    };
+    const renderAttributeFilters = (filters) => {
+        return filters
+            .filter(isDecoratedMetricAttributeFilter)
+            .map((filter) => renderAttributeFilter(filter));
+    };
+    const renderAttributePicker = () => {
+        if (nonDateFiltersCount >= MAX_ATTRIBUTE_FILTERS_COUNT) {
+            return null;
+        }
+        return (_jsx(MeasureAttributeFilterOrganized, { projectId: projectId, bucketLocalIdentifier: bucketLocalIdentifier, bucketItem: bucketItem, tagsConfiguration: tagsConfiguration, onSelect: onAddFilter, isLocationIconEnabled: locationIconEnabled, computedAttributesEnabled: computedAttributesEnabled }));
+    };
+    const renderAttributeHeader = (filters) => {
+        if (filters.length === 0) {
+            return null;
+        }
+        return (_jsx("h2", { children: _jsx(FormattedMessage, { id: "filters" }) }));
+    };
+    const dateFilterDateDatasetIdentifier = (dateFilter) => dateFilter.dateDataset?.identifier ?? dateFilter.original?.dimension;
+    const renderDateFilter = (dateFilter, additionalDateFilters, { key, isPrimary, isAdding = false }) => (_jsx(MeasureDateFilter, { filter: dateFilter, autoOpen: isAdding, onDropdownClosed: isAdding ? onAddingDateFilterPickerClosed : undefined, bucketLocalIdentifier: bucketLocalIdentifier, bucketItem: bucketItem, onAdd: onAddFilter, onUpdate: onUpdateFilter, onRemove: onRemoveFilter, additionalDateFilters: additionalDateFilters, onApply: onApplyDateFilter, isPrimaryDateFilter: isPrimary, ownDateDatasetIdentifier: 
+        // the legacy (flag off) primary chip keeps reading the measure-level selection
+        !dateFilter || (isPrimary && !improvedMetricDateFilterEnabled)
+            ? undefined
+            : dateFilterDateDatasetIdentifier(dateFilter) }, key));
+    const renderDateFilters = (dateFilters, additionalDateFilters) => {
+        // Chips are keyed by position, always inside one array: the chip that creates a filter
+        // must stay the same instance as the chip then showing it, or its open picker would close
+        // on the add.
+        if (!improvedMetricDateFilterEnabled) {
+            // the legacy chip reads "Filter by date" until the metric has a date filter
+            if (dateFilters.length === 0) {
+                return [
+                    renderDateFilter(undefined, additionalDateFilters, {
+                        key: "date-filter-0",
+                        isPrimary: true,
+                    }),
+                ];
+            }
+            return dateFilters.map((dateFilter, index) => renderDateFilter(dateFilter, index === 0 ? additionalDateFilters : [], {
+                key: `date-filter-${index}`,
+                isPrimary: index === 0,
+            }));
+        }
+        const chips = dateFilters.map((dateFilter, index) => renderDateFilter(dateFilter, index === 0 ? additionalDateFilters : [], {
+            key: `date-filter-${index}`,
+            isPrimary: index === 0,
+        }));
+        // the date filter the "Add filter" menu is adding, on the metric's default date dataset
+        // like the filter bar's — several date filters may share a dataset there too
+        if (addingDateFilterIndex === dateFilters.length) {
+            const isPrimary = dateFilters.length === 0;
+            chips.push(renderDateFilter(undefined, isPrimary ? additionalDateFilters : [], {
+                key: `date-filter-${dateFilters.length}`,
+                isPrimary,
+                isAdding: true,
+            }));
+        }
+        return chips;
+    };
+    const filters = bucketItem.filters || [];
+    const allDateFilters = filters.filter(isDecoratedDateFilter);
+    // With the flag on every stored date filter shows (only ADDING a further one is gated by the
+    // capability); with it off the open-report operation keeps the first one only, so this is just
+    // the legacy UI's own rule restated.
+    const dateFilters = improvedMetricDateFilterEnabled ? allDateFilters : allDateFilters.slice(0, 1);
+    // The picker always gets them so its Apply preserves them; they leave the regular list only when
+    // the picker can show and edit them (a backend without date attribute elements hides that section).
+    const additionalDateFilters = filters.filter(isAdditionalDateFilter).map((filter) => filter.original);
+    const listedFilters = filters.filter((filter) => !additionalDateFiltersEditable || !isAdditionalDateFilter(filter));
+    // the date filter landed at the adding chip's position: the chip now shows it
+    useEffect(() => {
+        setAddingDateFilterIndex(null);
+    }, [dateFilters.length]);
+    const onAddDateFilter = useCallback(() => {
+        setAddingDateFilterIndex(dateFilters.length);
+    }, [dateFilters.length]);
+    const isDateFilterAvailable = !hasDerivedMeasure && (multipleDateFiltersEnabled || allDateFilters.length === 0);
+    const dateFilterDisabledTooltip = hasDerivedMeasure
+        ? intl.formatMessage({ id: "filter.date.disabled_compare" })
+        : isDateFilterAvailable
+            ? undefined
+            : intl.formatMessage({ id: "dashboard.bucket.add_filter.date_limit" });
+    const isAttributeFilterAvailable = nonDateFiltersCount < MAX_ATTRIBUTE_FILTERS_COUNT;
+    const attributeFilterDisabledTooltip = isAttributeFilterAvailable
+        ? undefined
+        : intl.formatMessage({ id: "dashboard.bucket.add_filter.attribute_limit" }, { max: MAX_ATTRIBUTE_FILTERS_COUNT });
+    return (_jsxs("section", { className: "attribute-filters-wrapper", children: [renderAttributeHeader(filters), renderDateFilters(dateFilters, additionalDateFilters), renderAttributeFilters(listedFilters), improvedMetricDateFilterEnabled ? (_jsx(MeasureAddFilterDropdown, { bucketLocalIdentifier: bucketLocalIdentifier, bucketItem: bucketItem, projectId: projectId, tagsConfiguration: tagsConfiguration, isLocationIconEnabled: locationIconEnabled, computedAttributesEnabled: computedAttributesEnabled, isDateFilterAvailable: isDateFilterAvailable, dateFilterDisabledTooltip: dateFilterDisabledTooltip, isAttributeFilterAvailable: isAttributeFilterAvailable, attributeFilterDisabledTooltip: attributeFilterDisabledTooltip, onAddDateFilter: onAddDateFilter, onAddAttributeFilters: onAddAttributeFilters })) : (renderAttributePicker())] }));
+});

package/esm/components/buckets/measures/arithmetic_measure/ArithmeticMeasureBucketItem.d.ts

@@ -0,0 +1,10 @@
+import { type ReactElement } from "react";
+import { type ConnectDragSource } from "@evil-internetmann/react-dnd";
+import { type IDecoratedBucketItem } from "../../../../typings/buckets.js";
+export interface IArithmeticMeasureBucketItemProps {
+    bucketItem: IDecoratedBucketItem;
+    connectDragSource?: ConnectDragSource;
+    isDraggedItem?: boolean;
+}
+export declare function ArithmeticMeasureBucketItem({ bucketItem, connectDragSource, isDraggedItem, }: IArithmeticMeasureBucketItemProps): ReactElement;
+//# sourceMappingURL=ArithmeticMeasureBucketItem.d.ts.map

package/esm/components/buckets/measures/arithmetic_measure/ArithmeticMeasureBucketItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArithmeticMeasureBucketItem.d.ts","sourceRoot":"","sources":["../../../../../src/components/buckets/measures/arithmetic_measure/ArithmeticMeasureBucketItem.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAE1C,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAMtE,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAK3E,MAAM,WAAW,iCAAiC;IAC9C,UAAU,EAAE,oBAAoB,CAAC;IACjC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,wBAAgB,2BAA2B,CAAC,EACxC,UAAU,EACV,iBAAiB,EACjB,aAAqB,GACxB,EAAE,iCAAiC,GAAG,YAAY,CAoClD"}

package/esm/components/buckets/measures/arithmetic_measure/ArithmeticMeasureBucketItem.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useDispatch, useSelector } from "react-redux";
+import { toggleBucketItemExpanded } from "../../../../actions/buckets_actions.js";
+import { isRenamingBucketItem as isRenamingBucketItemSelector } from "../../../../services/buckets_service.js";
+import { MeasureBucketItemHeader } from "../../MeasureBucketItemHeader.js";
+import { ArithmeticMeasureBucketItemConfiguration } from "./ArithmeticMeasureBucketItemConfiguration.js";
+export function ArithmeticMeasureBucketItem({ bucketItem, connectDragSource, isDraggedItem = false, }) {
+    const isRenamingBucketItem = useSelector((state) => isRenamingBucketItemSelector(state));
+    const dispatch = useDispatch();
+    const renderHeader = () => {
+        const onToggleCollapse = () => dispatch(toggleBucketItemExpanded(bucketItem.original));
+        const header = (_jsx("div", { children: _jsx(MeasureBucketItemHeader, { bucketItem: bucketItem, filters: bucketItem.filters, isCollapsed: bucketItem.collapsed, onToggleCollapse: onToggleCollapse, isDraggedItem: isDraggedItem }) }));
+        if (!isRenamingBucketItem && connectDragSource !== undefined) {
+            return connectDragSource(header);
+        }
+        return header;
+    };
+    return (_jsxs("div", { children: [renderHeader(), bucketItem.collapsed ? null : (_jsx(ArithmeticMeasureBucketItemConfiguration, { bucketItemLocalIdentifier: bucketItem.localIdentifier }))] }));
+}

package/esm/components/buckets/measures/arithmetic_measure/ArithmeticMeasureBucketItemConfiguration.d.ts

@@ -0,0 +1,5 @@
+export interface IArithmeticMeasureBucketItemConfigurationProps {
+    bucketItemLocalIdentifier: string;
+}
+export declare function ArithmeticMeasureBucketItemConfiguration(props: IArithmeticMeasureBucketItemConfigurationProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ArithmeticMeasureBucketItemConfiguration.d.ts.map

package/esm/components/buckets/measures/arithmetic_measure/ArithmeticMeasureBucketItemConfiguration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArithmeticMeasureBucketItemConfiguration.d.ts","sourceRoot":"","sources":["../../../../../src/components/buckets/measures/arithmetic_measure/ArithmeticMeasureBucketItemConfiguration.tsx"],"names":[],"mappings":"AAUA,MAAM,WAAW,8CAA8C;IAC3D,yBAAyB,EAAE,MAAM,CAAC;CACrC;AAED,wBAAgB,wCAAwC,CACpD,KAAK,EAAE,8CAA8C,2CAaxD"}

package/esm/components/buckets/measures/arithmetic_measure/ArithmeticMeasureBucketItemConfiguration.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { FormattedMessage } from "react-intl";
+import { IsATotalCheckbox } from "../../measure/IsATotalCheckbox.js";
+import { MeasureNumberFormatPanel } from "../../measure/MeasureNumberFormatPanel/MeasureNumberFormatPanel.js";
+import { OperandDropdown } from "./OperandDropdown.js";
+import { OperatorDropdown } from "./OperatorDropdown.js";
+export function ArithmeticMeasureBucketItemConfiguration(props) {
+    return (_jsxs("div", { className: "adi-bucket-configuration adi-metric-bucket-item-configuration adi-arithmetic-measure-configuration s-metric-bucket-item-configuration s-adi-arithmetic-measure-configuration", children: [_jsx(FormattedMessage, { id: "dashboard.bucket_item.arithmetic_measure.operator_header" }), _jsx(OperatorDropdown, { localIdentifier: props.bucketItemLocalIdentifier }), _jsx(FormattedMessage, { id: "dashboard.bucket_item.arithmetic_measure.operands_header" }), _jsx(OperandDropdown, { operandIndex: 0, localIdentifier: props.bucketItemLocalIdentifier }), _jsx(OperandDropdown, { operandIndex: 1, localIdentifier: props.bucketItemLocalIdentifier }), _jsx(IsATotalCheckbox, { localIdentifier: props.bucketItemLocalIdentifier }), _jsx(MeasureNumberFormatPanel, { bucketItemLocalIdentifier: props.bucketItemLocalIdentifier })] }));
+}

package/esm/components/buckets/measures/arithmetic_measure/OperandDropdown.d.ts

@@ -0,0 +1,157 @@
+import { type ReactElement } from "react";
+import { type IBucketSequenceNumbers } from "../../../../selectors/measure_sequence_numbers_selector.js";
+import { getDecoratedMeasures } from "../../../../services/decorated_buckets_service.js";
+import { type IAppState } from "../../../../store/types.js";
+import { type IDecoratedBucketItems } from "../../../../typings/buckets.js";
+import { type IOperandDropdownItem } from "./model/operand_dropdown_item.js";
+export interface IOperandDropdownOwnProps {
+    localIdentifier: string;
+    operandIndex: number;
+}
+export interface IOperandDropdownStateProps {
+    availableMeasures: IOperandDropdownItem[];
+    selectedMeasure: IOperandDropdownItem | null;
+}
+export interface IOperandDropdownDispatchProps {
+    onSelect: (localIdentifier: string, operandIndex: number, selectedMeasureLocalIdentifier: string) => void;
+    setHighlightedBucketItems: (bucketItemlocalIdentifiers: string[]) => void;
+    resetHighlightedBucketItems: () => void;
+}
+export type IOperandDropdownProps = IOperandDropdownOwnProps & IOperandDropdownStateProps & IOperandDropdownDispatchProps;
+export declare const OperandDropdownBase: import("react").MemoExoticComponent<({ selectedMeasure, availableMeasures, onSelect, localIdentifier, operandIndex, setHighlightedBucketItems, resetHighlightedBucketItems, }: IOperandDropdownProps) => ReactElement>;
+declare function createGetAvailableMeasuresSelector(): ((state: IAppState, props: IOperandDropdownOwnProps) => IOperandDropdownItem[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IDecoratedBucketItems, resultFuncArgs_1: string, resultFuncArgs_2: IBucketSequenceNumbers) => IOperandDropdownItem[];
+    memoizedResultFunc: ((resultFuncArgs_0: IDecoratedBucketItems, resultFuncArgs_1: string, resultFuncArgs_2: IBucketSequenceNumbers) => IOperandDropdownItem[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => IOperandDropdownItem[];
+    dependencies: [typeof getDecoratedMeasures, typeof getBucketItemLocalIdentifier, ((state: IAppState) => IBucketSequenceNumbers) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import("../../../../typings/buckets.js").IRawBucketItems) => IBucketSequenceNumbers;
+        memoizedResultFunc: ((resultFuncArgs_0: import("../../../../typings/buckets.js").IRawBucketItems) => IBucketSequenceNumbers) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => IBucketSequenceNumbers;
+        dependencies: [((state: IAppState) => import("../../../../typings/buckets.js").IRawBucketItems) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: import("../../../../typings/buckets.js").IRawBuckets) => import("../../../../typings/buckets.js").IRawBucketItems;
+            memoizedResultFunc: ((resultFuncArgs_0: import("../../../../typings/buckets.js").IRawBuckets) => import("../../../../typings/buckets.js").IRawBucketItems) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => import("../../../../typings/buckets.js").IRawBucketItems;
+            dependencies: [typeof import("../../../../services/buckets_service.js").getBuckets];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import("reselect").weakMapMemoize;
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare function createGetSelectedMeasureSelector(): ((state: IAppState, props: IOperandDropdownOwnProps) => IOperandDropdownItem | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IDecoratedBucketItems, resultFuncArgs_1: string, resultFuncArgs_2: number, resultFuncArgs_3: IBucketSequenceNumbers) => IOperandDropdownItem | null;
+    memoizedResultFunc: ((resultFuncArgs_0: IDecoratedBucketItems, resultFuncArgs_1: string, resultFuncArgs_2: number, resultFuncArgs_3: IBucketSequenceNumbers) => IOperandDropdownItem | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => IOperandDropdownItem | null;
+    dependencies: [typeof getDecoratedMeasures, typeof getBucketItemLocalIdentifier, typeof getOperandIndex, ((state: IAppState) => IBucketSequenceNumbers) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import("../../../../typings/buckets.js").IRawBucketItems) => IBucketSequenceNumbers;
+        memoizedResultFunc: ((resultFuncArgs_0: import("../../../../typings/buckets.js").IRawBucketItems) => IBucketSequenceNumbers) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => IBucketSequenceNumbers;
+        dependencies: [((state: IAppState) => import("../../../../typings/buckets.js").IRawBucketItems) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: import("../../../../typings/buckets.js").IRawBuckets) => import("../../../../typings/buckets.js").IRawBucketItems;
+            memoizedResultFunc: ((resultFuncArgs_0: import("../../../../typings/buckets.js").IRawBuckets) => import("../../../../typings/buckets.js").IRawBucketItems) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => import("../../../../typings/buckets.js").IRawBucketItems;
+            dependencies: [typeof import("../../../../services/buckets_service.js").getBuckets];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import("reselect").weakMapMemoize;
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getBucketItemLocalIdentifier: (_state: IAppState, props: IOperandDropdownOwnProps) => string;
+declare const getOperandIndex: (_state: IAppState, props: IOperandDropdownOwnProps) => number;
+export declare const OperandDropdown: import("react-redux").ConnectedComponent<import("react").MemoExoticComponent<({ selectedMeasure, availableMeasures, onSelect, localIdentifier, operandIndex, setHighlightedBucketItems, resetHighlightedBucketItems, }: IOperandDropdownProps) => ReactElement>, {
+    context?: import("react").Context<import("react-redux").ReactReduxContextValue<any, import("redux").UnknownAction> | null>;
+    store?: import("redux").Store;
+    localIdentifier: string;
+    operandIndex: number;
+}>;
+export declare const OperandDropdownTest: {
+    createGetAvailableMeasuresSelector: typeof createGetAvailableMeasuresSelector;
+    createGetSelectedMeasureSelector: typeof createGetSelectedMeasureSelector;
+};
+export {};
+//# sourceMappingURL=OperandDropdown.d.ts.map

package/esm/components/buckets/measures/arithmetic_measure/OperandDropdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperandDropdown.d.ts","sourceRoot":"","sources":["../../../../../src/components/buckets/measures/arithmetic_measure/OperandDropdown.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAA+B,MAAM,OAAO,CAAC;AAavE,OAAO,EACH,KAAK,sBAAsB,EAE9B,MAAM,4DAA4D,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAC;AAEzF,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAA6B,KAAK,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAIvG,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAI7E,MAAM,WAAW,wBAAwB;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,0BAA0B;IACvC,iBAAiB,EAAE,oBAAoB,EAAE,CAAC;IAC1C,eAAe,EAAE,oBAAoB,GAAG,IAAI,CAAC;CAChD;AAED,MAAM,WAAW,6BAA6B;IAC1C,QAAQ,EAAE,CAAC,eAAe,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,8BAA8B,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1G,yBAAyB,EAAE,CAAC,0BAA0B,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IAC1E,2BAA2B,EAAE,MAAM,IAAI,CAAC;CAC3C;AAED,MAAM,MAAM,qBAAqB,GAAG,wBAAwB,GACxD,0BAA0B,GAC1B,6BAA6B,CAAC;AAelC,eAAO,MAAM,mBAAmB,iLAQ7B,qBAAqB,KAAG,YAAY,CAoFrC,CAAC;AAoGH,iBAAS,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuB1C;AAED,iBAAS,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCxC;AAED,QAAA,MAAM,4BAA4B,WAAY,SAAS,SAAS,wBAAwB,KAAG,MAE1F,CAAC;AAEF,QAAA,MAAM,eAAe,WAAY,SAAS,SAAS,wBAAwB,KAAG,MAE7E,CAAC;AAEF,eAAO,MAAM,eAAe,0NA5PzB,qBAAqB,KAAG,YAAY;;;qBAxClB,MAAM;kBACT,MAAM;EA2SF,CAAC;AAEvB,eAAO,MAAM,mBAAmB;;;CAG/B,CAAC"}