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

package/esm/components/InsightUsageOnDashboards.js

@@ -0,0 +1,59 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2020-2026 GoodData Corporation
+import { useCallback, useId, useState } from "react";
+import classNames from "classnames";
+import { FormattedMessage, useIntl } from "react-intl";
+import { useSelector } from "react-redux";
+import { Header, Item, ItemsWrapper, Overlay, UiButton, UiFocusManager } from "@gooddata/sdk-ui-kit";
+import { getIsEmbedded } from "../selectors/meta_selector.js";
+import { getSourceDashboardId, isAllowedDashboardLinks } from "../selectors/route_selector.js";
+import { analyticalDashboardUriFactorySelector, } from "../selectors/uri_selector.js";
+import { getInsightUsageOnDashboardsSelector } from "../store/insight_usage/insight_usage_selectors.js";
+function DashboardItem({ dashboard, sourceDashboardIdentifier, isEmbedded, analyticalDashboardUriFactory, }) {
+    const { title, id } = dashboard;
+    const isEditingNow = id === sourceDashboardIdentifier && isEmbedded;
+    const isAllowedGoToDashboard = !isEmbedded && isAllowedDashboardLinks && id !== sourceDashboardIdentifier;
+    const cssClassNames = classNames("gd-list-item", "gd-menu-item s-usage-item", {
+        "editing-now": isEditingNow,
+        "external-icon-link": isAllowedGoToDashboard,
+    });
+    const goToDashboard = useCallback(() => {
+        if (isAllowedGoToDashboard) {
+            const dashboardUri = analyticalDashboardUriFactory(id);
+            const externalUri = `${window.location.origin}${dashboardUri}`;
+            window.open(externalUri, "_blank");
+        }
+    }, [isAllowedGoToDashboard, id, analyticalDashboardUriFactory]);
+    return (_jsxs(Item, { className: cssClassNames, onClick: goToDashboard, children: [_jsx("p", { className: "gd-dashboard-link", title: title, children: title }), _jsx("span", { className: "gd-dashboard-link-hover-icon", children: isEditingNow ? _jsx(FormattedMessage, { id: "dashboard.editing.now" }) : null })] }));
+}
+function InaccessibleDashboardsMessage({ count }) {
+    return (_jsx("div", { className: "gd-usages-inaccessible-dashboards s-usages-inaccessible-dashboards", children: _jsx(FormattedMessage, { id: "dialogs.usage.inaccessibleDashboards", values: { count, b: (chunks) => _jsx("b", { children: chunks }) } }) }));
+}
+function OnlyInaccessibleDashboardsMessage({ count }) {
+    return (_jsx("div", { className: "gd-usages-inaccessible-dashboards-only s-usages-inaccessible-dashboards-only", children: _jsx(FormattedMessage, { id: "dialogs.usage.inaccessibleDashboardsOnly", values: { count } }) }));
+}
+function DashboardItemsDialog({ onClose, insightUsageOnDashboard, sourceDashboardIdentifier, isEmbedded, analyticalDashboardUriFactory, isAllowedDashboardLinks, }) {
+    const { accessibleDashboards, inaccessibleDashboardsCount } = insightUsageOnDashboard;
+    const headerId = useId();
+    const renderInaccessibleOnly = accessibleDashboards.length === 0 && inaccessibleDashboardsCount > 0;
+    const renderAlsoInaccessible = accessibleDashboards.length > 0 && inaccessibleDashboardsCount > 0;
+    return (_jsx(Overlay, { alignTo: ".gd-insight-usage-on-dashboards", alignPoints: [{ align: "bl tl" }], closeOnMouseDrag: true, closeOnOutsideClick: true, closeOnEscape: true, onClose: onClose, className: "gd-insight-usages-overlay s-insight-usages-overlay", children: _jsx(UiFocusManager, { enableAutofocus: true, enableReturnFocusOnUnmount: true, children: _jsx("div", { role: "dialog", "aria-labelledby": headerId, tabIndex: 0, children: _jsxs(ItemsWrapper, { smallItemsSpacing: true, children: [_jsx(Header, { children: _jsx("span", { id: headerId, children: _jsx(FormattedMessage, { id: "insight.usages.overlay.header" }) }) }), _jsxs("div", { className: "gd-usages-overlay-body s-usages-overlay-body", children: [insightUsageOnDashboard.accessibleDashboards.map((dashboard) => (_jsx(DashboardItem, { dashboard: dashboard, isEmbedded: isEmbedded, sourceDashboardIdentifier: sourceDashboardIdentifier, isAllowedDashboardLinks: isAllowedDashboardLinks, analyticalDashboardUriFactory: analyticalDashboardUriFactory }, dashboard.id))), renderAlsoInaccessible ? (_jsx(InaccessibleDashboardsMessage, { count: inaccessibleDashboardsCount })) : null, renderInaccessibleOnly ? (_jsx(OnlyInaccessibleDashboardsMessage, { count: inaccessibleDashboardsCount })) : null] })] }) }) }) }));
+}
+export function InsightUsageOnDashboards() {
+    const insightUsageOnDashboard = useSelector(getInsightUsageOnDashboardsSelector);
+    const isEmbedded = useSelector(getIsEmbedded);
+    const sourceDashboardIdentifier = useSelector(getSourceDashboardId);
+    // aliased so the local value does not shadow the isAllowedDashboardLinks selector it is read with
+    const isDashboardLinksAllowed = useSelector(isAllowedDashboardLinks);
+    const analyticalDashboardUriFactory = useSelector(analyticalDashboardUriFactorySelector);
+    const intl = useIntl();
+    const [isOpen, setOpen] = useState(false);
+    const toggleOpen = () => setOpen((state) => !state);
+    const usageLabel = intl.formatMessage({ id: "insight.usages.button.label" }, { dashboardsCount: insightUsageOnDashboard.allDashboardsCount });
+    return (_jsxs("div", { className: "gd-insight-usage-on-dashboards s-gd-insight-usage-on-dashboards", children: [_jsx(UiButton, { label: String(insightUsageOnDashboard.allDashboardsCount), variant: "tertiary", size: "medium", iconBefore: "dashboard", isSelected: isOpen, onClick: toggleOpen, tooltip: usageLabel, dataTestId: "s-insight-usages-of-dashboards-link", accessibilityConfig: {
+                    ariaLabel: usageLabel,
+                    ariaHaspopup: "dialog",
+                    ariaExpanded: isOpen,
+                    iconAriaHidden: true,
+                } }), isOpen ? (_jsx(DashboardItemsDialog, { insightUsageOnDashboard: insightUsageOnDashboard, isEmbedded: isEmbedded, sourceDashboardIdentifier: sourceDashboardIdentifier, isAllowedDashboardLinks: isDashboardLinksAllowed, analyticalDashboardUriFactory: analyticalDashboardUriFactory, onClose: toggleOpen })) : null] }));
+}

