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

package/esm/components/filterBar/pickerLoading/useCatalogItemPickerData.d.ts

@@ -0,0 +1,41 @@
+import { type CatalogItem, type IAttributeOrMeasure, type ICatalogGroup as ICatalogGroupModel, type IInsightDefinition, type ObjRef } from "@gooddata/sdk-model";
+import { type IDimensionalityItem } from "@gooddata/sdk-ui-filters";
+import { type IBucketItemDescriptors, type ICatalogGroup as ICatalogGroupPicker, type ICatalogItemPickerItems } from "@gooddata/sdk-ui-kit";
+import { type IAttributeFilter, type IMeasureValueFilter } from "../../../store/filter_bar/filter_bar_types.js";
+import { type IRawBucketItems } from "../../../typings/buckets.js";
+import { type ICatalogEntries } from "../../../typings/state_objects.js";
+import { type IMetricPickerItemPayload } from "../filterBarDropdown/filterBarDropdownUtils.js";
+export type CatalogItemPickerItemType = "attribute" | "metric";
+interface IUseCatalogItemPickerDataParams {
+    itemTypes: CatalogItemPickerItemType[];
+    isOpen: boolean;
+    isCatalogLoading: boolean;
+    projectId: string;
+    insight: IInsightDefinition | undefined;
+    datasetId: string | undefined;
+    includeObjectsWithTags?: ObjRef[];
+    excludeObjectsWithTags?: ObjRef[];
+    availableCatalogItems: ReadonlyArray<CatalogItem>;
+    allCatalogItems: ReadonlyArray<CatalogItem>;
+    catalogGroups: ReadonlyArray<ICatalogGroupModel>;
+    bucketMeasures: IRawBucketItems;
+    bucketAttributes: IRawBucketItems;
+    bucketItemNames: IBucketItemDescriptors;
+    itemCache: ICatalogEntries;
+    attributeFilters: ReadonlyArray<IAttributeFilter>;
+    measureValueFilters: ReadonlyArray<IMeasureValueFilter>;
+    /**
+     * Optional override of items used for attribute availability (computeValidObjects).
+     * When not provided, defaults to measures + attributes from the current insight.
+     */
+    attributeAvailabilityItems?: IAttributeOrMeasure[];
+}
+interface IUseCatalogItemPickerDataResult {
+    attributePickerItems: ICatalogItemPickerItems<IDimensionalityItem> | undefined;
+    metricPickerItems: ICatalogItemPickerItems<IMetricPickerItemPayload> | undefined;
+    groups: ICatalogGroupPicker[] | undefined;
+    isLoading: boolean;
+}
+export declare function useCatalogItemPickerData({ itemTypes, isOpen, isCatalogLoading, projectId, insight, datasetId, includeObjectsWithTags, excludeObjectsWithTags, availableCatalogItems, allCatalogItems, catalogGroups, bucketMeasures, bucketAttributes, bucketItemNames, itemCache, attributeFilters, measureValueFilters, attributeAvailabilityItems, }: IUseCatalogItemPickerDataParams): IUseCatalogItemPickerDataResult;
+export {};
+//# sourceMappingURL=useCatalogItemPickerData.d.ts.map

