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

package/esm/components/buckets/notifications/BucketNotifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BucketNotifications.d.ts","sourceRoot":"","sources":["../../../../src/components/buckets/notifications/BucketNotifications.tsx"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,mEAAmE,CAAC;AAEvG,OAAO,EAAE,KAAK,YAAY,EAA6B,MAAM,mCAAmC,CAAC;AAEjG,MAAM,WAAW,8BAA8B;IAC3C,kBAAkB,EAAE,aAAa,CAAC;IAClC,iBAAiB,EAAE,YAAY,CAAC;CACnC;AAmJD,wBAAgB,mBAAmB,oDAiBlC"}

package/esm/components/buckets/notifications/BucketNotifications.js

@@ -0,0 +1,87 @@
+import { createElement as _createElement } from "react";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2020-2026 GoodData Corporation
+import { useMemo } from "react";
+import classNames from "classnames";
+import { FormattedMessage, defineMessage } from "react-intl";
+import { useSelector } from "react-redux";
+import { Bubble, BubbleHoverTrigger } from "@gooddata/sdk-ui-kit";
+import { getRemovedItems } from "../../../store/bucket_notifications/bucket_notifications_selector.js";
+import { hiddenBucketItemsSelector } from "./hidden_bucket_items_selector.js";
+const getNumberOfAffectedItems = (items) => {
+    const { measures, measureValueFilters, rankingFilter } = items;
+    const attributes = items.attributes || 0;
+    return attributes + measures + measureValueFilters + (rankingFilter ? 1 : 0);
+};
+function ListItem({ value, messageId }) {
+    return (value > 0 && (_jsx("li", { children: _jsx(FormattedMessage, { id: messageId, values: { value } }) })));
+}
+function TooltipMessage({ headerMessageId, items, }) {
+    const { measures, measureValueFilters, rankingFilter } = items;
+    const attributes = items.attributes || 0;
+    return (_jsxs(_Fragment, { children: [_jsx(FormattedMessage, { id: headerMessageId }), _jsxs("ul", { children: [_jsx(ListItem, { messageId: defineMessage({ id: "bucket_notification.tooltip.items.attributes" }).id, value: attributes }), _jsx(ListItem, { messageId: defineMessage({ id: "bucket_notification.tooltip.items.measures" }).id, value: measures }), _jsx(ListItem, { messageId: defineMessage({ id: "bucket_notification.tooltip.items.measureValueFilters" }).id, value: measureValueFilters }), _jsx(ListItem, { messageId: defineMessage({ id: "bucket_notification.tooltip.items.rankingFilter" }).id, value: rankingFilter ? 1 : 0 })] })] }));
+}
+const buildRemovedItemsNotification = (items) => {
+    const { measures, measureValueFilters, rankingFilter } = items;
+    const numberOfAffectedItems = getNumberOfAffectedItems(items);
+    const messageId = numberOfAffectedItems === 1
+        ? defineMessage({ id: "bucket_notification.body.removedItem" }).id
+        : defineMessage({ id: "bucket_notification.body.removedItems" }).id;
+    const tooltipMessageId = numberOfAffectedItems === 1
+        ? defineMessage({ id: "bucket_notification.tooltip.removedItem" }).id
+        : defineMessage({ id: "bucket_notification.tooltip.removedItems" }).id;
+    return {
+        iconClassName: "bucket-notification-icon--removed-items",
+        testClassNames: [
+            "s-removed-items-notification",
+            `s-removed-items-notification--m-${measures}--mvf-${measureValueFilters}--rf-${rankingFilter}`,
+        ],
+        message: _jsx(FormattedMessage, { id: messageId }),
+        tooltipMessage: _jsx(TooltipMessage, { headerMessageId: tooltipMessageId, items: items }),
+    };
+};
+const buildHiddenItemsNotification = (items) => {
+    const { attributes, measures, measureValueFilters, rankingFilter } = items;
+    const numberOfAffectedItems = getNumberOfAffectedItems(items);
+    const messageId = numberOfAffectedItems === 1
+        ? defineMessage({ id: "bucket_notification.body.hiddenItem" }).id
+        : defineMessage({ id: "bucket_notification.body.hiddenItems" }).id;
+    const tooltipMessageId = numberOfAffectedItems === 1
+        ? defineMessage({ id: "bucket_notification.tooltip.hiddenItem" }).id
+        : defineMessage({ id: "bucket_notification.tooltip.hiddenItems" }).id;
+    return {
+        iconClassName: "bucket-notification-icon--hidden-items",
+        testClassNames: [
+            "s-hidden-items-notification",
+            `s-hidden-items-notification--a-${attributes}--m-${measures}--mvf-${measureValueFilters}--rf-${rankingFilter}`,
+        ],
+        message: _jsx(FormattedMessage, { id: messageId }),
+        tooltipMessage: _jsx(TooltipMessage, { headerMessageId: tooltipMessageId, items: items }),
+    };
+};
+const useNotifications = (props) => {
+    const { removedBucketItems, hiddenBucketItems } = props;
+    return useMemo(() => {
+        const items = [];
+        if (removedBucketItems) {
+            items.push(buildRemovedItemsNotification(removedBucketItems));
+        }
+        if (hiddenBucketItems) {
+            items.push(buildHiddenItemsNotification(hiddenBucketItems));
+        }
+        return items;
+    }, [removedBucketItems, hiddenBucketItems]);
+};
+function BucketNotification({ message, tooltipMessage, testClassNames, iconClassName, }) {
+    const wrapperClassNames = classNames("bucket-notification", ...testClassNames);
+    return (_jsxs(BubbleHoverTrigger, { tagName: "div", showDelay: 200, hideDelay: 0, className: wrapperClassNames, children: [_jsxs(_Fragment, { children: [_jsx("div", { className: classNames("bucket-notification-icon", iconClassName) }), _jsx("div", { className: "bucket-notification-message s-bucket-notification-message", children: message })] }), _jsx(Bubble, { alignPoints: [{ align: "tc bc" }], children: _jsx("div", { className: "bucket-notification-tooltip s-bucket-notification-tooltip", children: tooltipMessage }) })] }));
+}
+export function BucketNotifications() {
+    const removedBucketItems = useSelector(getRemovedItems);
+    const hiddenBucketItems = useSelector(hiddenBucketItemsSelector);
+    const notifications = useNotifications({
+        removedBucketItems,
+        hiddenBucketItems,
+    });
+    return (notifications.length > 0 && (_jsx("div", { className: "adi-bucket bucket-notifications has-rounded-corners s-bucket-notifications", children: notifications.map((notificationProps) => (_createElement(BucketNotification, { ...notificationProps, key: notificationProps.iconClassName }))) })));
+}