package/esm/components/Messages.d.ts

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

package/esm/components/Messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Messages.d.ts","sourceRoot":"","sources":["../../src/components/Messages.tsx"],"names":[],"mappings":"AAcA,wBAAgB,QAAQ,4CA6CvB"}

package/esm/components/Messages.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useCallback } from "react";
+import { useIntl } from "react-intl";
+import { useDispatch, useSelector } from "react-redux";
+import { NonContextToastsInterop } from "@gooddata/sdk-ui-kit";
+import { hideMessage } from "../actions/messages_actions.js";
+import { displayedMessagesSelector } from "../selectors/messages_selector.js";
+export function Messages() {
+    const intl = useIntl();
+    const dispatch = useDispatch();
+    const messages = useSelector((state) => displayedMessagesSelector(state).messages);
+    const onDismissMessage = useCallback((messageId) => {
+        dispatch(hideMessage(messageId));
+    }, [dispatch]);
+    function formatMessage({ text: id, values }) {
+        if (!id) {
+            return { text: "" };
+        }
+        const formatted = intl.formatMessage({ id }, { ...values, b: bold });
+        return typeof formatted === "string" ? { text: formatted } : { text: "", node: formatted };
+    }
+    const localizedMessages = messages
+        .map((message) => ({ ...message, ...formatMessage(message) }))
+        .map((message) => {
+        const errorDetails = message.errorDetails || undefined;
+        if (errorDetails) {
+            const errorDetail = intl.formatMessage({ id: errorDetails.id }, errorDetails.values);
+            return {
+                ...message,
+                showMore: intl.formatMessage({ id: "messages.showMore" }),
+                showLess: intl.formatMessage({ id: "messages.showLess" }),
+                errorDetail,
+            };
+        }
+        return message;
+    });
+    return (_jsx(NonContextToastsInterop
+    // the runtime message shape matches the ui-kit toast contract; the repo model is wider
+    , { 
+        // the runtime message shape matches the ui-kit toast contract; the repo model is wider
+        messages: localizedMessages, onDismissMessage: onDismissMessage }));
+}
+function bold(chunks) {
+    return _jsx("strong", { children: chunks });
+}

package/esm/components/MetricEditorDialog.d.ts

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

package/esm/components/MetricEditorDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricEditorDialog.d.ts","sourceRoot":"","sources":["../../src/components/MetricEditorDialog.tsx"],"names":[],"mappings":"AAiEA,wBAAgB,kBAAkB,mDA2MjC"}

package/esm/components/MetricEditorDialog.js

