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

package/esm/components/filterBar/DraggableFilterItem.d.ts

@@ -0,0 +1,19 @@
+import { type IFilterBarItem } from "../../store/filter_bar/filter_bar_types.js";
+interface IDragSourceProps {
+    isDragging?: boolean;
+}
+interface IDraggableFilterItemOwnProps {
+    filterItem: IFilterBarItem;
+    isHighlighted: boolean;
+    /** the store's auto-open hand-over names this filter: its picker opens right away */
+    isAutoOpen?: boolean;
+    onStartFilterItemDrag: (filter: IFilterBarItem) => void;
+    onEndFilterItemDrag: () => void;
+}
+export type IDraggableFilterItemProps = IDraggableFilterItemOwnProps & IDragSourceProps;
+export declare const DraggableFilterItem: import("react").MemoExoticComponent<({ filterItem, isHighlighted, isAutoOpen, isDragging: isDraggingProp, onStartFilterItemDrag, onEndFilterItemDrag, }: IDraggableFilterItemProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const DraggableFilterItemTest: {
+    DraggableFilterItem: import("react").MemoExoticComponent<({ filterItem, isHighlighted, isAutoOpen, isDragging: isDraggingProp, onStartFilterItemDrag, onEndFilterItemDrag, }: IDraggableFilterItemProps) => import("react/jsx-runtime").JSX.Element>;
+};
+export {};
+//# sourceMappingURL=DraggableFilterItem.d.ts.map

package/esm/components/filterBar/DraggableFilterItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DraggableFilterItem.d.ts","sourceRoot":"","sources":["../../../src/components/filterBar/DraggableFilterItem.tsx"],"names":[],"mappings":"AAUA,OAAO,EAAa,KAAK,cAAc,EAAE,MAAM,4CAA4C,CAAC;AAY5F,UAAU,gBAAgB;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,UAAU,4BAA4B;IAClC,UAAU,EAAE,cAAc,CAAC;IAC3B,aAAa,EAAE,OAAO,CAAC;IACvB,qFAAqF;IACrF,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,qBAAqB,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IACxD,mBAAmB,EAAE,MAAM,IAAI,CAAC;CACnC;AAED,MAAM,MAAM,yBAAyB,GAAG,4BAA4B,GAAG,gBAAgB,CAAC;AAExF,eAAO,MAAM,mBAAmB,2JAO7B,yBAAyB,6CAiH1B,CAAC;AAEH,eAAO,MAAM,uBAAuB;kLAnHjC,yBAAyB;CAqH3B,CAAC"}

package/esm/components/filterBar/DraggableFilterItem.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { memo, useCallback, useEffect, useState } from "react";
+import { useDrag } from "@evil-internetmann/react-dnd";
+import classNames from "classnames";
+import { useDispatch } from "react-redux";
+import { BUCKET_ITEM, FILTER_ITEM } from "../../constants/drag_item_types.js";
+import { storeFilterBarAutoOpen } from "../../store/filter_bar/filter_bar_actions.js";
+import { FilterBar } from "../../store/filter_bar/filter_bar_types.js";
+import { isParameterFilter } from "../../store/filter_bar/parameter_filter_types.js";
+import { AttributeFilterItemPure as AttributeFilterItem } from "./AttributeFilterItem.js";
+import { DateFilterItem } from "./dateFilter/DateFilterItem.js";
+import { FilterItemDragLayer } from "./FilterItemDragLayer.js";
+import { MeasureValueFilterItem } from "./MeasureValueFilterItem.js";
+import { ParameterFilterItem } from "./parameterFilter/ParameterFilterItem.js";
+import { RankingFilterItem } from "./rankingFilter/RankingFilterItem.js";
+export const DraggableFilterItem = memo(function DraggableFilterItem({ filterItem, isHighlighted, isAutoOpen = false, isDragging: isDraggingProp, onStartFilterItemDrag, onEndFilterItemDrag, }) {
+    const [hover, setHover] = useState(false);
+    const dispatch = useDispatch();
+    // The store keeps the hand-over until THIS picker closes, so a picker the user closed stays closed.
+    // Only the current owner clears it: a newer add has already taken it over, and that one is still
+    // waiting to open.
+    const onPickerClose = useCallback(() => {
+        if (isAutoOpen) {
+            dispatch(storeFilterBarAutoOpen(null));
+        }
+    }, [isAutoOpen, dispatch]);
+    useEffect(() => {
+        if (isDraggingProp) {
+            // not hovering anymore, but browser thinks it is
+            // prove him wrong!
+            setHover(false);
+        }
+    }, [isDraggingProp]);
+    const [{ isDragging }, dragRef] = useDrag(() => ({
+        type: BUCKET_ITEM,
+        item: () => {
+            function renderDraggedItemElement() {
+                return _jsx(FilterItemDragLayer, { filter: filterItem });
+            }
+            onStartFilterItemDrag(filterItem);
+            return {
+                dragItemType: FILTER_ITEM,
+                itemType: filterItem.type,
+                itemLocalIdentifier: filterItem.localIdentifier,
+                renderDraggedItemElement,
+            };
+        },
+        end: () => {
+            onEndFilterItemDrag();
+        },
+        collect: (monitor) => ({
+            isDragging: monitor.isDragging(),
+        }),
+    }), [filterItem, onStartFilterItemDrag, onEndFilterItemDrag]);
+    const renderFilterComponent = () => {
+        const classes = classNames({
+            "adi-filter-button-hover": hover,
+            "is-dragging": isDragging,
+        });
+        if (FilterBar.isDateFilter(filterItem)) {
+            return (_jsx(DateFilterItem, { filter: filterItem, className: classes, isHighlighted: isHighlighted, isAutoOpen: isAutoOpen, onClose: onPickerClose }));
+        }
+        else if (FilterBar.isAttributeFilter(filterItem)) {
+            return (_jsx(AttributeFilterItem, { filterLocalIdentifier: filterItem.localIdentifier, isHighlighted: isHighlighted, isAutoOpen: isAutoOpen, onClose: onPickerClose }));
+        }
+        else if (FilterBar.isMeasureValueFilter(filterItem)) {
+            return (_jsx(MeasureValueFilterItem, { filter: filterItem, className: classes, isHighlighted: isHighlighted, isAutoOpen: isAutoOpen, onClose: onPickerClose }));
+        }
+        else if (FilterBar.isRankingFilter(filterItem)) {
+            return (_jsx(RankingFilterItem, { filter: filterItem, className: classes, isHighlighted: isHighlighted, isAutoOpen: isAutoOpen, onClose: onPickerClose }));
+        }
+        else if (isParameterFilter(filterItem)) {
+            return (_jsx(ParameterFilterItem, { filter: filterItem, className: classes, isHighlighted: isHighlighted }));
+        }
+        return null;
+    };
+    const onMouseOver = () => {
+        setHover(true);
+    };
+    const onMouseOut = () => {
+        setHover(false);
+    };
+    return (_jsx("li", { ref: dragRef, onMouseOver: onMouseOver, onMouseOut: onMouseOut, children: renderFilterComponent() }));
+});
+export const DraggableFilterItemTest = {
+    DraggableFilterItem,
+};

package/esm/components/filterBar/FilterBar.d.ts

@@ -0,0 +1,4 @@
+export declare function FilterBar({ isSmallScreen }: {
+    isSmallScreen?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FilterBar.d.ts.map

package/esm/components/filterBar/FilterBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterBar.d.ts","sourceRoot":"","sources":["../../../src/components/filterBar/FilterBar.tsx"],"names":[],"mappings":"AAiCA,wBAAgB,SAAS,CAAC,EAAE,aAAa,EAAE,EAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,2CAwCvE"}

package/esm/components/filterBar/FilterBar.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2019-2026 GoodData Corporation
+import { useCallback, useEffect, useRef } from "react";
+import classNames from "classnames";
+import { useDispatch, useSelector } from "react-redux";
+import { setMultilineFilterBar } from "../../sagas/filter_bar/filter_bar_ui_actions.js";
+import { getFilterItemsWithoutAdditionalDateAttributes, getParameterFilters, isMultiline as isMultilineSelector, } from "../../store/filter_bar/filter_bar_selector.js";
+import { useWindowResize } from "../../utils/hooks/WindowResizeHook.js";
+import { FilterBarHeader } from "./FilterBarHeader.js";
+import { FilterBarList } from "./FilterBarList.js";
+const RESIZE_EVENT_DEBOUNCE_MILLISECONDS = 120;
+const isElementMultiline = (element) => {
+    if (!element) {
+        return false;
+    }
+    const style = window.getComputedStyle(element);
+    const minHeight = parseInt(style.getPropertyValue("min-height"), 10);
+    const currentHeight = parseInt(style.getPropertyValue("height"), 10);
+    return currentHeight > minHeight;
+};
+export function FilterBar({ isSmallScreen }) {
+    const filterItems = useSelector(getFilterItemsWithoutAdditionalDateAttributes);
+    const parameterItems = useSelector(getParameterFilters);
+    const isMultiline = useSelector(isMultilineSelector) ?? false;
+    const dispatch = useDispatch();
+    const setMultiline = useCallback((multilineValue) => dispatch(setMultilineFilterBar(multilineValue)), [dispatch]);
+    const wrapperElement = useRef(null);
+    const checkMultiline = useCallback(() => {
+        if (isElementMultiline(wrapperElement.current) !== isMultiline) {
+            setMultiline(!isMultiline);
+        }
+    }, [isMultiline, setMultiline, wrapperElement]);
+    useEffect(checkMultiline, [filterItems, parameterItems, checkMultiline]);
+    useWindowResize(checkMultiline, RESIZE_EVENT_DEBOUNCE_MILLISECONDS);
+    const isEmpty = filterItems.length + parameterItems.length === 0;
+    return (_jsxs("div", { className: classNames("adi-bucket", "adi-filter-bucket", "s-bucket-filters", {
+            "s-bucket-empty": isEmpty,
+            "s-bucket-not-empty": !isEmpty,
+        }), ref: wrapperElement, children: [_jsx(FilterBarHeader, {}), _jsx(FilterBarList, { filterItems: filterItems, parameterItems: parameterItems, isSmallScreen: isSmallScreen })] }));
+}

package/esm/components/filterBar/FilterBarHeader.d.ts

@@ -0,0 +1,2 @@
+export declare function FilterBarHeader(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FilterBarHeader.d.ts.map

package/esm/components/filterBar/FilterBarHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterBarHeader.d.ts","sourceRoot":"","sources":["../../../src/components/filterBar/FilterBarHeader.tsx"],"names":[],"mappings":"AAIA,wBAAgB,eAAe,4CAM9B"}

package/esm/components/filterBar/FilterBarHeader.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { FormattedMessage } from "react-intl";
+export function FilterBarHeader() {
+    return (_jsx("h2", { className: "adi-filter-bucket-header", children: _jsx(FormattedMessage, { id: "filters" }) }));
+}

package/esm/components/filterBar/FilterBarList.d.ts

@@ -0,0 +1,18 @@
+import { type IFilter, type IFilterBarItem } from "../../store/filter_bar/filter_bar_types.js";
+import { type IParameterFilter } from "../../store/filter_bar/parameter_filter_types.js";
+interface IFilterBarListStateProps {
+    highlightedFilterLocalIdentifier: string | undefined;
+}
+interface IFilterBarListOwnProps {
+    filterItems: ReadonlyArray<IFilter>;
+    parameterItems: ReadonlyArray<IParameterFilter>;
+    isSmallScreen?: boolean;
+}
+interface IFilterBarListDispatchProps {
+    onStartFilterItemDrag: (filter: IFilterBarItem) => void;
+    onEndFilterItemDrag: () => void;
+}
+export type IFilterBarListProps = IFilterBarListOwnProps & IFilterBarListStateProps & IFilterBarListDispatchProps;
+export declare function FilterBarList({ filterItems, parameterItems, isSmallScreen }: IFilterBarListOwnProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=FilterBarList.d.ts.map

package/esm/components/filterBar/FilterBarList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterBarList.d.ts","sourceRoot":"","sources":["../../../src/components/filterBar/FilterBarList.tsx"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,4CAA4C,CAAC;AAC/F,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,kDAAkD,CAAC;AAQzF,UAAU,wBAAwB;IAC9B,gCAAgC,EAAE,MAAM,GAAG,SAAS,CAAC;CACxD;AAED,UAAU,sBAAsB;IAC5B,WAAW,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACpC,cAAc,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;IAChD,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,UAAU,2BAA2B;IACjC,qBAAqB,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IACxD,mBAAmB,EAAE,MAAM,IAAI,CAAC;CACnC;AAED,MAAM,MAAM,mBAAmB,GAAG,sBAAsB,GACpD,wBAAwB,GACxB,2BAA2B,CAAC;AAEhC,wBAAgB,aAAa,CAAC,EAAE,WAAW,EAAE,cAAc,EAAE,aAAa,EAAE,EAAE,sBAAsB,2CAsCnG"}

package/esm/components/filterBar/FilterBarList.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useCallback } from "react";
+import { useDispatch, useSelector } from "react-redux";
+import { endDragFilterItem, startDragFilterItem } from "../../sagas/drag_and_drop/drag_and_drop_actions.js";
+import { getFilterBarAutoOpenFilter } from "../../selectors/filter_bar_auto_open_selector.js";
+import { getHighlightedFilterItem } from "../../store/highlighting/highlighting_selector.js";
+import { DraggableFilterItem } from "./DraggableFilterItem.js";
+import { FilterBarDropdown } from "./filterBarDropdown/FilterBarDropdown.js";
+import { PureFilterBarDropTarget as FilterBarDropTarget } from "./filterBarDropTarget/FilterBarDropTarget.js";
+export function FilterBarList({ filterItems, parameterItems, isSmallScreen }) {
+    const highlightedFilterLocalIdentifier = useSelector(getHighlightedFilterItem);
+    const autoOpenFilterLocalIdentifier = useSelector(getFilterBarAutoOpenFilter);
+    const dispatch = useDispatch();
+    const onStartFilterItemDrag = useCallback((filter) => dispatch(startDragFilterItem(filter)), [dispatch]);
+    const onEndFilterItemDrag = useCallback(() => dispatch(endDragFilterItem()), [dispatch]);
+    return (_jsxs("ul", { className: "adi-filter-bucket-list", children: [[...filterItems, ...parameterItems].map((item) => {
+                const isHighlighted = item.localIdentifier === highlightedFilterLocalIdentifier;
+                // the store owns the hand-over until that picker closes; a newer add overwrites it, so
+                // the older item's prop turns false before its picker could open
+                const isAutoOpen = item.localIdentifier === autoOpenFilterLocalIdentifier;
+                return (_jsx(DraggableFilterItem, { filterItem: item, isHighlighted: isHighlighted, isAutoOpen: isAutoOpen, onStartFilterItemDrag: onStartFilterItemDrag, onEndFilterItemDrag: onEndFilterItemDrag }, item.localIdentifier));
+            }), _jsx("li", { children: _jsxs("div", { className: "adi-filter-manage", children: [_jsx(FilterBarDropTarget, { isSmallScreen: isSmallScreen }), _jsx(FilterBarDropdown, {})] }) })] }));
+}

package/esm/components/filterBar/FilterItem.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from "react";
+interface IFilterItemProps {
+    identifier: string;
+    className?: string;
+    children: ReactNode;
+}
+export declare const FilterItem: import("react").MemoExoticComponent<({ identifier, className, children }: IFilterItemProps) => import("react/jsx-runtime").JSX.Element>;
+export {};
+//# sourceMappingURL=FilterItem.d.ts.map

package/esm/components/filterBar/FilterItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterItem.d.ts","sourceRoot":"","sources":["../../../src/components/filterBar/FilterItem.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,OAAO,CAAC;AAM1D,UAAU,gBAAgB;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,SAAS,CAAC;CACvB;AAED,eAAO,MAAM,UAAU,4EAAiE,gBAAgB,6CAYtG,CAAC"}

package/esm/components/filterBar/FilterItem.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { memo, useCallback } from "react";
+import classNames from "classnames";
+import { simplifyText } from "@gooddata/util";
+export const FilterItem = memo(function FilterItem({ identifier, className, children }) {
+    const getClassNames = useCallback(() => {
+        const simplifiedIdentifier = simplifyText(identifier);
+        return classNames(["adi-bucket-item", "adi-filter-item-wrapper", "s-bucket-item", "s-attr-filter"], `s-id-${simplifiedIdentifier}`, className);
+    }, [identifier, className]);
+    return _jsx("div", { className: getClassNames(), children: children });
+});

package/esm/components/filterBar/FilterItemDragLayer.d.ts

@@ -0,0 +1,6 @@
+import { type IFilterBarItem } from "../../store/filter_bar/filter_bar_types.js";
+export interface IFilterItemDragLayerProps {
+    readonly filter: IFilterBarItem;
+}
+export declare const FilterItemDragLayer: import("react").MemoExoticComponent<({ filter }: IFilterItemDragLayerProps) => import("react/jsx-runtime").JSX.Element | null>;
+//# sourceMappingURL=FilterItemDragLayer.d.ts.map

package/esm/components/filterBar/FilterItemDragLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterItemDragLayer.d.ts","sourceRoot":"","sources":["../../../src/components/filterBar/FilterItemDragLayer.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAa,KAAK,cAAc,EAAE,MAAM,4CAA4C,CAAC;AAS5F,MAAM,WAAW,yBAAyB;IACtC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;CACnC;AAED,eAAO,MAAM,mBAAmB,mDAAiD,yBAAyB,oDAkBxG,CAAC"}

package/esm/components/filterBar/FilterItemDragLayer.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { memo } from "react";
+import { FilterBar } from "../../store/filter_bar/filter_bar_types.js";
+import { isParameterFilter } from "../../store/filter_bar/parameter_filter_types.js";
+import { AttributeFilterDragItem } from "../AttributeFilter/components/AttributeFilterDragItem.js";
+import { DateFilterItem } from "./dateFilter/DateFilterItem.js";
+import { MeasureValueFilterItem } from "./MeasureValueFilterItem.js";
+import { ParameterFilterDragItem } from "./parameterFilter/ParameterFilterDragItem.js";
+import { RankingFilterItem } from "./rankingFilter/RankingFilterItem.js";
+export const FilterItemDragLayer = memo(function FilterItemDragLayer({ filter }) {
+    if (FilterBar.isDateFilter(filter)) {
+        return _jsx(DateFilterItem, { filter: filter, className: "adi-filter-button-hover", isDraggedItem: true });
+    }
+    else if (FilterBar.isAttributeFilter(filter)) {
+        return (_jsx(AttributeFilterDragItem, { filterLocalIdentifier: filter.localIdentifier }, filter.localIdentifier));
+    }
+    else if (FilterBar.isMeasureValueFilter(filter)) {
+        return _jsx(MeasureValueFilterItem, { filter: filter, className: "adi-filter-button-hover", isDraggedItem: true });
+    }
+    else if (FilterBar.isRankingFilter(filter)) {
+        return _jsx(RankingFilterItem, { filter: filter, className: "adi-filter-button-hover" });
+    }
+    else if (isParameterFilter(filter)) {
+        return _jsx(ParameterFilterDragItem, { filter: filter });
+    }
+    return null;
+});

package/esm/components/filterBar/MeasureValueFilterItem.d.ts

@@ -0,0 +1,73 @@
+import { type ObjRef } from "@gooddata/sdk-model";
+import { type ISeparators } from "@gooddata/sdk-ui";
+import { type IBucketItemDescriptors } from "@gooddata/sdk-ui-kit";
+import { type IMeasuresDescriptions } from "../../models/decorated_bucket_item.js";
+import { getInsightWithBucketsViaMd } from "../../selectors/insight_selectors.js";
+import { type IBucketSequenceNumbers } from "../../selectors/measure_sequence_numbers_selector.js";
+import { type IMeasureValueFilter } from "../../store/filter_bar/filter_bar_types.js";
+import type { ICatalogEntries } from "../../typings/state_objects.js";
+export interface IMeasureValueFilterItemOwnProps {
+    filter: IMeasureValueFilter;
+    className?: string;
+    isHighlighted?: boolean;
+    isDraggedItem?: boolean;
+    /** the user just added this filter, so its dropdown opens right away */
+    isAutoOpen?: boolean;
+    onClose?: () => void;
+}
+interface IMeasureValueFilterItemLabelStateProps {
+    measureDescriptions: IMeasuresDescriptions;
+    measureSequenceNumbers: IBucketSequenceNumbers;
+    itemCache: ICatalogEntries;
+    separators: ISeparators;
+    isVisualizationStackingToPercent: boolean;
+    isOptionalStackingDisabled: boolean;
+    secondaryAxisMeasures: string[];
+    aboutToBeRemovedBucketAndFilterItems: string[] | undefined;
+    enableOperatorSelection: boolean;
+    enableRankingWithMvf: boolean;
+    computedAttributesEnabled: boolean;
+    bucketItemNames: IBucketItemDescriptors;
+    insightDimensionalityItems: IBucketItemDescriptors;
+    projectId: string;
+    insight: ReturnType<typeof getInsightWithBucketsViaMd>;
+    datasetId: string | undefined;
+    includeObjectsWithTags: ObjRef[] | undefined;
+    excludeObjectsWithTags: ObjRef[] | undefined;
+}
+interface IMeasureValueFilterItemDispatchProps {
+    updateMeasureValueFilter: (filter: IMeasureValueFilter) => void;
+    onDropdownOpened: (filter: IMeasureValueFilter) => void;
+}
+export type IMeasureValueFilterItemProps = IMeasureValueFilterItemOwnProps & IMeasureValueFilterItemDispatchProps & IMeasureValueFilterItemLabelStateProps;
+export declare function MeasureValueFilterItemBase({ filter, className, updateMeasureValueFilter, measureDescriptions, isHighlighted, measureSequenceNumbers, onDropdownOpened, separators, isVisualizationStackingToPercent, isOptionalStackingDisabled, secondaryAxisMeasures, aboutToBeRemovedBucketAndFilterItems, isDraggedItem, isAutoOpen, onClose, enableOperatorSelection, enableRankingWithMvf, computedAttributesEnabled, itemCache, bucketItemNames, insightDimensionalityItems, projectId, insight, datasetId, includeObjectsWithTags, excludeObjectsWithTags, }: IMeasureValueFilterItemProps): import("react/jsx-runtime").JSX.Element;
+export declare const MeasureValueFilterItem: import("react-redux").ConnectedComponent<typeof MeasureValueFilterItemBase, {
+    context?: import("react").Context<import("react-redux").ReactReduxContextValue<any, import("redux").UnknownAction> | null>;
+    store?: import("redux").Store;
+    filter: IMeasureValueFilter;
+    className?: string;
+    isHighlighted?: boolean;
+    isDraggedItem?: boolean;
+    isAutoOpen?: boolean;
+    onClose?: () => void;
+    measureDescriptions: IMeasuresDescriptions;
+    measureSequenceNumbers: IBucketSequenceNumbers;
+    itemCache: ICatalogEntries;
+    separators: ISeparators;
+    isVisualizationStackingToPercent: boolean;
+    isOptionalStackingDisabled: boolean;
+    secondaryAxisMeasures: string[];
+    aboutToBeRemovedBucketAndFilterItems: string[] | undefined;
+    enableOperatorSelection: boolean;
+    enableRankingWithMvf: boolean;
+    computedAttributesEnabled: boolean;
+    bucketItemNames: IBucketItemDescriptors;
+    insightDimensionalityItems: IBucketItemDescriptors;
+    projectId: string;
+    insight: ReturnType<typeof getInsightWithBucketsViaMd>;
+    datasetId: string | undefined;
+    includeObjectsWithTags: ObjRef[] | undefined;
+    excludeObjectsWithTags: ObjRef[] | undefined;
+}>;
+export {};
+//# sourceMappingURL=MeasureValueFilterItem.d.ts.map

package/esm/components/filterBar/MeasureValueFilterItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeasureValueFilterItem.d.ts","sourceRoot":"","sources":["../../../src/components/filterBar/MeasureValueFilterItem.tsx"],"names":[],"mappings":"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"}

package/esm/components/filterBar/MeasureValueFilterItem.js

@@ -0,0 +1,151 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import classNames from "classnames";
+import { useIntl } from "react-intl";
+import { connect } from "react-redux";
+import { createStructuredSelector } from "reselect";
+import { areObjRefsEqual, isMeasureValueFilter, objRefToString, } from "@gooddata/sdk-model";
+import { MeasureValueFilterDropdown } from "@gooddata/sdk-ui-filters";
+import { getProjectId, getSeparators } from "../../selectors/bootstrap_selector.js";
+import { getMeasureDescriptions } from "../../selectors/buckets_selector.js";
+import { enableComputedAttributes, enableRankingWithMvf } from "../../selectors/feature_flag_selector.js";
+import { getInsightWithBucketsViaMd } from "../../selectors/insight_selectors.js";
+import { getItemCache } from "../../selectors/item_cache_selector.js";
+import { getMeasureSequenceNumbers, } from "../../selectors/measure_sequence_numbers_selector.js";
+import { isExtendedReferencePointStackingToPercent, isOptionalStackingDisabled, } from "../../selectors/optional_stacking_selector.js";
+import { getTagsConfiguration } from "../../selectors/route_selector.js";
+import { measureValueFilterConfigurationOpened, updateMeasureValueFilter, } from "../../store/bucket_filters/bucket_filters_actions.js";
+import { hasRankingFilter } from "../../store/filter_bar/filter_bar_selector.js";
+import { FilterBar } from "../../store/filter_bar/filter_bar_types.js";
+import { getAboutToBeRemovedBucketAndFilterItems } from "../../store/highlighting/highlighting_selector.js";
+import { getRouteParams } from "../../utils/location.js";
+import { isPercentageFormat } from "../../utils/measure_descriptions.js";
+import { getAttributeItems, getBucketItemNames } from "../sort/chart_sort_bucket_items.js";
+import { FilterItem } from "./FilterItem.js";
+import { buildMvfAvailabilityItems, buildVisualizationFilter, getMeasureIdentifier, getSecondaryAxisMeasures, getWarningMessage, updateFilterCondition, } from "./measure_value_filter_item_utils.js";
+import { MeasureValueFilterDropdownButton } from "./MeasureValueFilterItemDropdownButton.js";
+import { useFilterDimensionality } from "./useFilterDimensionality.js";
+const mapStateToProps = () => {
+    return createStructuredSelector({
+        measureDescriptions: getMeasureDescriptions,
+        measureSequenceNumbers: getMeasureSequenceNumbers,
+        separators: getSeparators,
+        isVisualizationStackingToPercent: isExtendedReferencePointStackingToPercent,
+        isOptionalStackingDisabled: isOptionalStackingDisabled,
+        secondaryAxisMeasures: getSecondaryAxisMeasures,
+        aboutToBeRemovedBucketAndFilterItems: getAboutToBeRemovedBucketAndFilterItems,
+        enableOperatorSelection: (state) => enableRankingWithMvf(state) || !hasRankingFilter(state),
+        enableRankingWithMvf,
+        computedAttributesEnabled: enableComputedAttributes,
+        itemCache: getItemCache,
+        bucketItemNames: getBucketItemNames,
+        insightDimensionalityItems: getAttributeItems,
+        projectId: getProjectId,
+        insight: getInsightWithBucketsViaMd,
+        datasetId: (state) => getRouteParams(state).dataset,
+        includeObjectsWithTags: (state) => getTagsConfiguration(state).includeObjectsWithTags,
+        excludeObjectsWithTags: (state) => getTagsConfiguration(state).excludeObjectsWithTags,
+    });
+};
+const mapDispatchToProps = {
+    updateMeasureValueFilter,
+    onDropdownOpened: measureValueFilterConfigurationOpened,
+};
+const getCatalogMetricTitle = (itemCache, metricIdentifier) => metricIdentifier ? itemCache?.[`metric.${objRefToString(metricIdentifier)}`]?.title : undefined;
+const getCatalogMetricFormat = (itemCache, metricIdentifier) => metricIdentifier ? itemCache?.[`metric.${objRefToString(metricIdentifier)}`]?.format : undefined;
+// Rewrites this MVF on the insight passed to date-dataset loading so it carries the in-progress
+// dimensionality; other insight filters pass through unchanged.
+const applyDimensionalityToMvf = (insightFilter, filter, override) => {
+    const currentFilter = buildVisualizationFilter(filter);
+    return isMeasureValueFilter(insightFilter) &&
+        areObjRefsEqual(insightFilter.measureValueFilter.measure, currentFilter.measureValueFilter.measure)
+        ? { measureValueFilter: { ...currentFilter.measureValueFilter, dimensionality: override } }
+        : insightFilter;
+};
+export function MeasureValueFilterItemBase({ filter, className, updateMeasureValueFilter, measureDescriptions, isHighlighted, measureSequenceNumbers, onDropdownOpened, separators, isVisualizationStackingToPercent, isOptionalStackingDisabled, secondaryAxisMeasures, aboutToBeRemovedBucketAndFilterItems, isDraggedItem, isAutoOpen = false, onClose, enableOperatorSelection, enableRankingWithMvf, computedAttributesEnabled, itemCache, bucketItemNames, insightDimensionalityItems, projectId, insight, datasetId, includeObjectsWithTags, excludeObjectsWithTags, }) {
+    const intl = useIntl();
+    const [displayDropdown, setDisplayDropdown] = useState(false);
+    const filterButtonElement = useRef(null);
+    const buttonElement = useRef(null);
+    const closeDropdown = useCallback(() => {
+        filterButtonElement.current = null;
+        setDisplayDropdown(false);
+        onClose?.();
+    }, [onClose]);
+    const onClick = useCallback((e) => {
+        if (displayDropdown) {
+            closeDropdown();
+            return;
+        }
+        filterButtonElement.current = e.currentTarget;
+        setDisplayDropdown(true);
+        onDropdownOpened(filter);
+    }, [displayDropdown, filter, onDropdownOpened, closeDropdown]);
+    // A filter the user just added opens its dropdown right away. An effect rather than initial state,
+    // because the dropdown is anchored to the button element, which exists only after mount. Only the
+    // rising edge of isAutoOpen opens it: the filter (and so the opened callback) changes on apply.
+    useEffect(() => {
+        if (isAutoOpen && buttonElement.current) {
+            filterButtonElement.current = buttonElement.current;
+            setDisplayDropdown(true);
+            onDropdownOpened(filter);
+        }
+        // oxlint-disable-next-line react-hooks/exhaustive-deps
+    }, [isAutoOpen]);
+    const onApply = useCallback((updatedAfmFilter) => {
+        updateMeasureValueFilter(updateFilterCondition(filter, updatedAfmFilter));
+        closeDropdown();
+    }, 
+    // oxlint-disable-next-line react-hooks/exhaustive-deps
+    [filter]);
+    const visualizationFilter = useMemo(() => buildVisualizationFilter(filter), [filter]);
+    // Shared catalog-dimensionality wiring (also used by the ranking filter). The availability builder and
+    // the in-progress-insight rewrite (applyDimensionalityToMvf) are the only per-filter pieces.
+    const { insightDimensionality, toTitledItems, loadCatalogDimensionality } = useFilterDimensionality({
+        insight,
+        insightDimensionalityItems,
+        itemCache,
+        bucketItemNames,
+        projectId,
+        datasetId,
+        includeObjectsWithTags,
+        excludeObjectsWithTags,
+        filter,
+        buildAvailabilityItems: buildMvfAvailabilityItems,
+        applyOverrideToInsightFilter: applyDimensionalityToMvf,
+        computedAttributesEnabled,
+    });
+    // Build dimensionality items with resolved titles and types for the dropdown
+    const dimensionalityWithTitles = useMemo(() => toTitledItems(visualizationFilter.measureValueFilter.dimensionality), [toTitledItems, visualizationFilter.measureValueFilter.dimensionality]);
+    const measureIdentifier = getMeasureIdentifier(filter);
+    const measureDesc = measureDescriptions[measureIdentifier];
+    const { title, alias, showInPercent } = measureDesc ?? {};
+    const catalogMetricName = getCatalogMetricTitle(itemCache, filter.measureRef);
+    const catalogMetricFormat = measureDesc
+        ? undefined
+        : getCatalogMetricFormat(itemCache, filter.measureRef);
+    const isFormattedAsPercentage = measureDesc?.isFormattedAsPercentage ??
+        (catalogMetricFormat ? isPercentageFormat(catalogMetricFormat) : false);
+    const format = measureDesc?.format ?? catalogMetricFormat;
+    const measureTitle = alias || title || catalogMetricName || filter.measureLocalIdentifier;
+    // Catalog measures (not in buckets) cannot be stacked to percent since they're not part of the visualization.
+    // For bucket measures, check if stacking is enabled and the measure is NOT on the secondary axis.
+    // Note: secondaryAxisMeasures contains local identifiers, which only match bucket measures.
+    const isMeasureStackedToPercent = !FilterBar.isCatalogMeasureValueFilter(filter) &&
+        isVisualizationStackingToPercent &&
+        !isOptionalStackingDisabled &&
+        !secondaryAxisMeasures.some((secondaryAxisMeasure) => secondaryAxisMeasure === measureIdentifier);
+    const displayPercentWarningMessage = showInPercent || isMeasureStackedToPercent;
+    const warningMessage = getWarningMessage(intl, !enableOperatorSelection, displayPercentWarningMessage);
+    const usePercentage = isFormattedAsPercentage && !showInPercent && !isMeasureStackedToPercent;
+    const filterItemClassNames = useMemo(() => {
+        const isAboutToBeRemoved = aboutToBeRemovedBucketAndFilterItems?.includes(filter.localIdentifier);
+        return classNames("adi-metric-value-filter s-metric-value-filter-item", {
+            highlight: isHighlighted,
+            "about-to-be-removed": isAboutToBeRemoved,
+        });
+    }, [isHighlighted, aboutToBeRemovedBucketAndFilterItems, filter]);
+    return (_jsxs(FilterItem, { identifier: measureIdentifier, className: filterItemClassNames, children: [_jsx(MeasureValueFilterDropdownButton, { measureTitle: measureTitle, sequenceNumber: measureSequenceNumbers[measureIdentifier], filter: filter, usePercentage: usePercentage, warningMessage: warningMessage, isActive: displayDropdown, onClick: onClick, buttonRef: buttonElement, separators: separators, className: className, isDraggedItem: isDraggedItem, dimensionality: dimensionalityWithTitles }), displayDropdown ? (_jsx(MeasureValueFilterDropdown, { onApply: onApply, onCancel: closeDropdown, usePercentage: usePercentage, warningMessage: warningMessage, filter: visualizationFilter, anchorEl: filterButtonElement.current, separators: separators, format: format, useShortFormat: true, locale: intl.locale, displayTreatNullAsZeroOption: true, treatNullAsZeroDefaultValue: false, measureIdentifier: measureIdentifier, measureTitle: measureTitle, enableOperatorSelection: enableOperatorSelection, dimensionality: dimensionalityWithTitles, insightDimensionality: insightDimensionality, isDimensionalityEnabled: true, loadCatalogDimensionality: loadCatalogDimensionality, enableMultipleConditions: true, enableRankingWithMvf: enableRankingWithMvf })) : null] }));
+}
+export const MeasureValueFilterItem = connect(mapStateToProps, mapDispatchToProps)(MeasureValueFilterItemBase);

package/esm/components/filterBar/MeasureValueFilterItemDropdownButton.d.ts

@@ -0,0 +1,21 @@
+import { type Ref, type SyntheticEvent } from "react";
+import { type ISeparators } from "@gooddata/sdk-ui";
+import { type IDimensionalityItem, type WarningMessage } from "@gooddata/sdk-ui-filters";
+import { type IMeasureValueFilter } from "../../store/filter_bar/filter_bar_types.js";
+export interface IMeasureValueFilterDropdownButtonProps {
+    measureTitle: string;
+    sequenceNumber: number;
+    filter: IMeasureValueFilter;
+    isActive: boolean;
+    usePercentage: boolean;
+    warningMessage: WarningMessage;
+    onClick: (event: SyntheticEvent) => void;
+    /** the button element, which the dropdown is anchored to when it is opened without a click */
+    buttonRef?: Ref<HTMLDivElement>;
+    separators?: ISeparators;
+    className?: string;
+    isDraggedItem?: boolean;
+    dimensionality?: IDimensionalityItem[];
+}
+export declare function MeasureValueFilterDropdownButton({ measureTitle, usePercentage, warningMessage, onClick, buttonRef, isActive, className, filter: { conditions }, sequenceNumber, separators, isDraggedItem, dimensionality, }: IMeasureValueFilterDropdownButtonProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=MeasureValueFilterItemDropdownButton.d.ts.map

package/esm/components/filterBar/MeasureValueFilterItemDropdownButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeasureValueFilterItemDropdownButton.d.ts","sourceRoot":"","sources":["../../../src/components/filterBar/MeasureValueFilterItemDropdownButton.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,cAAc,EAAW,MAAM,OAAO,CAAC;AAK/D,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,cAAc,EAAoB,MAAM,0BAA0B,CAAC;AAG3G,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAItF,MAAM,WAAW,sCAAsC;IACnD,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,QAAQ,EAAE,OAAO,CAAC;IAClB,aAAa,EAAE,OAAO,CAAC;IACvB,cAAc,EAAE,cAAc,CAAC;IAC/B,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;IACzC,8FAA8F;IAC9F,SAAS,CAAC,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC;IAChC,UAAU,CAAC,EAAE,WAAW,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,cAAc,CAAC,EAAE,mBAAmB,EAAE,CAAC;CAC1C;AA6BD,wBAAgB,gCAAgC,CAAC,EAC7C,YAAY,EACZ,aAAa,EACb,cAAc,EACd,OAAO,EACP,SAAS,EACT,QAAQ,EACR,SAAS,EACT,MAAM,EAAE,EAAE,UAAU,EAAE,EACtB,cAAc,EACd,UAAU,EACV,aAAa,EACb,cAAc,GACjB,EAAE,sCAAsC,2CA6ExC"}

package/esm/components/filterBar/MeasureValueFilterItemDropdownButton.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useMemo } from "react";
+import classNames from "classnames";
+import { uniqueId } from "lodash-es";
+import { isWarningMessage } from "@gooddata/sdk-ui-filters";
+import { Bubble, BubbleHoverTrigger, ShortenedText } from "@gooddata/sdk-ui-kit";
+import { DropdownButtonValue } from "./measureValueFilter/DropdownButtonValue.js";
+const tooltipAlignPoints = [
+    { align: "tc bc", offset: { x: 0, y: -2 } },
+    { align: "cc tc", offset: { x: 0, y: 10 } },
+    { align: "bl tr", offset: { x: -2, y: -8 } },
+];
+const getWarningMessageClassName = (warningMessage) => {
+    if (!warningMessage) {
+        return null;
+    }
+    const baseClass = "adi-filter-warning s-filter-warning";
+    if (typeof warningMessage === "string") {
+        return `${baseClass} adi-filter-warning-low`;
+    }
+    switch (warningMessage.severity) {
+        case "low":
+            return `${baseClass} adi-filter-warning-low`;
+        case "medium":
+            return `${baseClass} adi-filter-warning-medium`;
+        case "high":
+            return `${baseClass} adi-filter-warning-high`;
+    }
+};
+export function MeasureValueFilterDropdownButton({ measureTitle, usePercentage, warningMessage, onClick, buttonRef, isActive, className, filter: { conditions }, sequenceNumber, separators, isDraggedItem, dimensionality, }) {
+    // do not render the decorated sequence number when there's none
+    // (filter is built for measure not in buckets)
+    const sequenceNumberString = useMemo(() => (sequenceNumber === undefined ? "" : ` (M${sequenceNumber})`), [sequenceNumber]);
+    const dialogId = useMemo(() => uniqueId("filter_"), []);
+    const buttonClassNames = useMemo(() => classNames([
+        "dropdown-button",
+        "toggle-menu",
+        "adi-filter-button",
+        "s-filter-button",
+        "adi-measure-value-filter-button",
+        "gd-button",
+        "button-dropdown",
+        "gd-icon-right",
+        "gd-mvf-dropdown-toggle-button",
+        getWarningMessageClassName(warningMessage),
+        className,
+    ], {
+        "is-active": isActive,
+    }), [warningMessage, className, isActive]);
+    const getConfigurationClasses = () => classNames("adi-filter-selection", "adi-filter-button-bottom-line", "gd-mvf-configuration", "s-mvf-configuration");
+    const renderButton = () => (_jsx("div", { id: dialogId, ref: buttonRef, tabIndex: -1, className: buttonClassNames, onClick: onClick, children: _jsxs("div", { className: "gd-button-text", children: [_jsx("div", { className: "adi-filter-title s-attribute-filter-button-title s-mvf-measure-name", children: _jsx(ShortenedText, { tooltipAlignPoints: tooltipAlignPoints, tooltipVisibleOnMouseOver: false, displayTooltip: !isDraggedItem, children: `${measureTitle}${sequenceNumberString}` }) }), _jsx("div", { className: getConfigurationClasses(), children: _jsx("b", { "data-testid": "mvf-configuration-value", children: _jsx(DropdownButtonValue, { conditions: conditions, usePercentage: usePercentage, separators: separators, dimensionality: dimensionality }) }) })] }) }));
+    return warningMessage && !isDraggedItem ? (_jsxs(BubbleHoverTrigger, { tagName: "div", showDelay: 200, hideDelay: 0, children: [renderButton(), !isActive && (_jsx(Bubble, { alignPoints: [{ align: "bc tc" }], children: isWarningMessage(warningMessage) ? warningMessage.text : warningMessage }))] })) : (renderButton());
+}

package/esm/components/filterBar/__mocks__/DraggableFilterItem.d.ts

@@ -0,0 +1,3 @@
+import { type IDraggableFilterItemProps } from "../DraggableFilterItem.js";
+export declare function DraggableFilterItem({ filterItem }: IDraggableFilterItemProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DraggableFilterItem.d.ts.map

package/esm/components/filterBar/__mocks__/DraggableFilterItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DraggableFilterItem.d.ts","sourceRoot":"","sources":["../../../../src/components/filterBar/__mocks__/DraggableFilterItem.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAE3E,wBAAgB,mBAAmB,CAAC,EAAE,UAAU,EAAE,EAAE,yBAAyB,2CAE5E"}