package/esm/components/filterBar/pickerLoading/useCatalogItemPickerData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCatalogItemPickerData.d.ts","sourceRoot":"","sources":["../../../../src/components/filterBar/pickerLoading/useCatalogItemPickerData.ts"],"names":[],"mappings":"AAMA,OAAO,EACH,KAAK,WAAW,EAChB,KAAK,mBAAmB,EAGxB,KAAK,aAAa,IAAI,kBAAkB,EACxC,KAAK,kBAAkB,EACvB,KAAK,MAAM,EAOd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EACH,KAAK,sBAAsB,EAC3B,KAAK,aAAa,IAAI,mBAAmB,EAEzC,KAAK,uBAAuB,EAC/B,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACH,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EAC3B,MAAM,+CAA+C,CAAC;AACvD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE,OAAO,EACH,KAAK,wBAAwB,EAWhC,MAAM,gDAAgD,CAAC;AAGxD,MAAM,MAAM,yBAAyB,GAAG,WAAW,GAAG,QAAQ,CAAC;AAE/D,UAAU,+BAA+B;IACrC,SAAS,EAAE,yBAAyB,EAAE,CAAC;IACvC,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;IAE1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACxC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;IAClC,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;IAElC,qBAAqB,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAClD,eAAe,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAC5C,aAAa,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC;IAEjD,cAAc,EAAE,eAAe,CAAC;IAChC,gBAAgB,EAAE,eAAe,CAAC;IAClC,eAAe,EAAE,sBAAsB,CAAC;IACxC,SAAS,EAAE,eAAe,CAAC;IAE3B,gBAAgB,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;IAClD,mBAAmB,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAC;IAExD;;;OAGG;IACH,0BAA0B,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACtD;AAED,UAAU,+BAA+B;IACrC,oBAAoB,EAAE,uBAAuB,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAC;IAC/E,iBAAiB,EAAE,uBAAuB,CAAC,wBAAwB,CAAC,GAAG,SAAS,CAAC;IACjF,MAAM,EAAE,mBAAmB,EAAE,GAAG,SAAS,CAAC;IAC1C,SAAS,EAAE,OAAO,CAAC;CACtB;AAiFD,wBAAgB,wBAAwB,CAAC,EACrC,SAAS,EACT,MAAM,EACN,gBAAgB,EAChB,SAAS,EACT,OAAO,EACP,SAAS,EACT,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,eAAe,EACf,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,SAAS,EACT,gBAAgB,EAChB,mBAAmB,EACnB,0BAA0B,GAC7B,EAAE,+BAA+B,GAAG,+BAA+B,CA4MnE"}

package/esm/components/filterBar/pickerLoading/useCatalogItemPickerData.js