@@ -0,0 +1,116 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useIntl } from "react-intl";
+import { useDispatch, useSelector } from "react-redux";
+import { isInsight, isMeasureMetadataObject, isMeasureMetadataObjectDefinition, } from "@gooddata/sdk-model";
+import { DialogBase } from "@gooddata/sdk-ui-kit";
+import { ConflictContextProvider, ManageMetrics, MetricService, MinimizeMetrics, MultipleMetricsState, } from "@gooddata/sdk-ui-metric-component";
+import { openReport } from "../actions/open_actions.js";
+import { clearCache } from "../backend.js";
+import { getProjectId, getSeparators, isBranded } from "../selectors/bootstrap_selector.js";
+import { enableMetricFormatOverrides, enableMetricPermissions, getCurrencyFormatOverride, getDefaultMetricVisibility, } from "../selectors/feature_flag_selector.js";
+import { getInsightForSaveViaMd } from "../selectors/insight_selectors.js";
+import { effectiveWorkspacePermissions } from "../selectors/metric_permissions_selector.js";
+import { metricEditorCancelUnsavedChangesDialog, metricEditorCloseTabs, metricEditorFocusTab, metricEditorMaximize, metricEditorMetricDeleteError, metricEditorMetricDeleted, metricEditorMetricSaveError, metricEditorMetricSaved, metricEditorMinimize, metricEditorOpen, metricEditorOpenFromDialog, metricEditorOpenNew, metricEditorUnsavedChanges, } from "../store/metric_editor/metric_editor_actions.js";
+import { getMetricEditorActiveIndex, getMetricEditorIsMinimized, getMetricEditorOpenedMetrics, getSaveAllRequestNumber, } from "../store/metric_editor/metric_editor_selector.js";
+import { checkMetricOverrides } from "../utils/api.js";
+import { usePrefixes } from "../utils/hooks/usePrefixes.js";
+export function MetricEditorDialog() {
+    const intl = useIntl();
+    const dispatch = useDispatch();
+    const metrics = useSelector(getMetricEditorOpenedMetrics);
+    const activeIndex = useSelector(getMetricEditorActiveIndex);
+    const isMinimized = useSelector(getMetricEditorIsMinimized);
+    const saveAllRequestNumber = useSelector(getSaveAllRequestNumber);
+    const permissions = useSelector(effectiveWorkspacePermissions);
+    const activeInsight = useSelector(getInsightForSaveViaMd);
+    const isWhiteLabeled = useSelector(isBranded);
+    const separators = useSelector(getSeparators);
+    const workspaceId = useSelector(getProjectId);
+    const currencyFormatOverride = useSelector(getCurrencyFormatOverride);
+    const isMetricFormatOverridesEnabled = useSelector(enableMetricFormatOverrides);
+    const areMetricPermissionsEnabled = useSelector(enableMetricPermissions);
+    const defaultMetricVisibility = useSelector(getDefaultMetricVisibility);
+    const createTab = useCallback(() => {
+        dispatch(metricEditorOpenNew("OPEN_NEW_TAB"));
+    }, [dispatch]);
+    const openTabFromDialog = useCallback((metricInfo) => {
+        dispatch(metricEditorOpenFromDialog(metricInfo));
+    }, [dispatch]);
+    const activateTab = useCallback((metricInfo) => {
+        dispatch(metricEditorFocusTab(metricInfo.identifier));
+    }, [dispatch]);
+    const minimize = useCallback(() => {
+        dispatch(metricEditorMinimize());
+    }, [dispatch]);
+    const maximize = useCallback(() => {
+        dispatch(metricEditorMaximize());
+    }, [dispatch]);
+    const onClose = useCallback((metricInfos) => {
+        dispatch(metricEditorCloseTabs(metricInfos.map((info) => info.identifier)));
+    }, [dispatch]);
+    const onDirtyChanged = useCallback((isUnsaved) => {
+        dispatch(metricEditorUnsavedChanges(isUnsaved));
+    }, [dispatch]);
+    const onMetricDeleted = useCallback((metric) => {
+        dispatch(metricEditorMetricDeleted(metric));
+    }, [dispatch]);
+    const onMetricDeletedError = useCallback((metric, error) => {
+        dispatch(metricEditorMetricDeleteError(metric, error));
+    }, [dispatch]);
+    const onMetricSave = useCallback((metric, info, mode) => {
+        dispatch(metricEditorMetricSaved(metric, info, mode));
+    }, [dispatch]);
+    const onMetricSaveError = useCallback((metric, error) => {
+        dispatch(metricEditorMetricSaveError(metric, error));
+    }, [dispatch]);
+    const onMetricClick = useCallback((metric) => {
+        dispatch(metricEditorOpen(metric.ref));
+    }, [dispatch]);
+    const onInsightClick = useCallback((insight) => {
+        const action = openReport(insight.insight, false);
+        dispatch(action);
+    }, [dispatch]);
+    const onCancelUnsavedChangesDialog = useCallback(() => {
+        dispatch(metricEditorUnsavedChanges(false));
+        dispatch(metricEditorCancelUnsavedChangesDialog());
+    }, [dispatch]);
+    const serviceProps = {
+        settings: { enableMetricPermissions: areMetricPermissionsEnabled, defaultMetricVisibility },
+    };
+    const manageMetricsRef = useRef(undefined);
+    const [initSaveAllRequestNumber] = useState(saveAllRequestNumber);
+    const prefixes = usePrefixes(metrics);
+    useEffect(() => {
+        if (initSaveAllRequestNumber === saveAllRequestNumber) {
+            return;
+        }
+        void manageMetricsRef.current?.saveAndCloseAll().then(({ status }) => {
+            if (status === "canceled") {
+                onCancelUnsavedChangesDialog();
+            }
+        });
+    }, [initSaveAllRequestNumber, onCancelUnsavedChangesDialog, saveAllRequestNumber]);
+    const handleMetricDeleted = useCallback((metric, _, err) => {
+        if (err) {
+            return onMetricDeletedError(metric, err);
+        }
+        return onMetricDeleted(metric);
+    }, [onMetricDeleted, onMetricDeletedError]);
+    const handleMetricSave = useCallback((metric, info, err) => {
+        const mode = isMeasureMetadataObjectDefinition(info.previousMetric) ? "new" : "edit";
+        if (err) {
+            return onMetricSaveError(metric, err);
+        }
+        else {
+            return onMetricSave(metric, info, mode);
+        }
+    }, [onMetricSave, onMetricSaveError]);
+    if (metrics.length > 0 && prefixes !== null) {
+        return (_jsx(ConflictContextProvider, { checker: (data) => checkMetricOverrides(workspaceId, data), children: _jsx(MetricService, { ...serviceProps, children: _jsx(MultipleMetricsState, { metrics: metrics, active: activeIndex, permissions: permissions, onMetricsChange: () => {
+                        clearCache();
+                    }, onSave: handleMetricSave, onDelete: handleMetricDeleted, onDirtyChanged: onDirtyChanged, metricOpenType: "internal", onMetricClick: (metric) => isMeasureMetadataObject(metric) && onMetricClick(metric), activeInsight: activeInsight, insightOpenType: "internal", onInsightClick: (object) => isInsight(object) && onInsightClick(object), onCancel: (tabId) => onClose([tabId]), onClose: onClose, createTab: createTab, openTab: (metricInfo) => openTabFromDialog(metricInfo), activateTab: activateTab, children: _jsx(DialogBase, { className: "editMetricDialog", onMouseUp: () => { }, submitOnEnterKey: false, children: isMinimized ? (_jsx(MinimizeMetrics, { locale: intl.locale, setMinimized: maximize })) : (_jsx(ManageMetrics, { ref: manageMetricsRef, locale: intl.locale, permissions: permissions, prefixes: prefixes, setMinimized: minimize, setMaximized: () => { }, isWhiteLabeled: isWhiteLabeled, separators: separators, useReferences: true, currencyFormatOverride: currencyFormatOverride, enableMetricFormatOverrides: isMetricFormatOverridesEnabled })) }) }) }) }));
+    }
+    return null;
+}