package/esm/components/buckets/notifications/hidden_bucket_items_selector.d.ts

@@ -0,0 +1,34 @@
+import { getBucketsExtended } from "../../../selectors/extended_reference_point_selector.js";
+import { isMdObjectValidSelector } from "../../../selectors/metadata_object_selector.js";
+import { getRefPointBuckets, getRefPointFilters } from "../../../services/reference_point_service.js";
+import { getFilterItemsExtended } from "../../../store/filter_bar/filter_bar_selector.js";
+import { type IFilter } from "../../../store/filter_bar/filter_bar_types.js";
+import { type IRawBuckets } from "../../../typings/buckets.js";
+export interface IHiddenItems {
+    attributes: number;
+    measures: number;
+    measureValueFilters: number;
+    rankingFilter: boolean;
+}
+export declare const hiddenBucketItemsSelector: ((state: import("../../../store/types.js").IAppState) => IHiddenItems | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: boolean, resultFuncArgs_1: IRawBuckets, resultFuncArgs_2: import("../../../store/reference_point/extended_reference_point_state.js").IExtendedRefPointBuckets | undefined, resultFuncArgs_3: import("../../../store/reference_point/reference_point_state.js").IRefPointFiltersBucket | undefined, resultFuncArgs_4: readonly IFilter[]) => IHiddenItems | null;
+    memoizedResultFunc: ((resultFuncArgs_0: boolean, resultFuncArgs_1: IRawBuckets, resultFuncArgs_2: import("../../../store/reference_point/extended_reference_point_state.js").IExtendedRefPointBuckets | undefined, resultFuncArgs_3: import("../../../store/reference_point/reference_point_state.js").IRefPointFiltersBucket | undefined, resultFuncArgs_4: readonly IFilter[]) => IHiddenItems | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => IHiddenItems | null;
+    dependencies: [typeof isMdObjectValidSelector, typeof getRefPointBuckets, typeof getBucketsExtended, typeof getRefPointFilters, typeof getFilterItemsExtended];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+//# sourceMappingURL=hidden_bucket_items_selector.d.ts.map

package/esm/components/buckets/notifications/hidden_bucket_items_selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hidden_bucket_items_selector.d.ts","sourceRoot":"","sources":["../../../../src/components/buckets/notifications/hidden_bucket_items_selector.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yDAAyD,CAAC;AAC7F,OAAO,EAAE,uBAAuB,EAAE,MAAM,gDAAgD,CAAC;AACzF,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAC;AACtG,OAAO,EAAE,sBAAsB,EAAE,MAAM,kDAAkD,CAAC;AAE1F,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,+CAA+C,CAAC;AAKxF,OAAO,EAAwC,KAAK,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAErG,MAAM,WAAW,YAAY;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,OAAO,CAAC;CAC1B;AA6CD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;CAwCrC,CAAC"}

package/esm/components/buckets/notifications/hidden_bucket_items_selector.js

@@ -0,0 +1,51 @@
+// (C) 2020-2026 GoodData Corporation
+import { createSelector } from "reselect";
+import { ATTRIBUTE, DATE, METRIC } from "../../../constants/bucket.js";
+import { getBucketsExtended } from "../../../selectors/extended_reference_point_selector.js";
+import { isMdObjectValidSelector } from "../../../selectors/metadata_object_selector.js";
+import { getRefPointBuckets, getRefPointFilters } from "../../../services/reference_point_service.js";
+import { getFilterItemsExtended } from "../../../store/filter_bar/filter_bar_selector.js";
+import { FilterBarService } from "../../../store/filter_bar/filter_bar_service.js";
+import { FilterBar } from "../../../store/filter_bar/filter_bar_types.js";
+function getBucketItemsCount(buckets, itemType) {
+    const items = (buckets ?? []).reduce((acc, bucket) => acc.concat(bucket.items ?? []), []);
+    return items.filter((item) => itemType === null || item.type === itemType).length;
+}
+function getHiddenBucketItemsCount(referencePointBuckets, extendedReferencePointBuckets, bucketItemType) {
+    return (getBucketItemsCount(referencePointBuckets, bucketItemType) -
+        getBucketItemsCount(extendedReferencePointBuckets, bucketItemType));
+}
+function getNumberOfMatchedFilters(refPointFilters, filterPredicate) {
+    if (!refPointFilters) {
+        return 0;
+    }
+    const convertedFilters = FilterBarService.convertFromExtendedRefPointFilters(refPointFilters);
+    return convertedFilters.filter(filterPredicate).length;
+}
+function getHiddenMatchedFiltersCount(refPointFilters, extendedRefPointFilters, filterPredicate) {
+    const refPointMeasureValueFilters = getNumberOfMatchedFilters(refPointFilters, filterPredicate);
+    const visibleMeasureValueFilters = extendedRefPointFilters.filter(filterPredicate).length;
+    return refPointMeasureValueFilters - visibleMeasureValueFilters;
+}
+export const hiddenBucketItemsSelector = createSelector(isMdObjectValidSelector, getRefPointBuckets, getBucketsExtended, getRefPointFilters, getFilterItemsExtended, (isMdObjectValid, refPointBuckets, extendedRefPointBuckets, refPointFilters, extendedRefPointFilters) => {
+    if (!isMdObjectValid) {
+        return null;
+    }
+    const attributesCount = getHiddenBucketItemsCount(refPointBuckets, extendedRefPointBuckets, ATTRIBUTE) +
+        getHiddenBucketItemsCount(refPointBuckets, extendedRefPointBuckets, DATE);
+    const measuresCount = getHiddenBucketItemsCount(refPointBuckets, extendedRefPointBuckets, METRIC);
+    const measureValueFiltersCount = getHiddenMatchedFiltersCount(refPointFilters, extendedRefPointFilters, FilterBar.isMeasureValueFilter);
+    const rankingFiltersCount = getHiddenMatchedFiltersCount(refPointFilters, extendedRefPointFilters, FilterBar.isRankingFilter);
+    const result = attributesCount === 0 &&
+        measuresCount === 0 &&
+        measureValueFiltersCount === 0 &&
+        rankingFiltersCount === 0
+        ? null
+        : {
+            attributes: attributesCount,
+            measures: measuresCount,
+            measureValueFilters: measureValueFiltersCount,
+            rankingFilter: rankingFiltersCount > 0,
+        };
+    return result;
+});

package/esm/components/buckets/useMeasureAttributeFilterItems.d.ts

@@ -0,0 +1,30 @@
+import { type IAttributeOrMeasure, type ICatalogAttribute, type ICatalogComputedAttribute, type IInsightDefinition } from "@gooddata/sdk-model";
+import { type IDecoratedBucketItem } from "../../typings/buckets.js";
+import { type ITagsConfiguration } from "../../typings/route.js";
+import { type IMeasureAttributeFilterItem } from "./MeasureAttributeListItemOrganized.js";
+export type MeasureAttributeFilterItemsLoader = (projectId: string, tagsConfiguration: ITagsConfiguration, options: {
+    insight?: IInsightDefinition;
+    items?: IAttributeOrMeasure[];
+    enableComputedAttributes?: boolean;
+}) => Promise<Array<ICatalogAttribute | ICatalogComputedAttribute>>;
+export interface IUseMeasureAttributeFilterItemsParams {
+    bucketItem: IDecoratedBucketItem;
+    projectId: string;
+    tagsConfiguration: ITagsConfiguration;
+    itemsLoader?: MeasureAttributeFilterItemsLoader;
+    isLocationIconEnabled?: boolean;
+    computedAttributesEnabled?: boolean;
+    /** false holds the load back (a closed dropdown); once loaded, the items stay */
+    isEnabled?: boolean;
+}
+export interface IUseMeasureAttributeFilterItemsResult {
+    items: IMeasureAttributeFilterItem[];
+    isLoading: boolean;
+}
+export declare const toMeasureAttributeFilterItem: (item: ICatalogAttribute | ICatalogComputedAttribute, isLocationIconEnabled: boolean | undefined) => IMeasureAttributeFilterItem;
+/**
+ * The attributes a metric can be filtered by, loaded for the metric on mount and again when the
+ * metric or the catalog tags change.
+ */
+export declare function useMeasureAttributeFilterItems({ bucketItem, projectId, tagsConfiguration, itemsLoader, isLocationIconEnabled, computedAttributesEnabled, isEnabled, }: IUseMeasureAttributeFilterItemsParams): IUseMeasureAttributeFilterItemsResult;
+//# sourceMappingURL=useMeasureAttributeFilterItems.d.ts.map

package/esm/components/buckets/useMeasureAttributeFilterItems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMeasureAttributeFilterItems.d.ts","sourceRoot":"","sources":["../../../src/components/buckets/useMeasureAttributeFilterItems.ts"],"names":[],"mappings":"AAMA,OAAO,EACH,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAC9B,KAAK,kBAAkB,EAE1B,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAGjE,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,wCAAwC,CAAC;AAE1F,MAAM,MAAM,iCAAiC,GAAG,CAC5C,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,kBAAkB,EACrC,OAAO,EAAE;IACL,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,KAAK,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAC9B,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACtC,KACA,OAAO,CAAC,KAAK,CAAC,iBAAiB,GAAG,yBAAyB,CAAC,CAAC,CAAC;AAEnE,MAAM,WAAW,qCAAqC;IAClD,UAAU,EAAE,oBAAoB,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,kBAAkB,CAAC;IACtC,WAAW,CAAC,EAAE,iCAAiC,CAAC;IAChD,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,iFAAiF;IACjF,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,qCAAqC;IAClD,KAAK,EAAE,2BAA2B,EAAE,CAAC;IACrC,SAAS,EAAE,OAAO,CAAC;CACtB;AAiBD,eAAO,MAAM,4BAA4B,SAC/B,iBAAiB,GAAG,yBAAyB,yBAC5B,OAAO,GAAG,SAAS,KAC3C,2BAuBF,CAAC;AAEF;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,EAC3C,UAAU,EACV,SAAS,EACT,iBAAiB,EACjB,WAAgD,EAChD,qBAAqB,EACrB,yBAAiC,EACjC,SAAgB,GACnB,EAAE,qCAAqC,GAAG,qCAAqC,CA8D/E"}

package/esm/components/buckets/useMeasureAttributeFilterItems.js

@@ -0,0 +1,100 @@
+// (C) 2019-2026 GoodData Corporation
+import { useEffect, useRef, useState } from "react";
+import { isEqual } from "lodash-es";
+import { isCatalogComputedAttribute, } from "@gooddata/sdk-model";
+import { BackendToBearConvertors } from "../../convertors/index.js";
+import { getMetricMDObject } from "../../services/metadata_service.js";
+import { API } from "../../utils/organized_catalog_api.js";
+const NO_ITEMS = [];
+/**
+ * The value by content: the decorated bucket item (and the tags configuration) is rebuilt by its
+ * selectors on inputs the loader does not read, so a reference change alone must not reload the
+ * list — a reload drops the items and the search while the picker is open.
+ */
+function useContentStable(value) {
+    const ref = useRef(value);
+    if (ref.current !== value && !isEqual(ref.current, value)) {
+        ref.current = value;
+    }
+    return ref.current;
+}
+export const toMeasureAttributeFilterItem = (item, isLocationIconEnabled) => {
+    // A computed attribute carries its metadata object under its own key and has no geo display
+    // forms, but is otherwise picked the same way a regular attribute is.
+    const isComputedAttribute = isCatalogComputedAttribute(item);
+    const attribute = isComputedAttribute ? item.computedAttribute : item.attribute;
+    const dataSet = isComputedAttribute
+        ? item.computedAttribute.dataSet
+        : (item.dataSet ?? item.attribute.dataSet);
+    const isLocationIconVisible = !isComputedAttribute && item.geoPinDisplayForms.length > 0 && isLocationIconEnabled;
+    const primaryDf = item.displayForms.find((df) => df.isPrimary);
+    return {
+        ref: attribute.ref,
+        dfUri: item.defaultDisplayForm.uri,
+        dfRef: item.defaultDisplayForm.ref,
+        primaryUri: primaryDf?.uri,
+        primaryRef: primaryDf?.ref,
+        isLocationIconVisible,
+        identifier: attribute.id,
+        title: attribute.title,
+        type: item.type,
+        dataset: dataSet ? { identifier: dataSet.ref, title: dataSet.title } : undefined,
+    };
+};
+/**
+ * The attributes a metric can be filtered by, loaded for the metric on mount and again when the
+ * metric or the catalog tags change.
+ */
+export function useMeasureAttributeFilterItems({ bucketItem, projectId, tagsConfiguration, itemsLoader = API.loadAvailableMeasureAttributes, isLocationIconEnabled, computedAttributesEnabled = false, isEnabled = true, }) {
+    const [isLoading, setIsLoading] = useState(true);
+    const [items, setItems] = useState(NO_ITEMS);
+    const stableBucketItem = useContentStable(bucketItem);
+    const stableTagsConfiguration = useContentStable(tagsConfiguration);
+    useEffect(() => {
+        // The mount and a tags/bucket-item change can each start a load, so two can be in flight
+        // at once and settle out of order. Only the newest one may touch the state - otherwise a
+        // slow failure wipes the items a later request already loaded (and a slow success
+        // overwrites them); the cleanup of a run retires its request, as does the unmount. Same
+        // reasoning as the in-flight guard in utils/api.ts.
+        if (!isEnabled) {
+            return undefined;
+        }
+        let isCurrentRequest = true;
+        setIsLoading(true);
+        setItems(NO_ITEMS);
+        const mdObject = getMetricMDObject(stableBucketItem);
+        const { items: bucketItems } = BackendToBearConvertors.convertBucket(mdObject.buckets[0]);
+        void itemsLoader(projectId, stableTagsConfiguration, {
+            items: bucketItems,
+            enableComputedAttributes: computedAttributesEnabled,
+        })
+            .then((availableItems) => {
+            if (isCurrentRequest) {
+                setItems(availableItems.map((item) => toMeasureAttributeFilterItem(item, isLocationIconEnabled)));
+                setIsLoading(false);
+            }
+        })
+            .catch((error) => {
+            if (!isCurrentRequest) {
+                return;
+            }
+            // Without this the dropdown is stuck on its loading placeholder forever: the
+            // search input and the item list only render once isLoading clears.
+            console.error("Failed to load the metric attribute filter items", error);
+            setItems(NO_ITEMS);
+            setIsLoading(false);
+        });
+        return () => {
+            isCurrentRequest = false;
+        };
+    }, [
+        isEnabled,
+        stableBucketItem,
+        itemsLoader,
+        projectId,
+        stableTagsConfiguration,
+        computedAttributesEnabled,
+        isLocationIconEnabled,
+    ]);
+    return { items, isLoading };
+}

package/esm/components/catalog/Catalog.d.ts

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

package/esm/components/catalog/Catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Catalog.d.ts","sourceRoot":"","sources":["../../../src/components/catalog/Catalog.tsx"],"names":[],"mappings":"AA8CA,wBAAgB,OAAO,4CA+HtB"}

package/esm/components/catalog/Catalog.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2019-2026 GoodData Corporation
+import { useCallback, useMemo } from "react";
+import { useIntl } from "react-intl";
+import { useDispatch, useSelector } from "react-redux";
+import { customMatcher, useHybridSearch, } from "@gooddata/sdk-ui-semantic-search";
+import { CatalogUiActions } from "../../sagas/catalog/catalog_ui_actions.js";
+import { getLinkToDatasourcePage } from "../../selectors/data_page_selector.js";
+import { enableCatalogSmartSearchResults as enableCatalogSmartSearchResultsSelector, enableEnhancedInsightPicker, getCatalogGroupsExpanded, isFreemiumEdition as isFreemiumEditionSelector, } from "../../selectors/feature_flag_selector.js";
+import { canManageProject as canManageProjectSelector } from "../../selectors/permissions_selector.js";
+import { getActiveGeoLabelType, isLocationIconEnabled as isLocationIconEnabledSelector, } from "../../services/reference_point_service.js";
+import { getAvailableItems, getHLLFilteredCatalogItems, getSortedCatalogGroups, getUpdatedItemsCount, isDateItemAvailable, isLoadingGroups as isLoadingGroupsSelector, isLoadingItems as isLoadingItemsSelector, isWorkspaceEmpty as isWorkspaceEmptySelector, shouldUnavailableItemsBeVisible as shouldUnavailableItemsBeVisibleSelector, } from "../../store/catalog/catalog_selector.js";
+import { OrganizedCatalogUtils } from "../../utils/organized_catalog.js";
+import { CatalogVisual as OrganizedCatalogVisual } from "./CatalogVisual.js";
+import { createOrganizedCatalogItem, useGroups } from "./hooks/GroupHook.js";
+import { useTabs } from "./hooks/TabsHook.js";
+import { isCatalogItemRef } from "./utils/equals.js";
+export function Catalog() {
+    const showDateItem = useSelector(isDateItemAvailable);
+    const isLoadingGroups = useSelector(isLoadingGroupsSelector);
+    const isLoadingItems = useSelector(isLoadingItemsSelector);
+    const items = useSelector(getAvailableItems);
+    const allItems = useSelector(getHLLFilteredCatalogItems);
+    const groups = useSelector(getSortedCatalogGroups);
+    const defaultExpandedState = useSelector(getCatalogGroupsExpanded);
+    const isLocationIconEnabled = useSelector(isLocationIconEnabledSelector);
+    const geoLabelType = useSelector(getActiveGeoLabelType);
+    const updatedItemsCount = useSelector(getUpdatedItemsCount);
+    const isWorkspaceEmpty = useSelector(isWorkspaceEmptySelector);
+    const canManageProject = useSelector(canManageProjectSelector);
+    const isFreemiumEdition = useSelector(isFreemiumEditionSelector);
+    const linkToDatasourcePage = useSelector(getLinkToDatasourcePage);
+    const shouldUnavailableItemsBeVisible = useSelector(shouldUnavailableItemsBeVisibleSelector);
+    const enableCatalogSmartSearchResults = useSelector(enableCatalogSmartSearchResultsSelector);
+    const isEnhancedInsightPickerEnabled = useSelector(enableEnhancedInsightPicker);
+    const dispatch = useDispatch();
+    const requestCatalogRefresh = useCallback((preventRefreshAvailability) => {
+        dispatch(CatalogUiActions.requestCatalogRefresh(preventRefreshAvailability));
+    }, [dispatch]);
+    const intl = useIntl();
+    const { tabAvailableItems, tabAllItems, onTabChanged, tabs, tabShowDateItem, tabSelectionStates, objectTypes, } = useTabs(items, allItems, true, isLocationIconEnabled, geoLabelType);
+    const itemBuilder = useCallback(((_, { ref }) => {
+        const item = allItems.find((item) => isCatalogItemRef(item, ref));
+        if (item) {
+            return createOrganizedCatalogItem(isLocationIconEnabled, geoLabelType, allItems)(item);
+        }
+        return null;
+    }), [allItems, geoLabelType, isLocationIconEnabled]);
+    const matcher = useMemo(() => customMatcher(["name", "title"]), []);
+    const { searchState, onSearchQueryChange, search } = useHybridSearch({
+        allowSematicSearch: enableCatalogSmartSearchResults,
+        deepSearch: false,
+        objectTypes,
+        itemBuilder,
+        matcher,
+    });
+    const { flatItems, allFlatItems, itemGroups, onGroupClick } = useGroups(groups, defaultExpandedState, tabAvailableItems, tabAllItems, searchState.debouncedQuery, isLoadingItems, isLocationIconEnabled, geoLabelType, intl, shouldUnavailableItemsBeVisible);
+    const { searchItems, searchAllItems, searchItemGroups, searchKeywords, searchRelatedItems, semanticSearchState, } = useMemo(() => search({
+        items: flatItems,
+        allItems: allFlatItems,
+        itemGroups: itemGroups,
+        keywords: [intl.formatMessage({ id: "date" })],
+    }), [allFlatItems, flatItems, intl, itemGroups, search]);
+    const unavailableItemsCount = OrganizedCatalogUtils.getUnavailableItemsCount(searchState.debouncedQuery, flatItems, allFlatItems, searchItems, searchAllItems);
+    return (_jsx(OrganizedCatalogVisual, { searchState: searchState, tabs: tabs, allItems: shouldUnavailableItemsBeVisible ? searchAllItems : searchItems, relatedItems: searchRelatedItems, itemGroups: searchItemGroups, hiddenItemsCount: unavailableItemsCount, showDateItem: showDateItem && tabShowDateItem && searchKeywords.length > 0 ? !isLoadingItems : null, isLoadingGroups: isLoadingGroups, isLoadingItems: isLoadingItems, isRelatedLoading: semanticSearchState.state === "loading", onGroupClick: onGroupClick, onSearchQueryChange: onSearchQueryChange, onTabChanged: onTabChanged, requestCatalogRefresh: requestCatalogRefresh, updatedItemsCount: updatedItemsCount, isWorkspaceEmpty: isWorkspaceEmpty, tabSelectionStates: tabSelectionStates, canManageProject: canManageProject, isFreemiumEdition: isFreemiumEdition, linkToDatasourcePage: linkToDatasourcePage, isEnhancedInsightPickerEnabled: isEnhancedInsightPickerEnabled }));
+}

package/esm/components/catalog/CatalogGroup.d.ts

@@ -0,0 +1,9 @@
+export interface ICatalogGroupProps {
+    name: string;
+    id: string;
+    isExpanded: boolean;
+    isLoading: boolean;
+    onClick: (groupId: string) => void;
+}
+export declare function CatalogGroup({ name, id, isExpanded, isLoading, onClick }: ICatalogGroupProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=CatalogGroup.d.ts.map

package/esm/components/catalog/CatalogGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CatalogGroup.d.ts","sourceRoot":"","sources":["../../../src/components/catalog/CatalogGroup.tsx"],"names":[],"mappings":"AAUA,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC;AAED,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,kBAAkB,2CAuB5F"}

package/esm/components/catalog/CatalogGroup.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2019-2026 GoodData Corporation
+import { useCallback } from "react";
+import classNames from "classnames";
+import { getCssClass } from "../../utils/css_class.js";
+import { Spinner } from "./blocks/Spinner.js";
+export function CatalogGroup({ name, id, isExpanded, isLoading, onClick }) {
+    const wrapperClasses = classNames("adi-catalog-group", "s-catalog-group", getCssClass(name, "s-catalog-group-"));
+    const labelClasses = classNames("adi-catalog-group-label", "s-catalog-group-label", {
+        expanded: isExpanded,
+        "s-is-expanded": isExpanded,
+    });
+    const handleClick = useCallback(() => onClick(id), [onClick, id]);
+    return (_jsxs("div", { className: wrapperClasses, children: [_jsx("div", { className: labelClasses, onClick: handleClick, title: name, children: _jsx("span", { children: name }) }), isExpanded ? (_jsx("div", { className: "adi-catalog-group-content", children: isLoading ? _jsx(Spinner, {}) : null })) : null] }));
+}

package/esm/components/catalog/CatalogList.d.ts

@@ -0,0 +1,39 @@
+import { type ComponentType } from "react";
+import { type IntlShape } from "react-intl";
+import { CellMeasurerCache, type ListRowProps } from "react-virtualized";
+import { type IOrganizedCatalogGroup, type IOrganizedCatalogItem } from "../../typings/catalog.js";
+export interface ICatalogListOwnProps {
+    showDateItem: boolean;
+    itemGroups: ReadonlyArray<IOrganizedCatalogGroup>;
+    relatedItems: ReadonlyArray<IOrganizedCatalogItem>;
+    isRelatedLoading: boolean;
+    isLoadingGroups: boolean;
+    isLoadingItems: boolean;
+    onGroupClick: (groupId: string) => void;
+    allItems: ReadonlyArray<IOrganizedCatalogItem>;
+    searchQuery: string;
+    isWorkspaceEmpty: boolean;
+    hiddenItemsCount: number;
+    selectedTabNames: string;
+    canManageProject: boolean;
+    isFreemiumEdition: boolean;
+    linkToDatasourcePage: string;
+}
+export type ICatalogListProps = ICatalogListOwnProps;
+export declare function CatalogSeparator(): import("react/jsx-runtime").JSX.Element;
+export declare function createDateItem(intl: IntlShape): IOrganizedCatalogItem;
+interface IVirtualizedListItem {
+    /** props are the opaque per-row bag; strictFunctionTypes stays off, so concrete components fit */
+    ListItemComponent: ComponentType<Record<string, unknown>>;
+    key: string;
+    props: Record<string, unknown>;
+}
+export declare function rowRenderer(list: IVirtualizedListItem[], cache: CellMeasurerCache): ({ index, style, parent }: ListRowProps) => import("react/jsx-runtime").JSX.Element;
+export declare function createVirtualizedListItem<P extends object>(key: string, component: ComponentType<P>, props?: P): IVirtualizedListItem;
+export declare function useVirtualizedCatalogList({ showDateItem, itemGroups, isLoadingItems, onGroupClick, allItems, isRelatedLoading, relatedItems, }: ICatalogListProps): {
+    list: IVirtualizedListItem[];
+    cache: import("react").RefObject<null>;
+};
+export declare const CatalogList: import("react").MemoExoticComponent<(props: ICatalogListProps) => import("react/jsx-runtime").JSX.Element>;
+export {};
+//# sourceMappingURL=CatalogList.d.ts.map

package/esm/components/catalog/CatalogList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CatalogList.d.ts","sourceRoot":"","sources":["../../../src/components/catalog/CatalogList.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,aAAa,EAAsC,MAAM,OAAO,CAAC;AAE/E,OAAO,EAAE,KAAK,SAAS,EAAW,MAAM,YAAY,CAAC;AACrD,OAAO,EAA2B,iBAAiB,EAAQ,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAKxG,OAAO,EAAE,KAAK,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAYnG,MAAM,WAAW,oBAAoB;IACjC,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,aAAa,CAAC,sBAAsB,CAAC,CAAC;IAClD,YAAY,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;IACnD,gBAAgB,EAAE,OAAO,CAAC;IAC1B,eAAe,EAAE,OAAO,CAAC;IACzB,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,QAAQ,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,oBAAoB,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,CAAC;AAErD,wBAAgB,gBAAgB,4CAM/B;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,qBAAqB,CAgBrE;AAED,UAAU,oBAAoB;IAC1B,kGAAkG;IAClG,iBAAiB,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1D,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,oBAAoB,EAAE,EAAE,KAAK,EAAE,iBAAiB,8BACtB,YAAY,6CAwBvE;AAED,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,MAAM,EACtD,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,EAC3B,KAAK,GAAE,CAAW,GACnB,oBAAoB,CAOtB;AAED,wBAAgB,yBAAyB,CAAC,EACtC,YAAY,EACZ,UAAU,EACV,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,gBAAgB,EAChB,YAAY,GACf,EAAE,iBAAiB;;;EAmGnB;AAED,eAAO,MAAM,WAAW,8CAAoC,iBAAiB,6CA8E3E,CAAC"}

package/esm/components/catalog/CatalogList.js

@@ -0,0 +1,141 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2019-2026 GoodData Corporation
+import { memo, useCallback, useMemo, useRef } from "react";
+import { useIntl } from "react-intl";
+import { AutoSizer, CellMeasurer, CellMeasurerCache, List } from "react-virtualized";
+import { simplifyText } from "@gooddata/util";
+import { DATE_DATASET_ATTRIBUTE } from "../../models/date_item.js";
+import { EmptyCatalogWarning } from "./blocks/EmptyCatalogWarning.js";
+import { EmptySearchResult } from "./blocks/EmptySearchResult.js";
+import { Spinner } from "./blocks/Spinner.js";
+import { CatalogGroup } from "./CatalogGroup.js";
+import { CatalogSuggestions } from "./CatalogSuggestion.js";
+import { CatalogListItemContainer } from "./item/CatalogListItemContainer.js";
+const CATALOG_ITEM_ADDITIONAL_PADDING = 10;
+const DEFAULT_CATALOG_ITEM_ROW_HEIGHT = 24;
+export function CatalogSeparator() {
+    return (_jsx("div", { className: "adi-catalog-separator", children: _jsx("hr", {}) }));
+}
+export function createDateItem(intl) {
+    return {
+        type: "date",
+        title: intl.formatMessage({
+            id: "date",
+        }),
+        ref: {
+            identifier: DATE_DATASET_ATTRIBUTE,
+        },
+        identifier: DATE_DATASET_ATTRIBUTE,
+        uri: DATE_DATASET_ATTRIBUTE,
+        summary: intl.formatMessage({
+            id: "dashboard.catalog_item.common_date_description.workspace",
+        }),
+        available: true,
+    };
+}
+export function rowRenderer(list, cache) {
+    function RowRendererComponent({ index, style, parent }) {
+        const { ListItemComponent, props, key } = list[index];
+        const additionalPadding = {
+            paddingTop: index === 0 ? CATALOG_ITEM_ADDITIONAL_PADDING : 0,
+            paddingBottom: index === list.length - 1 ? CATALOG_ITEM_ADDITIONAL_PADDING : 0,
+        };
+        return (_jsx(CellMeasurer, { cache: cache, parent: parent, columnIndex: 0, rowIndex: index, children: _jsx("div", { style: { ...style, ...additionalPadding }, children: _jsx(ListItemComponent, { ...props }) }) }, `${key + "_" + index}`));
+    }
+    return RowRendererComponent;
+}
+export function createVirtualizedListItem(key, component, props = {}) {
+    return {
+        key,
+        // the row renderer re-marries each component with exactly the props it was registered with
+        ListItemComponent: component,
+        props: props,
+    };
+}
+export function useVirtualizedCatalogList({ showDateItem, itemGroups, isLoadingItems, onGroupClick, allItems, isRelatedLoading, relatedItems, }) {
+    const intl = useIntl();
+    const cache = useRef(null);
+    return useMemo(() => {
+        const list = [];
+        if (showDateItem) {
+            list.push(createVirtualizedListItem("date_item", CatalogListItemContainer, {
+                item: createDateItem(intl),
+            }));
+        }
+        itemGroups.forEach((itemGroup) => {
+            list.push(createVirtualizedListItem(itemGroup.id, CatalogGroup, {
+                ...itemGroup,
+                onClick: onGroupClick,
+                isLoading: isLoadingItems,
+            }));
+            if (itemGroup.isExpanded) {
+                itemGroup.items.forEach((item) => {
+                    list.push(createVirtualizedListItem(`${itemGroup.id}_${item.identifier}`, CatalogListItemContainer, {
+                        item,
+                        className: `s-catalog-${simplifyText(itemGroup.id)}-group-item`,
+                    }));
+                });
+            }
+        });
+        const showSeparator = allItems.length > 0 && itemGroups.length > 0;
+        if (showSeparator) {
+            list.push(createVirtualizedListItem("catalog_separator", CatalogSeparator));
+        }
+        allItems.forEach((item) => {
+            list.push(createVirtualizedListItem(item.identifier, CatalogListItemContainer, {
+                item,
+                className: "s-catalog-flat-item",
+            }));
+        });
+        if (isRelatedLoading || relatedItems.length > 0) {
+            const group = {
+                name: intl.formatMessage({
+                    id: "catalog.group_title.suggestion",
+                }),
+                id: "suggestions",
+                items: relatedItems,
+                onClick: onGroupClick,
+                isLoading: isRelatedLoading,
+            };
+            list.push(createVirtualizedListItem(group.id, CatalogSuggestions, group));
+            if (!isRelatedLoading && relatedItems.length > 0) {
+                relatedItems.forEach((item) => {
+                    list.push(createVirtualizedListItem(`${group.id}_${item.identifier}`, CatalogListItemContainer, {
+                        item,
+                        className: `s-catalog-${simplifyText(group.id)}-group-item`,
+                    }));
+                });
+            }
+        }
+        cache.current = new CellMeasurerCache({
+            fixedWidth: true,
+            defaultHeight: DEFAULT_CATALOG_ITEM_ROW_HEIGHT,
+            keyMapper: (rowIndex) => list[rowIndex].key,
+        });
+        return { list, cache };
+    }, [
+        showDateItem,
+        itemGroups,
+        isLoadingItems,
+        onGroupClick,
+        allItems,
+        intl,
+        isRelatedLoading,
+        relatedItems,
+    ]);
+}
+export const CatalogList = memo(function CatalogList(props) {
+    const { showDateItem, itemGroups, isLoadingGroups, isLoadingItems, isRelatedLoading, relatedItems, allItems, searchQuery, isWorkspaceEmpty, hiddenItemsCount, selectedTabNames, canManageProject, isFreemiumEdition, linkToDatasourcePage, } = props;
+    const { list, cache: { current: currentCache }, } = useVirtualizedCatalogList(props);
+    const noLocalItemsFound = !showDateItem && itemGroups.length === 0 && allItems.length === 0;
+    const noItemsFound = noLocalItemsFound && !isRelatedLoading && relatedItems.length === 0;
+    const isSearch = searchQuery && searchQuery.length !== 0;
+    const showGlobalLoading = isLoadingGroups || (isLoadingItems && itemGroups.length === 0);
+    const getRowHeight = useCallback((info) => {
+        return (currentCache.rowHeight(info) ||
+            (info.index === 0
+                ? DEFAULT_CATALOG_ITEM_ROW_HEIGHT + CATALOG_ITEM_ADDITIONAL_PADDING
+                : DEFAULT_CATALOG_ITEM_ROW_HEIGHT));
+    }, [currentCache]);
+    return (_jsxs("div", { className: "adi-catalog-list", children: [showGlobalLoading ? (_jsx("div", { className: "adi-catalog-loading-group", children: _jsx(Spinner, {}) })) : null, !showGlobalLoading && noLocalItemsFound ? (isSearch ? (_jsx(EmptySearchResult, { searchPhrase: searchQuery })) : (_jsx(EmptyCatalogWarning, { selectedTabNames: selectedTabNames, isWorkspaceEmpty: isWorkspaceEmpty, hiddenItemsCount: hiddenItemsCount, canManageProject: canManageProject, isFreemiumEdition: isFreemiumEdition, linkToDatasourcePage: linkToDatasourcePage }))) : null, !showGlobalLoading && !noItemsFound && (_jsx(AutoSizer, { children: ({ width, height }) => (_jsx(List, { height: height, width: width, rowCount: list.length, rowRenderer: rowRenderer(list, currentCache), deferredMeasurementCache: currentCache, rowHeight: getRowHeight, style: { paddingBottom: "29px" } })) }))] }));
+});

package/esm/components/catalog/CatalogSuggestion.d.ts

@@ -0,0 +1,6 @@
+export interface ICatalogSuggestionsProps {
+    name: string;
+    isLoading: boolean;
+}
+export declare function CatalogSuggestions({ name, isLoading }: ICatalogSuggestionsProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=CatalogSuggestion.d.ts.map

package/esm/components/catalog/CatalogSuggestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CatalogSuggestion.d.ts","sourceRoot":"","sources":["../../../src/components/catalog/CatalogSuggestion.tsx"],"names":[],"mappings":"AAQA,MAAM,WAAW,wBAAwB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACtB;AAED,wBAAgB,kBAAkB,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,wBAAwB,2CA0B/E"}