@@ -0,0 +1,198 @@
+// (C) 2026 GoodData Corporation
+import { useEffect, useMemo, useState } from "react";
+import { useSelector } from "react-redux";
+import { idRef, insightAttributes, insightMeasures, isCatalogAttribute, isCatalogComputedAttribute, objRefToString, } from "@gooddata/sdk-model";
+import { enableComputedAttributes } from "../../../selectors/feature_flag_selector.js";
+import { loadValidDimensionalityAttributes } from "../../../utils/api.js";
+import { getAvailableInsightAttributeItems, getBucketMeasureIdentifiers, getBucketMetricItems, getCatalogMeasures, getFilteredAttributeRefKeys, getFilteredMeasureIdentifiers, getFilteredMeasureRefKeys, getMetricCacheItemsById, isAttributeRefFiltered, toAttributePickerItems, } from "../filterBarDropdown/filterBarDropdownUtils.js";
+import { buildAttributeCatalogItems } from "../measure_value_filter_item_utils.js";
+const getAttributeItemId = (item) => objRefToString(item.identifier);
+const buildAvailabilityItems = (insight) => {
+    return [...insightMeasures(insight), ...insightAttributes(insight)];
+};
+/**
+ * Computed attributes are filterable exactly like regular attributes, so every path that offers
+ * catalog attributes to the picker must accept both. The catalog only contains computed attributes
+ * while the feature flag is on (the catalog load is gated), so no extra gating is needed here.
+ */
+const isAttributeLikeCatalogItem = (item) => isCatalogAttribute(item) || isCatalogComputedAttribute(item);
+const catalogItemToDimensionalityItem = (item) => {
+    const metadata = isCatalogComputedAttribute(item) ? item.computedAttribute : item.attribute;
+    const dataSet = isCatalogComputedAttribute(item)
+        ? item.computedAttribute.dataSet
+        : (item.dataSet ?? item.attribute.dataSet);
+    return {
+        identifier: item.defaultDisplayForm.ref,
+        ref: item.defaultDisplayForm.ref,
+        title: metadata.title,
+        type: "attribute",
+        dataset: dataSet
+            ? {
+                identifier: dataSet.ref,
+                title: dataSet.title,
+            }
+            : undefined,
+    };
+};
+const buildFallbackCatalogItems = ({ itemCache, availableCatalogItems, allCatalogItems, }) => {
+    const catalogAttributes = (availableCatalogItems.length > 0 ? availableCatalogItems : allCatalogItems).filter(isAttributeLikeCatalogItem);
+    if (catalogAttributes.length > 0) {
+        return catalogAttributes.map(catalogItemToDimensionalityItem);
+    }
+    const result = [];
+    Object.values(itemCache).forEach((cacheItem) => {
+        if (cacheItem.type !== "attribute" && cacheItem.type !== "computedAttribute") {
+            return;
+        }
+        const dfRef = cacheItem.dfRef ?? cacheItem.ref;
+        if (!dfRef) {
+            return;
+        }
+        result.push({
+            identifier: dfRef,
+            ref: dfRef,
+            title: cacheItem.title,
+            type: "attribute",
+            dataset: undefined,
+        });
+    });
+    return result;
+};
+const buildCatalogAttributeItems = (catalogAttributes) => {
+    return catalogAttributes.map(catalogItemToDimensionalityItem);
+};
+export function useCatalogItemPickerData({ itemTypes, isOpen, isCatalogLoading, projectId, insight, datasetId, includeObjectsWithTags, excludeObjectsWithTags, availableCatalogItems, allCatalogItems, catalogGroups, bucketMeasures, bucketAttributes, bucketItemNames, itemCache, attributeFilters, measureValueFilters, attributeAvailabilityItems, }) {
+    const includesAttributes = itemTypes.includes("attribute");
+    const includesMetrics = itemTypes.includes("metric");
+    const computedAttributesEnabled = useSelector(enableComputedAttributes);
+    const [catalogAttributeItems, setCatalogAttributeItems] = useState([]);
+    const [isLoadingAttributes, setIsLoadingAttributes] = useState(false);
+    useEffect(() => {
+        let canceled = false;
+        const cleanup = () => {
+            canceled = true;
+        };
+        if (!isOpen || !includesAttributes) {
+            setIsLoadingAttributes(false);
+            return cleanup;
+        }
+        const availabilityItems = attributeAvailabilityItems ?? (insight ? buildAvailabilityItems(insight) : []);
+        const catalogAttributes = (availableCatalogItems.length > 0 ? availableCatalogItems : allCatalogItems).filter(isAttributeLikeCatalogItem);
+        // No availability request -> show catalog attributes (best effort dataset) or cache fallback.
+        if (availabilityItems.length === 0) {
+            if (catalogAttributes.length > 0) {
+                setCatalogAttributeItems(buildCatalogAttributeItems(catalogAttributes));
+            }
+            else {
+                setCatalogAttributeItems(buildFallbackCatalogItems({
+                    itemCache,
+                    availableCatalogItems,
+                    allCatalogItems,
+                }));
+            }
+            setIsLoadingAttributes(false);
+            return cleanup;
+        }
+        // Availability (computeValidObjects) -> use validated list, fall back to catalog/cache if empty.
+        setIsLoadingAttributes(true);
+        loadValidDimensionalityAttributes(projectId, {
+            items: availabilityItems,
+            includeObjectsWithTags,
+            excludeObjectsWithTags,
+            dataSetIdentifier: datasetId ? idRef(datasetId) : undefined,
+            enableComputedAttributes: computedAttributesEnabled,
+        })
+            .then((validAttributesMap) => {
+            if (canceled) {
+                return;
+            }
+            const items = buildAttributeCatalogItems(validAttributesMap);
+            setCatalogAttributeItems(items.length > 0
+                ? items
+                : buildFallbackCatalogItems({
+                    itemCache,
+                    availableCatalogItems,
+                    allCatalogItems,
+                }));
+        })
+            .catch(() => {
+            if (canceled) {
+                return;
+            }
+            setCatalogAttributeItems(buildFallbackCatalogItems({
+                itemCache,
+                availableCatalogItems,
+                allCatalogItems,
+            }));
+        })
+            .finally(() => {
+            if (!canceled) {
+                setIsLoadingAttributes(false);
+            }
+        });
+        return cleanup;
+    }, [
+        allCatalogItems,
+        attributeAvailabilityItems,
+        datasetId,
+        excludeObjectsWithTags,
+        includeObjectsWithTags,
+        includesAttributes,
+        insight,
+        isOpen,
+        itemCache,
+        availableCatalogItems,
+        projectId,
+        computedAttributesEnabled,
+    ]);
+    // Attribute picker items (mapped to CatalogItemPicker items)
+    const filteredAttributeRefKeys = useMemo(() => getFilteredAttributeRefKeys(attributeFilters, itemCache), [attributeFilters, itemCache]);
+    const availableInsightAttributeItems = useMemo(() => getAvailableInsightAttributeItems(bucketAttributes, bucketItemNames, filteredAttributeRefKeys), [bucketAttributes, bucketItemNames, filteredAttributeRefKeys]);
+    const availableCatalogAttributeItems = useMemo(() => {
+        return catalogAttributeItems.filter((item) => !isAttributeRefFiltered(filteredAttributeRefKeys, item.identifier));
+    }, [catalogAttributeItems, filteredAttributeRefKeys]);
+    const attributePickerItems = useMemo(() => includesAttributes
+        ? toAttributePickerItems(availableInsightAttributeItems, availableCatalogAttributeItems, getAttributeItemId)
+        : undefined, [includesAttributes, availableCatalogAttributeItems, availableInsightAttributeItems]);
+    // Metric picker items (pure mapping; no extra network)
+    const metricCacheItemsById = useMemo(() => getMetricCacheItemsById(itemCache), [itemCache]);
+    const bucketMeasureIdentifiers = useMemo(() => getBucketMeasureIdentifiers(bucketMeasures), [bucketMeasures]);
+    const filteredMeasureRefKeys = useMemo(() => getFilteredMeasureRefKeys(bucketMeasures, measureValueFilters), [bucketMeasures, measureValueFilters]);
+    const filteredMeasureIdentifiers = useMemo(() => getFilteredMeasureIdentifiers(bucketMeasures, measureValueFilters), [bucketMeasures, measureValueFilters]);
+    const bucketMetricItems = useMemo(() => getBucketMetricItems(bucketMeasures, bucketItemNames, measureValueFilters, metricCacheItemsById), [bucketMeasures, bucketItemNames, measureValueFilters, metricCacheItemsById]);
+    const catalogMeasures = useMemo(() => getCatalogMeasures(availableCatalogItems, bucketMeasureIdentifiers, filteredMeasureIdentifiers, filteredMeasureRefKeys), [availableCatalogItems, bucketMeasureIdentifiers, filteredMeasureIdentifiers, filteredMeasureRefKeys]);
+    const metricPickerItems = useMemo(() => {
+        if (!includesMetrics) {
+            return undefined;
+        }
+        const insightItems = bucketMetricItems.map((item) => ({
+            id: item.id,
+            title: item.title,
+            type: "metric",
+            payload: item.payload,
+            sequenceNumber: item.sequenceNumber,
+        }));
+        const catalogItemsList = catalogMeasures.map((item) => ({
+            id: item.id,
+            title: item.title,
+            type: "metric",
+            payload: item.payload,
+            groupIds: item.groups.map((group) => objRefToString(group)),
+        }));
+        return { insightItems, catalogItems: catalogItemsList };
+    }, [includesMetrics, bucketMetricItems, catalogMeasures]);
+    // Groups for metrics
+    const groups = useMemo(() => includesMetrics
+        ? catalogGroups.map((group) => ({
+            id: objRefToString(group.tag),
+            title: group.title,
+        }))
+        : undefined, [includesMetrics, catalogGroups]);
+    const isLoading = (includesAttributes && isLoadingAttributes) || (isOpen && isCatalogLoading);
+    return {
+        attributePickerItems,
+        metricPickerItems,
+        groups,
+        isLoading,
+    };
+}