package/esm/components/OpenReportDialog.d.ts

@@ -0,0 +1,8 @@
+import { ConfirmDialog as ConfirmDialogComponent } from "@gooddata/sdk-ui-kit";
+interface IOpenReportDialogProps {
+    /** test seam: defaults to the ui-kit dialog */
+    ConfirmDialog?: typeof ConfirmDialogComponent;
+}
+export declare function OpenReportDialog({ ConfirmDialog }: IOpenReportDialogProps): false | import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=OpenReportDialog.d.ts.map

package/esm/components/OpenReportDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenReportDialog.d.ts","sourceRoot":"","sources":["../../src/components/OpenReportDialog.tsx"],"names":[],"mappings":"AAOA,OAAO,EAAE,aAAa,IAAI,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAO/E,UAAU,sBAAsB;IAC5B,+CAA+C;IAC/C,aAAa,CAAC,EAAE,OAAO,sBAAsB,CAAC;CACjD;AAED,wBAAgB,gBAAgB,CAAC,EAAE,aAAsC,EAAE,EAAE,sBAAsB,mDAiClG"}

package/esm/components/OpenReportDialog.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useCallback } from "react";
+import { useIntl } from "react-intl";
+import { useDispatch, useSelector } from "react-redux";
+import { ConfirmDialog as ConfirmDialogComponent } from "@gooddata/sdk-ui-kit";
+import { hideDialog } from "../actions/dialogs_actions.js";
+import { openReport } from "../actions/open_actions.js";
+import { openReportDialogSelector } from "../selectors/dialogs_selector.js";
+export function OpenReportDialog({ ConfirmDialog = ConfirmDialogComponent }) {
+    const intl = useIntl();
+    const dispatch = useDispatch();
+    const { openReportDialog } = useSelector(openReportDialogSelector);
+    const insightRef = openReportDialog.data;
+    const onHideDialog = useCallback(() => {
+        dispatch(hideDialog());
+    }, [dispatch]);
+    // insightRef is always set while the dialog is active; the guard only keeps the null out of the action.
+    const onOpenReportDialogConfirm = useCallback(() => {
+        if (insightRef) {
+            dispatch(openReport(insightRef, true));
+        }
+    }, [dispatch, insightRef]);
+    if (openReportDialog.active) {
+        return (_jsx(ConfirmDialog, { onCancel: onHideDialog, onSubmit: onOpenReportDialogConfirm, className: "s-dialog", headline: intl.formatMessage({ id: "dialogs.openReportConfirmation.headline" }), cancelButtonText: intl.formatMessage({ id: "dialogs.openReportConfirmation.cancel" }), submitButtonText: intl.formatMessage({ id: "dialogs.openReportConfirmation.confirm" }), children: _jsx("p", { children: intl.formatMessage({ id: "dialogs.openReportConfirmation.description" }) }) }));
+    }
+    return false;
+}

package/esm/components/PoweredByGDLogo.d.ts

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

package/esm/components/PoweredByGDLogo.d.ts.map

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

package/esm/components/PoweredByGDLogo.js