package/esm/components/filterBar/rankingFilter/RankingFilter.d.ts

@@ -0,0 +1,40 @@
+import { type IntlShape } from "react-intl";
+import { type IRankingFilter, type ObjRefInScope } from "@gooddata/sdk-model";
+import { type IAttributeDropdownItem, type ICustomGranularitySelection, type IDimensionalityItem, type IMeasureDropdownItem, type RenderMeasureDropdownBody } from "@gooddata/sdk-ui-filters";
+export declare const getButtonModel: (filter: IRankingFilter, measureItems: IMeasureDropdownItem[], attributeItems: IAttributeDropdownItem[], attributeTitles?: string[]) => {
+    operator: import("@gooddata/sdk-model").RankingFilterOperator;
+    value: number;
+    measureTitle: string;
+    measureSequence: string | undefined;
+    attributeTitle: string | undefined;
+};
+export interface IRankingFilterProps {
+    filter: IRankingFilter;
+    measureItems: IMeasureDropdownItem[];
+    attributeItems: IAttributeDropdownItem[];
+    onApply: (rankingFilter: IRankingFilter) => void;
+    onCancel: () => void;
+    onDropDownItemMouseOver?: (ref: ObjRefInScope) => void;
+    onDropDownItemMouseOut?: () => void;
+    className?: string;
+    mountOpened?: boolean;
+    customGranularitySelection?: ICustomGranularitySelection;
+    intl?: IntlShape;
+    enableRankingWithMvf?: boolean;
+    enableRankingStrictLimit?: boolean;
+    renderMeasureDropdownBody?: RenderMeasureDropdownBody;
+    isAttributesSectionEnabled?: boolean;
+    /** Current "out of" attributes (titled), seeded by the container (filter's own, or insight defaults). */
+    attributes?: IDimensionalityItem[];
+    /** Insight default "out of" attributes, used for the reset action and the default "reuses insight" state. */
+    insightAttributes?: IDimensionalityItem[];
+    /** Lazily loads catalog "out of" attributes valid for the current selection (on picker open). */
+    loadCatalogAttributes?: (attributes: ObjRefInScope[]) => Promise<IDimensionalityItem[]>;
+    /**
+     * Catalog-aware resolved titles of the filter's current "out of" attributes, used for the pill label
+     * (covers catalog attributes not present in the bucket attributeItems).
+     */
+    attributeTitles?: string[];
+}
+export declare function RankingFilter({ filter, measureItems, attributeItems, onApply, onCancel, className, mountOpened, onDropDownItemMouseOver, onDropDownItemMouseOut, customGranularitySelection, intl, enableRankingWithMvf, enableRankingStrictLimit, renderMeasureDropdownBody, isAttributesSectionEnabled, attributes, insightAttributes, loadCatalogAttributes, attributeTitles, }: IRankingFilterProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RankingFilter.d.ts.map

package/esm/components/filterBar/rankingFilter/RankingFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RankingFilter.d.ts","sourceRoot":"","sources":["../../../../src/components/filterBar/rankingFilter/RankingFilter.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAmB,MAAM,qBAAqB,CAAC;AAC/F,OAAO,EACH,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EAChC,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EAEzB,KAAK,yBAAyB,EACjC,MAAM,0BAA0B,CAAC;AASlC,eAAO,MAAM,cAAc,WACf,cAAc,gBACR,oBAAoB,EAAE,kBACpB,sBAAsB,EAAE,oBACtB,MAAM,EAAE;;;;;;CA4B7B,CAAC;AAEF,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE,cAAc,CAAC;IACvB,YAAY,EAAE,oBAAoB,EAAE,CAAC;IACrC,cAAc,EAAE,sBAAsB,EAAE,CAAC;IACzC,OAAO,EAAE,CAAC,aAAa,EAAE,cAAc,KAAK,IAAI,CAAC;IACjD,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,uBAAuB,CAAC,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,IAAI,CAAC;IACvD,sBAAsB,CAAC,EAAE,MAAM,IAAI,CAAC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,0BAA0B,CAAC,EAAE,2BAA2B,CAAC;IACzD,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,yBAAyB,CAAC,EAAE,yBAAyB,CAAC;IACtD,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,yGAAyG;IACzG,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACnC,6GAA6G;IAC7G,iBAAiB,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAC1C,iGAAiG;IACjG,qBAAqB,CAAC,EAAE,CAAC,UAAU,EAAE,aAAa,EAAE,KAAK,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAC;IACxF;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,wBAAgB,aAAa,CAAC,EAC1B,MAAM,EACN,YAAY,EACZ,cAAc,EACd,OAAO,EACP,QAAQ,EACR,SAAS,EACT,WAAW,EACX,uBAAuB,EACvB,sBAAsB,EACtB,0BAA0B,EAC1B,IAAI,EACJ,oBAAoB,EACpB,wBAAwB,EACxB,yBAAyB,EACzB,0BAA0B,EAC1B,UAAU,EACV,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,GAClB,EAAE,mBAAmB,2CAiDrB"}

package/esm/components/filterBar/rankingFilter/RankingFilter.js

@@ -0,0 +1,45 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2020-2026 GoodData Corporation
+import { useState } from "react";
+import { areObjRefsEqual } from "@gooddata/sdk-model";
+import { RankingFilterDropdown, } from "@gooddata/sdk-ui-filters";
+import { RankingFilterButton } from "./RankingFilterButton.js";
+const findItemByRef = (items, targetRef) => items.find(({ ref }) => areObjRefsEqual(ref, targetRef));
+export const getButtonModel = (filter, measureItems, attributeItems, attributeTitles) => {
+    const { rankingFilter: { operator, value, measure, attributes }, } = filter;
+    const measureItem = findItemByRef(measureItems, measure);
+    // Prefer catalog-aware titles resolved by the container (these cover catalog attributes referenced by
+    // ObjRef, which are not present in the bucket attributeItems). Fall back to the bucket lookup of the
+    // first attribute for the legacy single-attribute flow.
+    const attributeTitle = attributeTitles && attributeTitles.length > 0
+        ? attributeTitles.join(", ")
+        : attributes?.length
+            ? findItemByRef(attributeItems, attributes[0])?.title
+            : undefined;
+    // measureItem can be undefined for a catalog-backed ranking filter whose measure is not in
+    // measureItems (e.g. enableImprovedRankingFilter off, or the catalog still loading); guard so the
+    // filter pill renders instead of crashing the whole filter bar.
+    return {
+        operator,
+        value,
+        measureTitle: measureItem?.title ?? "",
+        measureSequence: measureItem?.sequenceNumber,
+        attributeTitle,
+    };
+};
+export function RankingFilter({ filter, measureItems, attributeItems, onApply, onCancel, className, mountOpened, onDropDownItemMouseOver, onDropDownItemMouseOut, customGranularitySelection, intl, enableRankingWithMvf, enableRankingStrictLimit, renderMeasureDropdownBody, isAttributesSectionEnabled, attributes, insightAttributes, loadCatalogAttributes, attributeTitles, }) {
+    const [isOpen, setIsOpen] = useState(mountOpened);
+    const onButtonClick = () => {
+        setIsOpen(!isOpen);
+    };
+    const handleApply = (rankingFilter) => {
+        onApply(rankingFilter);
+        setIsOpen(false);
+        onCancel();
+    };
+    const handleCancel = () => {
+        setIsOpen(false);
+        onCancel();
+    };
+    return (_jsxs(_Fragment, { children: [_jsx(RankingFilterButton, { model: getButtonModel(filter, measureItems, attributeItems, attributeTitles), onClick: onButtonClick, isActive: isOpen, className: `gd-rf-dropdown-toggle-button s-rf-dropdown-toggle-button ${className}` }), isOpen ? (_jsx(RankingFilterDropdown, { filter: filter, measureItems: measureItems, attributeItems: attributeItems, onApply: handleApply, onCancel: handleCancel, onDropDownItemMouseOver: onDropDownItemMouseOver, onDropDownItemMouseOut: onDropDownItemMouseOut, anchorEl: ".gd-rf-dropdown-toggle-button", customGranularitySelection: customGranularitySelection, locale: intl?.locale, enableRankingWithMvf: enableRankingWithMvf, enableRankingStrictLimit: enableRankingStrictLimit, renderMeasureDropdownBody: renderMeasureDropdownBody, isAttributesSectionEnabled: isAttributesSectionEnabled, attributes: attributes, insightAttributes: insightAttributes, loadCatalogAttributes: loadCatalogAttributes })) : null] }));
+}

package/esm/components/filterBar/rankingFilter/RankingFilter.test.helpers.d.ts

@@ -0,0 +1,19 @@
+import { type IRankingFilter } from "@gooddata/sdk-model";
+import { type IAttributeDropdownItem, type IMeasureDropdownItem } from "@gooddata/sdk-ui-filters";
+import { type IRankingFilter as IRankingFilterState } from "../../../store/filter_bar/filter_bar_types.js";
+import { type IRankingFilterButtonModel } from "./RankingFilterButton.js";
+export declare const rankingFilterWithoutAttributes: IRankingFilter;
+export declare const rankingFilterWithAttributes: IRankingFilter;
+export declare const rankingFilterWithUriMeasure: IRankingFilter;
+export declare const rankingFilterWithUriAttribute: IRankingFilter;
+export declare const rankingFilterState: IRankingFilterState;
+export declare const rankingFilterStateWithCatalogMeasureRef: IRankingFilterState;
+export declare const rankingFilterStateWithAttributeLocalIdentifiers: IRankingFilterState;
+export declare const rankingFilterStateWithCatalogAttribute: IRankingFilterState;
+export declare const measureItems: IMeasureDropdownItem[];
+export declare const measureItemsWithSequence: IMeasureDropdownItem[];
+export declare const attributeItems: IAttributeDropdownItem[];
+export declare const buttonValueWithoutAttribute: IRankingFilterButtonModel;
+export declare const buttonValueWithAttribute: IRankingFilterButtonModel;
+export declare const buttonValueWithSequenceAndAttribute: IRankingFilterButtonModel;
+//# sourceMappingURL=RankingFilter.test.helpers.d.ts.map

package/esm/components/filterBar/rankingFilter/RankingFilter.test.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RankingFilter.test.helpers.d.ts","sourceRoot":"","sources":["../../../../src/components/filterBar/rankingFilter/RankingFilter.test.helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,cAAc,EAA+C,MAAM,qBAAqB,CAAC;AACvG,OAAO,EAAE,KAAK,sBAAsB,EAAE,KAAK,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAElG,OAAO,EAAE,KAAK,cAAc,IAAI,mBAAmB,EAAE,MAAM,+CAA+C,CAAC;AAE3G,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAE1E,eAAO,MAAM,8BAA8B,EAAE,cAAkD,CAAC;AAChG,eAAO,MAAM,2BAA2B,EAAE,cAA0D,CAAC;AACrG,eAAO,MAAM,2BAA2B,EAAE,cAKzC,CAAC;AACF,eAAO,MAAM,6BAA6B,EAAE,cAK3C,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,mBAMhC,CAAC;AAEF,eAAO,MAAM,uCAAuC,EAAE,mBAMrD,CAAC;AAEF,eAAO,MAAM,+CAA+C,EAAE,mBAO7D,CAAC;AAEF,eAAO,MAAM,sCAAsC,EAAE,mBAQpD,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,oBAAoB,EAI9C,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,oBAAoB,EAI1D,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,sBAAsB,EAIlD,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,yBAIzC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,yBAKtC,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,yBAMjD,CAAC"}

package/esm/components/filterBar/rankingFilter/RankingFilter.test.helpers.js

@@ -0,0 +1,70 @@
+// (C) 2020-2026 GoodData Corporation
+import { idRef, localIdRef, newRankingFilter, uriRef } from "@gooddata/sdk-model";
+export const rankingFilterWithoutAttributes = newRankingFilter("m1", "TOP", 10);
+export const rankingFilterWithAttributes = newRankingFilter("m1", ["a1"], "TOP", 10);
+export const rankingFilterWithUriMeasure = newRankingFilter(uriRef("/uri"), ["a1"], "TOP", 10);
+export const rankingFilterWithUriAttribute = newRankingFilter("m1", [uriRef("/uri")], "TOP", 10);
+export const rankingFilterState = {
+    type: "ranking",
+    localIdentifier: "f1",
+    measureLocalIdentifier: "m1",
+    operator: "TOP",
+    value: 10,
+};
+export const rankingFilterStateWithCatalogMeasureRef = {
+    type: "ranking",
+    localIdentifier: "f1",
+    measureRef: idRef("metric_from_catalog", "measure"),
+    operator: "TOP",
+    value: 10,
+};
+export const rankingFilterStateWithAttributeLocalIdentifiers = {
+    type: "ranking",
+    localIdentifier: "f1",
+    measureLocalIdentifier: "m1",
+    attributes: ["a1"],
+    operator: "TOP",
+    value: 10,
+};
+export const rankingFilterStateWithCatalogAttribute = {
+    type: "ranking",
+    localIdentifier: "f1",
+    measureLocalIdentifier: "m1",
+    // A bucket attribute (local id) plus a catalog attribute referenced by ObjRef.
+    attributes: ["a1", idRef("attr_from_catalog", "displayForm")],
+    operator: "TOP",
+    value: 10,
+};
+export const measureItems = [
+    { title: "Measure 1", ref: localIdRef("m1") },
+    { title: "Measure 2", ref: localIdRef("m2") },
+    { title: "Measure 3", ref: localIdRef("m3") },
+];
+export const measureItemsWithSequence = [
+    { title: "Measure 1", ref: localIdRef("m1"), sequenceNumber: "M1" },
+    { title: "Measure 2", ref: localIdRef("m2"), sequenceNumber: "M2" },
+    { title: "Measure 3", ref: localIdRef("m3"), sequenceNumber: "M3" },
+];
+export const attributeItems = [
+    { title: "Attribute 1", ref: localIdRef("a1"), type: "ATTRIBUTE" },
+    { title: "Attribute 2", ref: localIdRef("a2"), type: "ATTRIBUTE" },
+    { title: "DATE", ref: localIdRef("d1"), type: "DATE" },
+];
+export const buttonValueWithoutAttribute = {
+    operator: "TOP",
+    value: 10,
+    measureTitle: "Measure 1",
+};
+export const buttonValueWithAttribute = {
+    operator: "TOP",
+    value: 10,
+    measureTitle: "Measure 1",
+    attributeTitle: "Attribute 1",
+};
+export const buttonValueWithSequenceAndAttribute = {
+    operator: "BOTTOM",
+    value: 10,
+    measureTitle: "Measure 1",
+    measureSequence: "M1",
+    attributeTitle: "Attribute 1",
+};

package/esm/components/filterBar/rankingFilter/RankingFilterButton.d.ts

@@ -0,0 +1,16 @@
+import { type RankingFilterOperator } from "../../../utils/drilling/types.js";
+export interface IRankingFilterButtonModel {
+    operator: RankingFilterOperator;
+    value: number;
+    measureTitle: string;
+    measureSequence?: string;
+    attributeTitle?: string;
+}
+export interface IRankingFilterButtonProps {
+    model: IRankingFilterButtonModel;
+    onClick: () => void;
+    isActive: boolean;
+    className?: string;
+}
+export declare function RankingFilterButton({ model, onClick, isActive, className }: IRankingFilterButtonProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RankingFilterButton.d.ts.map

package/esm/components/filterBar/rankingFilter/RankingFilterButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RankingFilterButton.d.ts","sourceRoot":"","sources":["../../../../src/components/filterBar/rankingFilter/RankingFilterButton.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAW9E,MAAM,WAAW,yBAAyB;IACtC,QAAQ,EAAE,qBAAqB,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,yBAAyB;IACtC,KAAK,EAAE,yBAAyB,CAAC;IACjC,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,mBAAmB,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,yBAAyB,2CA4ErG"}

package/esm/components/filterBar/rankingFilter/RankingFilterButton.js

@@ -0,0 +1,33 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2020-2026 GoodData Corporation
+import cx from "classnames";
+import { FormattedMessage, defineMessages } from "react-intl";
+const messages = defineMessages({
+    titleTopLong: { id: "ranking_filter.button.title_top_long" },
+    titleBottomLong: { id: "ranking_filter.button.title_bottom_long" },
+    titleTopShort: { id: "ranking_filter.button.title_top_short" },
+    titleBottomShort: { id: "ranking_filter.button.title_bottom_short" },
+    configuration: { id: "ranking_filter.button.configuration" },
+    configurationWithoutAttribute: { id: "ranking_filter.button.configuration_without_attribute" },
+});
+export function RankingFilterButton({ model, onClick, isActive, className }) {
+    const buttonClassName = cx("dropdown-button", "toggle-menu", "adi-filter-button", "s-filter-button", "adi-ranking-filter-button", "gd-button", "button-dropdown", "gd-icon-right", className, {
+        "is-active": isActive,
+    });
+    const configurationClassName = cx("adi-filter-selection", "adi-filter-button-bottom-line", "gd-rf-configuration", "s-rf-configuration");
+    const { attributeTitle, measureTitle, measureSequence, operator, value } = model;
+    return (_jsx("div", { className: buttonClassName, onClick: onClick, children: _jsxs("div", { className: "gd-button-text", children: [_jsx("div", { className: "adi-filter-title s-attribute-filter-button-title adi-rf-attribute-title s-rf-title", children: _jsx("span", { className: "adi-filter-title-long", children: attributeTitle ? (_jsx("span", { title: attributeTitle, children: _jsx(FormattedMessage, { id: operator === "TOP"
+                                    ? messages.titleTopLong.id
+                                    : messages.titleBottomLong.id, values: {
+                                    value,
+                                    attribute: attributeTitle,
+                                    strong: (chunks) => _jsx("strong", { children: chunks }),
+                                } }) })) : (_jsx(FormattedMessage, { id: operator === "TOP"
+                                ? messages.titleTopShort.id
+                                : messages.titleBottomShort.id, values: {
+                                value,
+                                strong: (chunks) => _jsx("strong", { children: chunks }),
+                            } })) }) }), _jsxs("div", { className: configurationClassName, children: [_jsx("span", { className: "adi-filter-title-long", title: measureTitle, children: _jsx(FormattedMessage, { id: attributeTitle
+                                    ? messages.configuration.id
+                                    : messages.configurationWithoutAttribute.id, values: { measure: measureTitle } }) }), measureSequence ? _jsxs(_Fragment, { children: ["\u00A0(", measureSequence, ")"] }) : null] })] }) }));
+}