@@ -0,0 +1,14 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useDispatch, useSelector } from "react-redux";
+import { poweredByGDCClicked } from "../sagas/powered_by_gdc/powered_by_gdc_ui_actions.js";
+import { isPoweredByGDLogoPresent, poweredByGDLogoLink } from "../selectors/PoweredByLogoSelector.js";
+export function PoweredByGDLogo() {
+    const isPresent = useSelector((state) => isPoweredByGDLogoPresent(state));
+    const logoLink = useSelector((state) => poweredByGDLogoLink(state));
+    const dispatch = useDispatch();
+    const logPoweredByGDClicked = () => {
+        dispatch(poweredByGDCClicked());
+    };
+    return (_jsx(_Fragment, { children: isPresent ? (_jsx("div", { className: "gd-powered-by-logo-wrapper", onClick: logPoweredByGDClicked, children: _jsx("a", { href: logoLink, target: "_blank", rel: "noopener noreferrer" }) })) : null }));
+}

package/esm/components/Recommendations.d.ts

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

package/esm/components/Recommendations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Recommendations.d.ts","sourceRoot":"","sources":["../../src/components/Recommendations.tsx"],"names":[],"mappings":"AAmDA,wBAAgB,eAAe,oDA0J9B"}

package/esm/components/Recommendations.js

@@ -0,0 +1,103 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useCallback } from "react";
+import { useIntl } from "react-intl";
+import { useDispatch, useSelector } from "react-redux";
+import { Button } from "@gooddata/sdk-ui-kit";
+import { GRANULARITY_OPTIONS, isFiscalGranularity, isStandardGranularity, } from "../models/granularity.js";
+import { getActiveCalendars } from "../selectors/feature_flag_selector.js";
+import { displayRecommendationBlockSelector, displayRecommendationComparisonSelector, displayRecommendationComparisonWithPeriodSelector, displayRecommendationContributionInPercentsSelector, displayRecommendationFilteringSelector, displayRecommendationsMetricWithPeriodSelector, displayRecommendationsTrendingSelector, isGeoSegmentConflictRecommendedSelector, isRecommendationDismissedForVisClass, } from "../selectors/recommendations_selector.js";
+import { getVisualizationClassTypeFromState } from "../services/visualization_class_service.js";
+import { getAvailableAttributes } from "../store/catalog/catalog_selector.js";
+import { applyComparison, applyComparisonWithPeriod, applyContributionInPercents, applyFiltering, applyMetricWithPeriod, applyTrending, dismissRecommendations, } from "../store/recommendations/recommendations_actions.js";
+import { RecommendationComparison } from "./recommendations/RecommendationComparison.js";
+import { RecommendationComparisonWithPeriod } from "./recommendations/RecommendationComparisonWithPeriod.js";
+import { RecommendationContributionInPercents } from "./recommendations/RecommendationContributionInPercents.js";
+import { RecommendationFiltering, } from "./recommendations/RecommendationFiltering.js";
+import { RecommendationMetricWithPeriod } from "./recommendations/RecommendationMetricWithPeriod.js";
+import { RecommendationTrending } from "./recommendations/RecommendationTrending.js";
+export function Recommendations() {
+    const dispatch = useDispatch();
+    const displayRecommendationBlock = useSelector(displayRecommendationBlockSelector);
+    const displayContributionInPercents = useSelector(displayRecommendationContributionInPercentsSelector);
+    const displayMetricWithPeriod = useSelector(displayRecommendationsMetricWithPeriodSelector);
+    const displayComparisonWithPeriod = useSelector(displayRecommendationComparisonWithPeriodSelector);
+    const displayTrending = useSelector(displayRecommendationsTrendingSelector);
+    const displayComparison = useSelector(displayRecommendationComparisonSelector);
+    const displayFiltering = useSelector(displayRecommendationFilteringSelector);
+    const isGeoSegmentConflictRecommended = useSelector(isGeoSegmentConflictRecommendedSelector);
+    const isRecommendationsDismissed = useSelector(isRecommendationDismissedForVisClass);
+    const availableAttributes = useSelector(getAvailableAttributes);
+    const visualization = useSelector(getVisualizationClassTypeFromState);
+    const activeCalendars = useSelector(getActiveCalendars);
+    const filteringVariant = isGeoSegmentConflictRecommended
+        ? "geoSegmentConflict"
+        : "default";
+    const handleApplyComparisonWithPeriod = useCallback((granularity) => {
+        dispatch(applyComparisonWithPeriod(granularity));
+    }, [dispatch]);
+    const handleApplyContributionInPercents = useCallback(() => {
+        dispatch(applyContributionInPercents());
+    }, [dispatch]);
+    const handleApplyMetricWithPeriod = useCallback(() => {
+        dispatch(applyMetricWithPeriod());
+    }, [dispatch]);
+    const handleApplyTrending = useCallback((granularity) => {
+        dispatch(applyTrending(granularity));
+    }, [dispatch]);
+    const handleApplyComparison = useCallback((attributeRef) => {
+        dispatch(applyComparison(attributeRef));
+    }, [dispatch]);
+    const handleApplyFiltering = useCallback(() => {
+        dispatch(applyFiltering());
+    }, [dispatch]);
+    const fiscalActive = activeCalendars?.fiscal === true;
+    const standardActive = activeCalendars?.standard !== false;
+    const fiscalDefault = activeCalendars?.default === "FISCAL";
+    const intl = useIntl();
+    const filteredGranularityOptions = GRANULARITY_OPTIONS.filter((g) => {
+        if (isFiscalGranularity(g.dateType))
+            return fiscalActive;
+        if (isStandardGranularity(g.dateType))
+            return standardActive;
+        return true;
+    }).sort((a, b) => {
+        // Put the default calendar granularities first
+        const aIsDefault = fiscalDefault
+            ? isFiscalGranularity(a.dateType)
+            : isStandardGranularity(a.dateType);
+        const bIsDefault = fiscalDefault
+            ? isFiscalGranularity(b.dateType)
+            : isStandardGranularity(b.dateType);
+        if (aIsDefault === bIsDefault)
+            return 0;
+        return aIsDefault ? -1 : 1;
+    });
+    const getContributionInPercents = (show) => {
+        return show && _jsx(RecommendationContributionInPercents, { onApply: handleApplyContributionInPercents });
+    };
+    const getMetricWithPeriod = (show) => {
+        return show && _jsx(RecommendationMetricWithPeriod, { onApply: handleApplyMetricWithPeriod });
+    };
+    const getComparisonWithPeriod = (show) => {
+        return (show && (_jsx(RecommendationComparisonWithPeriod, { granularityOptions: filteredGranularityOptions, onApply: handleApplyComparisonWithPeriod })));
+    };
+    const getTrending = (show) => {
+        return (show && (_jsx(RecommendationTrending, { granularityOptions: filteredGranularityOptions, onApply: handleApplyTrending })));
+    };
+    const getComparison = (show) => {
+        return (show && (_jsx(RecommendationComparison, { availableAttributes: availableAttributes, onApply: handleApplyComparison })));
+    };
+    const getFiltering = (show) => {
+        return (show &&
+            !isRecommendationsDismissed && (_jsx(RecommendationFiltering, { onApply: handleApplyFiltering, variant: filteringVariant })));
+    };
+    const renderTurnOffButton = () => {
+        /**
+         * We currently only allow to hide the block using the "filtering" recommendation.
+         */
+        return (displayFiltering &&
+            !isRecommendationsDismissed && (_jsx(Button, { className: "gd-button-link-dimmed adi-recommendations-turn-off-button s-recommendations-turn-off", tagName: "a", value: intl.formatMessage({ id: "dashboard.recommendation.turn_off" }), onClick: () => dispatch(dismissRecommendations(visualization)) })));
+    };
+    return (displayRecommendationBlock && (_jsxs("div", { className: "adi-recommendations-container s-adi-recommendations-container", children: [_jsxs("div", { className: "adi-recommendations-title-wrapper", children: [_jsx("div", { className: "adi-recommendations-title", children: intl.formatMessage({ id: "dashboard.recommendation.recommended_next_steps" }) }), renderTurnOffButton()] }), getFiltering(displayFiltering), getTrending(displayTrending), getComparison(displayComparison), getContributionInPercents(displayContributionInPercents), getComparisonWithPeriod(displayComparisonWithPeriod), getMetricWithPeriod(displayMetricWithPeriod)] })));
+}

package/esm/components/Report.d.ts

@@ -0,0 +1,34 @@
+import { type IExtendedRefPointCustomError } from "../store/reference_point/extended_reference_point_state.js";
+import { type IMissingDateFilterItem } from "../typings/report.js";
+export interface IReportProps {
+    projectId: string;
+    appSessionId: string;
+    isExecutionRunning?: boolean;
+    isReportNotFound?: boolean;
+    reportNotFoundMissingItems?: ReadonlyArray<IMissingDateFilterItem>;
+    isReportTooLargeToCompute?: boolean;
+    isReportTooLargeToDisplay?: boolean;
+    isInvalidConfiguration?: boolean;
+    isReportWithFiltersEmpty?: boolean;
+    isReportWithoutFiltersEmpty?: boolean;
+    isBadRequest?: boolean;
+    isReportProtected?: boolean;
+    isMissingLocation?: boolean;
+    isMissingArea?: boolean;
+    isMissingMetric?: boolean;
+    isMissingColumns?: boolean;
+    isSmallScreen?: boolean;
+    isExecutable?: boolean;
+    isComputingShortcut?: boolean;
+    isNoMetricSupported?: boolean;
+    hasNegativeValue?: boolean;
+    unsupportedConfiguration?: boolean;
+    hasReportLoadingError?: boolean;
+    customError?: IExtendedRefPointCustomError | null;
+    messages?: Record<string, string>;
+}
+export declare const ReportBase: import("react").MemoExoticComponent<({ projectId, appSessionId, messages, isSmallScreen, isExecutionRunning, isReportNotFound, reportNotFoundMissingItems, isReportTooLargeToCompute, isReportTooLargeToDisplay, isInvalidConfiguration, isReportWithFiltersEmpty, isReportWithoutFiltersEmpty, isBadRequest, isReportProtected, isMissingLocation, isMissingArea, isMissingMetric, isMissingColumns, isExecutable, isComputingShortcut, isNoMetricSupported, hasNegativeValue, unsupportedConfiguration, hasReportLoadingError, customError, }: IReportProps) => import("react/jsx-runtime").JSX.Element>;
+export declare function Report({ isSmallScreen }: {
+    isSmallScreen: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Report.d.ts.map

package/esm/components/Report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Report.d.ts","sourceRoot":"","sources":["../../src/components/Report.tsx"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,4DAA4D,CAAC;AAC/G,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAoBnE,MAAM,WAAW,YAAY;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,0BAA0B,CAAC,EAAE,aAAa,CAAC,sBAAsB,CAAC,CAAC;IACnE,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,WAAW,CAAC,EAAE,4BAA4B,GAAG,IAAI,CAAC;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC;AAED,eAAO,MAAM,UAAU,mhBA0BpB,YAAY,6CA2Db,CAAC;AAEH,wBAAgB,MAAM,CAAC,EAAE,aAAa,EAAE,EAAE;IAAE,aAAa,EAAE,OAAO,CAAA;CAAE,2CAInE"}

package/esm/components/Report.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { memo } from "react";
+import classNames from "classnames";
+import { useSelector } from "react-redux";
+import { reportSelector } from "../selectors/report_selector.js";
+import { ReportBlank } from "./report/ReportBlank.js";
+import { ReportComputing } from "./report/ReportComputing.js";
+import { ReportCustomError } from "./report/ReportCustomError.js";
+import { ReportEmpty } from "./report/ReportEmpty.js";
+import { ReportExecuteProtected } from "./report/ReportExecuteProtected.js";
+import { ReportHasNegativeValues } from "./report/ReportHasNegativeValues.js";
+import { ReportInvalidConfiguration } from "./report/ReportInvalidConfiguration.js";
+import { ReportMissingArea } from "./report/ReportMissingArea.js";
+import { ReportMissingColumns } from "./report/ReportMissingColumns.js";
+import { ReportMissingLocation } from "./report/ReportMissingLocation.js";
+import { ReportMissingMetric } from "./report/ReportMissingMetric.js";
+import { ReportNotFound } from "./report/ReportNotFound.js";
+import { ReportTooLargeToCompute } from "./report/ReportTooLargeToCompute/ReportTooLargeToCompute.js";
+import { ReportTooLargeToDisplay } from "./report/ReportTooLargeToDisplay.js";
+import { ReportUnsupportedConfiguration } from "./report/ReportUnsupportedConfiguration.js";
+import { ReportVisualization } from "./report/ReportVisualization.js";
+import { WorkspaceEmpty } from "./report/WorkspaceEmpty.js";
+export const ReportBase = memo(function Report({ projectId = null, appSessionId, messages = {}, isSmallScreen = false, isExecutionRunning = false, isReportNotFound = false, reportNotFoundMissingItems, isReportTooLargeToCompute = false, isReportTooLargeToDisplay = false, isInvalidConfiguration = false, isReportWithFiltersEmpty = false, isReportWithoutFiltersEmpty = false, isBadRequest = false, isReportProtected = false, isMissingLocation = false, isMissingArea = false, isMissingMetric = false, isMissingColumns = false, isExecutable = false, isComputingShortcut = false, isNoMetricSupported, hasNegativeValue = false, unsupportedConfiguration = false, hasReportLoadingError = false, customError = null, }) {
+    const getReportErrorComponent = () => {
+        if (hasReportLoadingError) {
+            return ReportBlank; // we do not render specific error for now, only red toast message
+        }
+        else if (isReportNotFound) {
+            return ReportNotFound;
+        }
+        else if (!isExecutable) {
+            return ReportBlank;
+        }
+        else if (unsupportedConfiguration) {
+            return ReportUnsupportedConfiguration;
+        }
+        else if (customError) {
+            return ReportCustomError;
+        }
+        else if (isMissingArea) {
+            return ReportMissingArea;
+        }
+        else if (isMissingLocation) {
+            return ReportMissingLocation;
+        }
+        else if (isMissingMetric && !isNoMetricSupported) {
+            return ReportMissingMetric;
+        }
+        else if (isMissingColumns) {
+            return ReportMissingColumns;
+        }
+        else if (hasNegativeValue) {
+            return ReportHasNegativeValues;
+        }
+        else if (isInvalidConfiguration || isBadRequest) {
+            return ReportInvalidConfiguration;
+        }
+        else if (isReportTooLargeToCompute) {
+            return ReportTooLargeToCompute;
+        }
+        else if (isReportTooLargeToDisplay) {
+            return ReportTooLargeToDisplay;
+        }
+        else if (isExecutionRunning || isComputingShortcut) {
+            return ReportComputing;
+        }
+        else if (isReportWithFiltersEmpty) {
+            return ReportEmpty;
+        }
+        else if (isReportWithoutFiltersEmpty) {
+            return WorkspaceEmpty;
+        }
+        else if (isReportProtected) {
+            return ReportExecuteProtected;
+        }
+        return null;
+    };
+    const ErrorComponent = getReportErrorComponent();
+    const className = classNames({
+        "invisible-report-visualization": ErrorComponent !== null,
+    });
+    return (_jsxs("div", { className: className, children: [ErrorComponent === ReportNotFound ? (_jsx(ReportNotFound, { missingItems: reportNotFoundMissingItems })) : ErrorComponent === null ? null : (_jsx(ErrorComponent, { isSmallScreen: isSmallScreen })), _jsx(ReportVisualization, { projectId: projectId, appSessionId: appSessionId, messages: messages }, appSessionId)] }));
+});
+export function Report({ isSmallScreen }) {
+    const reportProps = useSelector(reportSelector);
+    return _jsx(ReportBase, { ...reportProps, isSmallScreen: isSmallScreen });
+}

package/esm/components/ReportDescription.d.ts

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

package/esm/components/ReportDescription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReportDescription.d.ts","sourceRoot":"","sources":["../../src/components/ReportDescription.tsx"],"names":[],"mappings":"AA0BA,wBAAgB,iBAAiB,4CA0GhC"}

package/esm/components/ReportDescription.js

@@ -0,0 +1,64 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2022-2026 GoodData Corporation
+import { useCallback, useEffect, useState } from "react";
+import cx from "classnames";
+import { isEmpty } from "lodash-es";
+import { useIntl } from "react-intl";
+import { useDispatch, useSelector } from "react-redux";
+import { Bubble, RichText, RichTextWithTooltip } from "@gooddata/sdk-ui-kit";
+import { reportDescriptionChange } from "../actions/report_actions.js";
+import { reportDescriptionSelector } from "../selectors/report_description_selector.js";
+import { ReportDescriptionTrigger } from "./ReportDescriptionTrigger.js";
+const ALIGN_POINTS = [{ align: "bl tl" }];
+const ARROW_OFFSETS = { "bl tl": [0, 5] };
+const ARROW_STYLE = { display: "none" };
+const richTextTooltipAlignPoints = [
+    { align: "bc tc", offset: { x: 0, y: 5 } },
+    { align: "tc bc", offset: { x: 0, y: -5 } },
+];
+export function ReportDescription() {
+    const intl = useIntl();
+    const dispatch = useDispatch();
+    const { currentDescription, filters, separators } = useSelector(reportDescriptionSelector);
+    const currentDescriptionTrimmed = currentDescription.trim();
+    const [description, setDescription] = useState(currentDescriptionTrimmed);
+    const [preventClose, setPreventClose] = useState(false);
+    const [editMode, setEditMode] = useState(false);
+    const placeholder = intl.formatMessage({ id: "report.description.add" });
+    useEffect(() => {
+        setDescription(currentDescriptionTrimmed);
+    }, [currentDescriptionTrimmed]);
+    const handleSave = () => {
+        const trimmedDescription = description.trim();
+        setDescription(trimmedDescription);
+        setPreventClose(false);
+        setEditMode(false);
+        if (trimmedDescription !== currentDescriptionTrimmed) {
+            dispatch(reportDescriptionChange(trimmedDescription));
+        }
+    };
+    const handleBlur = () => {
+        setPreventClose(false);
+        setEditMode(false);
+    };
+    const handleClick = () => {
+        setPreventClose(true);
+        setEditMode(true);
+    };
+    const onRichTextChange = useCallback((value) => {
+        setDescription(value);
+    }, []);
+    const renderContent = () => {
+        const getClassNames = (ownClass) => {
+            return cx("adi-description-tooltip-base", "s-adi-description-tooltip-content", ownClass);
+        };
+        if (isEmpty(description) && !editMode) {
+            return (_jsx("div", { className: getClassNames("adi-description-tooltip-placeholder"), onClick: handleClick, children: intl.formatMessage({ id: "report.description.add" }) }));
+        }
+        if (editMode) {
+            return (_jsx("div", { className: "adi-description-tooltip-rich-text s-adi-description-tooltip-content", onBlur: handleBlur, children: _jsx(RichTextWithTooltip, { className: "adi-description-tooltip-rich-text-content", value: description, renderMode: editMode ? "edit" : "view", onChange: onRichTextChange, editRows: 20, tooltipAlignPoints: richTextTooltipAlignPoints, showTooltip: editMode, editPlaceholder: placeholder, emptyElement: _jsx(_Fragment, { children: placeholder }), referencesEnabled: true, filters: filters, separators: separators }) }));
+        }
+        return (_jsx("div", { className: getClassNames("adi-description-tooltip-text"), onClick: handleClick, children: _jsx(RichText, { referencesEnabled: true, className: "adi-description-tooltip-rich-text", value: description, renderMode: "view", filters: filters, separators: separators }) }));
+    };
+    return (_jsx("div", { className: "adi-description-tooltip-wrapper", children: _jsxs(ReportDescriptionTrigger, { isCloseBlocked: () => preventClose, onBubbleClose: handleSave, children: [_jsx("div", { className: "gd-icon-circle-question adi-description-tooltip-icon s-adi-description-tooltip-icon" }), _jsx(Bubble, { className: "bubble-light adi-description-tooltip-content", arrowStyle: ARROW_STYLE, arrowOffsets: ARROW_OFFSETS, alignPoints: ALIGN_POINTS, closeOnOutsideClick: true, children: renderContent() })] }) }));
+}