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

package/esm/components/report/ReportTooLargeToCompute/ReportTooLargeToCrosstabulate.js

@@ -0,0 +1,174 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2025-2026 GoodData Corporation
+import { useCallback, useState } from "react";
+import { FormattedMessage, defineMessage, useIntl } from "react-intl";
+import { useDispatch } from "react-redux";
+import { createSelector } from "reselect";
+import { Button } from "@gooddata/sdk-ui-kit";
+import { addMessage } from "../../../actions/messages_actions.js";
+import { COMPACT_FORMATTING_OPTIONS } from "../../../constants/formats.js";
+import { TABLE } from "../../../constants/visualization_types.js";
+import { canManageProject as canManageProjectSelector } from "../../../selectors/permissions_selector.js";
+import { getExecutionErrorResponseData } from "../../../selectors/report_selector.js";
+import { VisualizationPropertiesSelectors } from "../../../selectors/visualization_properties_selector.js";
+import { getVisualizationClassTypeFromState } from "../../../services/visualization_class_service.js";
+import { toggleFilterDropdown } from "../../../store/filter_bar/filter_bar_actions.js";
+import { useAppSelector } from "../../../store/hooks.js";
+import { ErrorRawDataArea } from "../ErrorRawDataArea.js";
+import { ReportMessage } from "../ReportMessage.js";
+import { TraceIdMessage } from "../TraceIdMessage.js";
+/**
+ * Bit flags for the individual limit breaks.
+ * This allows us to combine multiple limits and represent the combinations efficiently.
+ */
+const limitBreakTypeFlags = {
+    "xtab-rows": 1 << 2,
+    "xtab-columns": 1 << 1,
+    "xtab-cells": 1 << 0,
+};
+/**
+ * Bit flags for the individual limit breaks to use when we need to transpose the results.
+ * This allows us to combine multiple limits and represent the combinations efficiently.
+ */
+const transposedLimitBreakTypeFlags = {
+    // notice the rows and columns positions are flipped compared to the limitBreakTypeFlags
+    "xtab-rows": limitBreakTypeFlags["xtab-columns"],
+    "xtab-columns": limitBreakTypeFlags["xtab-rows"],
+    "xtab-cells": limitBreakTypeFlags["xtab-cells"],
+};
+/**
+ * Placeholder names used for the individual types of limits.
+ * These correspond to the placeholders used by the description messages as defined in the localization messages.
+ */
+const limitBreakTypeLocalizationValuesNames = {
+    "xtab-rows": ["rowLimit", "rowOverflow"],
+    "xtab-columns": ["columnLimit", "columnOverflow"],
+    "xtab-cells": ["cellLimit", "cellOverflow"],
+};
+/**
+ * Placeholder names used for the individual types of limits to use when we need to transpose the results.
+ * These correspond to the placeholders used by the description messages as defined in the localization messages.
+ */
+const transposedLimitBreakTypeLocalizationValuesNames = {
+    // notice the rows and columns values are flipped compared to the limitBreakTypeLocalizationValuesNames
+    "xtab-rows": limitBreakTypeLocalizationValuesNames["xtab-columns"],
+    "xtab-columns": limitBreakTypeLocalizationValuesNames["xtab-rows"],
+    "xtab-cells": limitBreakTypeLocalizationValuesNames["xtab-cells"],
+};
+/**
+ * Mapping of all the different combinations of limits broken to the correct header message id.
+ * The index corresponds to the bit mask of all the limits broken.
+ *
+ * @see limitBreakTypeFlags
+ */
+const limitBreakHeaderMessageIdMap = [
+    // default to the original non-specific message in case no limits are sent by the backend
+    defineMessage({ id: "dashboard.message.too_large_to_compute.header" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.cells_header" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.columns_header" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.columns_cells_header" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.rows_header" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.rows_cells_header" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.rows_columns_header" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.rows_columns_cells_header" }).id,
+];
+/**
+ * Mapping of all the different combinations of limits broken to the correct description message id.
+ * The index corresponds to the bit mask of all the limits broken.
+ *
+ * @see limitBreakTypeFlags
+ */
+const limitBreakDescriptionMessageIdMap = [
+    // default to the original non-specific message in case no limits are sent by the backend
+    defineMessage({ id: "dashboard.message.too_large_to_compute.description" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.cells_description" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.columns_description" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.columns_cells_description" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.rows_description" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.rows_cells_description" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.rows_columns_description" }).id,
+    defineMessage({ id: "dashboard.message.too_large_to_compute.rows_columns_cells_description" }).id,
+];
+/**
+ * Collects all the limit types that are broken as a bit mask.
+ *
+ * @param limitBreaks - the descriptions of the individual limits being broken
+ * @param shouldTranspose - if true, handle columns as rows and vice versa
+ */
+function getLimitBreakBitFlags(limitBreaks, shouldTranspose) {
+    const flagCollection = shouldTranspose ? transposedLimitBreakTypeFlags : limitBreakTypeFlags;
+    return limitBreaks.reduce((flags, limitBreak) => flags | flagCollection[limitBreak.limitType], 0);
+}
+/**
+ * Formats the number to a human-readable format like 123K and so on. Respects the locale.
+ */
+function formatNumber(n, intl) {
+    return intl.formatNumber(n, COMPACT_FORMATTING_OPTIONS);
+}
+/**
+ * Given an intl object and a list of limit breaks, returns an object with all the necessary placeholder values for
+ * a description message.
+ *
+ * @param intl - the object that can format numbers in a locale-aware manner
+ * @param limitBreaks - the descriptions of the individual limits being broken
+ * @param shouldTranspose - if true, handle columns as rows and vice versa
+ */
+function getLimitBreakDescriptionValues(intl, limitBreaks, shouldTranspose) {
+    const nameMapping = shouldTranspose
+        ? transposedLimitBreakTypeLocalizationValuesNames
+        : limitBreakTypeLocalizationValuesNames;
+    return limitBreaks.reduce((formattedValues, limitBreak) => {
+        const [limitName, overflowName] = nameMapping[limitBreak.limitType];
+        formattedValues[limitName] = formatNumber(limitBreak.limit, intl);
+        formattedValues[overflowName] = formatNumber(limitBreak.actualValue - limitBreak.limit, intl);
+        return formattedValues;
+    }, {});
+}
+/**
+ * Returns true if the visualization has the non-default measure placement.
+ * This means that we need to flip all the column and row related messages.
+ */
+const isTransposedSelector = createSelector(VisualizationPropertiesSelectors.getExtendedReferencePointPropertiesControls, (controls) => controls?.["measureGroupDimension"] === "rows");
+/**
+ * Displays the information about how exactly the report violated (potentially multiple) crosstabulation size limits.
+ *
+ * The logic is a bit involved because the three different limit types can happen at the same time in any combination,
+ * and the UX differs based on that:
+ * - some situations can be handled by transposition, some cannot (and the transposition is not always available)
+ * - some can be solved by filters, some cannot
+ */
+export function ReportTooLargeToCrosstabulate({ limitBreaks }) {
+    const intl = useIntl();
+    const dispatch = useDispatch();
+    const errorResponseData = useAppSelector(getExecutionErrorResponseData);
+    const canManageProject = useAppSelector(canManageProjectSelector);
+    const currentVisualizationType = useAppSelector(getVisualizationClassTypeFromState);
+    const isTransposed = useAppSelector(isTransposedSelector);
+    const onToggleFilterDropdown = useCallback(() => {
+        dispatch(toggleFilterDropdown());
+    }, [dispatch]);
+    const showToastMessage = useCallback((payload) => {
+        dispatch(addMessage(payload));
+    }, [dispatch]);
+    const [shouldShowErrorRawData, setShowErrorRawData] = useState(false);
+    const showErrorRawDataArea = useCallback(() => setShowErrorRawData(true), [setShowErrorRawData]);
+    const flags = getLimitBreakBitFlags(limitBreaks, isTransposed);
+    // the transposition only makes sense if we are in the table visualization
+    // and the only limit broken is the smaller dimension, otherwise, transposition would not help.
+    // same goes for cell limit: transposition will not make the cell count go down
+    const onlySmallerDimensionBroken = isTransposed
+        ? flags == limitBreakTypeFlags["xtab-rows"]
+        : flags == limitBreakTypeFlags["xtab-columns"];
+    const canTranspose = currentVisualizationType == TABLE && onlySmallerDimensionBroken;
+    return (_jsxs(ReportMessage, { headerMessageId: limitBreakHeaderMessageIdMap[flags], className: "s-error-too-large s-report-message-type-too_large_to_compute", children: [_jsx(FormattedMessage, { id: limitBreakDescriptionMessageIdMap[flags], values: {
+                    br: _jsx("br", {}),
+                    a2: (chunk) => (_jsx(Button, { value: chunk, className: "gd-button-link adi-canvas-link", onClick: onToggleFilterDropdown, tagName: "a" })),
+                    ...getLimitBreakDescriptionValues(intl, limitBreaks, isTransposed),
+                } }), _jsx("br", {}), _jsx(FormattedMessage, { id: canTranspose
+                    ? defineMessage({
+                        id: "dashboard.message.too_large_to_compute.transpose_call_to_action",
+                    }).id
+                    : defineMessage({
+                        id: "dashboard.message.too_large_to_compute.filter_call_to_action",
+                    }).id }), canManageProject && !shouldShowErrorRawData ? (_jsxs(_Fragment, { children: [_jsx("br", {}), _jsx(Button, { value: intl.formatMessage(defineMessage({ id: "dashboard.message.too_large_to_compute.see_raw_error" })), className: "gd-button-link adi-canvas-link s-error-raw-data-link", onClick: showErrorRawDataArea, tagName: "a" })] })) : null, shouldShowErrorRawData ? _jsx(ErrorRawDataArea, { errorRawData: errorResponseData?.rawData }) : null, errorResponseData?.traceId ? (_jsx(TraceIdMessage, { traceId: errorResponseData.traceId, canManageProject: canManageProject, showToastMessage: showToastMessage })) : null] }));
+}

package/esm/components/report/ReportTooLargeToCompute/types.d.ts

@@ -0,0 +1,21 @@
+import { type IDataTooLargeResponseBodyLimitBreak } from "@gooddata/sdk-backend-spi";
+declare const crosstabulationLimitTypes: readonly ["xtab-rows", "xtab-columns", "xtab-cells"];
+/**
+ * All the limit types related to the crosstabulation operation.
+ */
+export type CrosstabulationLimitType = (typeof crosstabulationLimitTypes)[number];
+/**
+ * Type guard narrowing the general LimitBreaks to only those related to crosstabulation.
+ */
+export declare function isOnlyCrosstabulationLimitBreaks(items: IDataTooLargeResponseBodyLimitBreak[]): items is IDataTooLargeResponseBodyLimitBreak<CrosstabulationLimitType>[];
+declare const calculationLimitTypes: readonly ["sql-cumulative-table-bytes"];
+/**
+ * All the limit types related to the SQL calculation.
+ */
+export type CalculationLimitType = (typeof calculationLimitTypes)[number];
+/**
+ * Type guard narrowing the general LimitBreaks to only those related to SQL calculation.
+ */
+export declare function isOnlyCalculationLimitBreaks(items: IDataTooLargeResponseBodyLimitBreak[]): items is IDataTooLargeResponseBodyLimitBreak<CalculationLimitType>[];
+export {};
+//# sourceMappingURL=types.d.ts.map

package/esm/components/report/ReportTooLargeToCompute/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/components/report/ReportTooLargeToCompute/types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,mCAAmC,EAAE,MAAM,2BAA2B,CAAC;AAQrF,QAAA,MAAM,yBAAyB,YAAI,WAAW,EAAE,cAAc,EAAE,YAAY,CAAU,CAAC;AAKvF;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC;AAElF;;GAEG;AACH,wBAAgB,gCAAgC,CAC5C,KAAK,EAAE,mCAAmC,EAAE,GAC7C,KAAK,IAAI,mCAAmC,CAAC,wBAAwB,CAAC,EAAE,CAE1E;AAQD,QAAA,MAAM,qBAAqB,YAAI,4BAA4B,CAAU,CAAC;AAKtE;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1E;;GAEG;AACH,wBAAgB,4BAA4B,CACxC,KAAK,EAAE,mCAAmC,EAAE,GAC7C,KAAK,IAAI,mCAAmC,CAAC,oBAAoB,CAAC,EAAE,CAEtE"}

package/esm/components/report/ReportTooLargeToCompute/types.js

@@ -0,0 +1,29 @@
+// (C) 2025-2026 GoodData Corporation
+/////
+// Crosstabulation limit types
+/////
+// source of truth for all the possible crosstabulation limit types.
+// done like this so that all the derived types are automatically updated whenever this changes.
+const crosstabulationLimitTypes = ["xtab-rows", "xtab-columns", "xtab-cells"];
+// auxiliary set used mainly in type guards. typed as Set<string> to make using them in type guards easier
+const crosstabulationLimitTypesSet = new Set(crosstabulationLimitTypes);
+/**
+ * Type guard narrowing the general LimitBreaks to only those related to crosstabulation.
+ */
+export function isOnlyCrosstabulationLimitBreaks(items) {
+    return items.every((i) => crosstabulationLimitTypesSet.has(i.limitType));
+}
+/////
+// Calculation limit types
+/////
+// source of truth for all the possible SQL calculation limit types.
+// done like this so that all the derived types are automatically updated whenever this changes.
+const calculationLimitTypes = ["sql-cumulative-table-bytes"];
+// auxiliary set used mainly in type guards. typed as Set<string> to make using them in type guards easier
+const calculationLimitTypesSet = new Set(calculationLimitTypes);
+/**
+ * Type guard narrowing the general LimitBreaks to only those related to SQL calculation.
+ */
+export function isOnlyCalculationLimitBreaks(items) {
+    return items.every((i) => calculationLimitTypesSet.has(i.limitType));
+}

package/esm/components/report/ReportTooLargeToDisplay.d.ts

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

package/esm/components/report/ReportTooLargeToDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReportTooLargeToDisplay.d.ts","sourceRoot":"","sources":["../../../src/components/report/ReportTooLargeToDisplay.tsx"],"names":[],"mappings":"AAyBA,wBAAgB,uBAAuB,4CA2CtC"}

package/esm/components/report/ReportTooLargeToDisplay.js

@@ -0,0 +1,35 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useCallback } from "react";
+import cx from "classnames";
+import { FormattedMessage, defineMessage } from "react-intl";
+import { useDispatch, useSelector } from "react-redux";
+import { Button } from "@gooddata/sdk-ui-kit";
+import { selectVisualizationType } from "../../actions/buckets_actions.js";
+import { TABLE } from "../../constants/visualization_types.js";
+import { currentVisualizationTypeSelector, visualizationClassesSelector, } from "../../selectors/report_too_large_to_display_selector.js";
+import { getTableVisualizationClass } from "../../services/visualization_class_service.js";
+import { toggleFilterDropdown } from "../../store/filter_bar/filter_bar_actions.js";
+import { findVisualizationClass, isVisualizationClassDeprecated } from "../../utils/visualization_class.js";
+import { ReportMessage } from "./ReportMessage.js";
+const linkClass = "gd-button-link adi-canvas-link";
+export function ReportTooLargeToDisplay() {
+    const dispatch = useDispatch();
+    const visualizationClasses = useSelector(visualizationClassesSelector);
+    const currentVisualizationType = useSelector(currentVisualizationTypeSelector);
+    const className = "adi-canvas-message-too-many-data-points s-error-too-many-data-points";
+    const visualizationClassTable = findVisualizationClass(visualizationClasses, TABLE);
+    const isTableDeprecated = isVisualizationClassDeprecated(visualizationClassTable);
+    const isTableEnabled = visualizationClassTable !== null;
+    const onSwitchToTableClick = useCallback(() => dispatch(selectVisualizationType(getTableVisualizationClass(visualizationClasses))), [dispatch, visualizationClasses]);
+    const onToggleFilterDropdownClick = useCallback(() => dispatch(toggleFilterDropdown()), [dispatch]);
+    const chunks = {
+        br: _jsx("br", {}),
+        a1: (chunk) => (_jsx(Button, { value: chunk, className: cx(linkClass, "s-canvas-link-switch"), onClick: onSwitchToTableClick, tagName: "a" })),
+        a2: (chunk) => (_jsx(Button, { value: chunk, className: linkClass, onClick: onToggleFilterDropdownClick, tagName: "a" })),
+        switch: (chunk) => 
+        // if the rest should not be rendered, render an empty fragment, otherwise just render children
+        currentVisualizationType === TABLE || !isTableEnabled ? _jsx(_Fragment, {}) : _jsx(_Fragment, { children: chunk }),
+    };
+    return (_jsx(ReportMessage, { headerMessageId: defineMessage({ id: "dashboard.message.too_large_to_display.header" }).id, className: cx(className, "s-report-message-type-too_large_to_display"), children: isTableDeprecated ? null : (_jsx(FormattedMessage, { id: "dashboard.message.too_large_to_display.description", values: chunks })) }));
+}

package/esm/components/report/ReportUnsupportedConfiguration.d.ts

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

package/esm/components/report/ReportUnsupportedConfiguration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReportUnsupportedConfiguration.d.ts","sourceRoot":"","sources":["../../../src/components/report/ReportUnsupportedConfiguration.tsx"],"names":[],"mappings":"AAMA,wBAAgB,8BAA8B,4CAS7C"}

package/esm/components/report/ReportUnsupportedConfiguration.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { FormattedMessage, defineMessage } from "react-intl";
+import { ReportMessage } from "./ReportMessage.js";
+export function ReportUnsupportedConfiguration() {
+    return (_jsx(ReportMessage, { headerMessageId: defineMessage({ id: "dashboard.message.unsupported_config.header" }).id, className: "s-error-unsupported-configuration s-report-message-type-unsupported_config", children: _jsx(FormattedMessage, { id: "dashboard.message.unsupported_config.description" }) }));
+}

package/esm/components/report/ReportVisualization.d.ts

@@ -0,0 +1,9 @@
+import { PluggableVisualization } from "./PluggableVisualization.js";
+export interface IReportVisualizationProps {
+    projectId: string;
+    appSessionId: string;
+    messages?: Record<string, string>;
+    visualizationGenericComponent?: typeof PluggableVisualization;
+}
+export declare function ReportVisualization({ projectId, appSessionId, messages, visualizationGenericComponent, }: IReportVisualizationProps): false | import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=ReportVisualization.d.ts.map

package/esm/components/report/ReportVisualization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReportVisualization.d.ts","sourceRoot":"","sources":["../../../src/components/report/ReportVisualization.tsx"],"names":[],"mappings":"AAoEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAiBrE,MAAM,WAAW,yBAAyB;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,6BAA6B,CAAC,EAAE,OAAO,sBAAsB,CAAC;CACjE;AAID,wBAAgB,mBAAmB,CAAC,EAChC,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,6BAAsD,GACzD,EAAE,yBAAyB,0DA0T3B"}

package/esm/components/report/ReportVisualization.js

@@ -0,0 +1,216 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useCallback, useRef, useState, } from "react";
+import classNames from "classnames";
+import { isEmpty } from "lodash-es";
+import { defineMessage } from "react-intl";
+// NodeNext types react-measure's default as the module namespace; cast restores the component type.
+import MeasureRaw from "react-measure";
+import { useDispatch } from "react-redux";
+const Measure = MeasureRaw;
+import { v4 as uuid } from "uuid";
+import { visClassUrl } from "@gooddata/sdk-model";
+import { ErrorCodes, isClusteringNotReceived, isForecastNotReceived, isGoodDataSdkError, useAutoupdateRef, } from "@gooddata/sdk-ui";
+import { PluggableVisualizationErrorCodes, } from "@gooddata/sdk-ui-ext/internal";
+import { createDrillPerformedAction } from "../../actions/drill_actions.js";
+import { exportResultReady } from "../../actions/export_report_actions.js";
+import { showErrorMessage } from "../../actions/messages_actions.js";
+import { openAsReportToggled, visualizationPropertiesChanged, visualizationPropertiesInitialized, visualizationPropertiesMetaChanged, } from "../../actions/properties_actions.js";
+import { newDerivedBucketItemsPlaced, reportExecutionFailed, reportExecutionFinished, reportExecutionStarted, reportExecutionWarning, uiExtendedReferencePointChanged, } from "../../actions/report_actions.js";
+import { updateChartSortConfig } from "../../sagas/chart_sort/chart_sort_ui_actions.js";
+import { reportVisualizationSelector } from "../../selectors/report_visualization_selector.js";
+import { useAppSelector } from "../../store/hooks.js";
+import { getCssClass } from "../../utils/css_class.js";
+import { getTime } from "../../utils/timers.js";
+import { areSameVisualizationProperties } from "../../utils/visualization_properties.js";
+import { DrillDownList } from "./drillDown/DrillDownList.js";
+import { PluggableVisualization } from "./PluggableVisualization.js";
+import { extractErrorResponseData } from "./reportUtils.js";
+const knownErrorCodes = [
+    ErrorCodes.DATA_TOO_LARGE_TO_DISPLAY,
+    ErrorCodes.DATA_TOO_LARGE_TO_COMPUTE,
+    ErrorCodes.NO_DATA,
+    ErrorCodes.NEGATIVE_VALUES,
+    ErrorCodes.BAD_REQUEST,
+    ErrorCodes.PROTECTED_REPORT,
+    ErrorCodes.GEO_LOCATION_MISSING,
+    ErrorCodes.GEO_AREA_MISSING,
+    PluggableVisualizationErrorCodes.INVALID_BUCKETS,
+    PluggableVisualizationErrorCodes.INVALID_COLUMNS,
+    PluggableVisualizationErrorCodes.EMPTY_AFM,
+];
+export function ReportVisualization({ projectId, appSessionId, messages, visualizationGenericComponent = PluggableVisualization, }) {
+    const dispatch = useDispatch();
+    const { isNarrow, featureFlags, permissions, isMdObjectValid, drillableItems, visualizationProperties, visualizationPropertiesMeta, referencePoint, newDerivedBucketItems, locale, dateFormat, config, executionConfig, insight, visualizationClass, lastSavedVisClassUrl, sourceInsightId, supportsChartFill, } = useAppSelector(reportVisualizationSelector);
+    const [containerHeight, setContainerHeight] = useState(null);
+    const [containerWidth, setContainerWidth] = useState(null);
+    // not on state to keep it synchronous between callbacks from pl. vis
+    const executionIdRef = useRef(null);
+    const startTimeRef = useRef(null);
+    const endTimeRef = useRef(null);
+    const visualizationPropertiesRef = useAutoupdateRef(visualizationProperties);
+    const parseErrorReason = (reason) => {
+        return reason
+            .split(/\n/)
+            .map((str) => {
+            const index = str.indexOf("Limit:");
+            if (index === -1) {
+                return "";
+            }
+            const cutStr = str.substring(index).replace(/_/g, "").replace(/\./g, "").toLowerCase();
+            if (str.indexOf("dimension with metrics") !== -1) {
+                return `DimensionWithMetrics ${cutStr}.`;
+            }
+            if (str.indexOf("dimension without metrics") !== -1) {
+                return `DimensionWithoutMetrics ${cutStr}.`;
+            }
+            if (str.indexOf("cells") !== -1) {
+                return `Cells ${cutStr}.`;
+            }
+            return "";
+        })
+            .filter((str) => str !== "")
+            .join(" ")
+            .trim();
+    };
+    const extractSupportedErrorCode = (error) => {
+        let errorCode;
+        if (isGoodDataSdkError(error)) {
+            return error.getErrorCode();
+        }
+        else {
+            errorCode = ErrorCodes.UNKNOWN_ERROR;
+        }
+        return knownErrorCodes.includes(errorCode) ? errorCode : ErrorCodes.UNKNOWN_ERROR;
+    };
+    const onError = (error) => {
+        const executionId = executionIdRef.current;
+        const startTime = startTimeRef.current;
+        const endTime = endTimeRef.current;
+        const errorCode = extractSupportedErrorCode(error);
+        const errorResponseData = extractErrorResponseData(error);
+        let message = "";
+        // the caught error is probed for the response reason the toast shows
+        const reason = error?.cause
+            ?.responseBody?.reason;
+        if (typeof reason === "string") {
+            message = parseErrorReason(reason);
+        }
+        if (errorCode === ErrorCodes.DATA_TOO_LARGE_TO_DISPLAY) {
+            message = error.message;
+        }
+        if (isForecastNotReceived(error)) {
+            dispatch(showErrorMessage(defineMessage({ id: "messages.visualizations.forecast.error" }).id, error.message));
+        }
+        if (isClusteringNotReceived(error)) {
+            dispatch(showErrorMessage(defineMessage({ id: "messages.visualizations.clustering.error" }).id, error.message));
+        }
+        dispatch(reportExecutionFailed({
+            status: errorCode,
+            responseData: errorResponseData,
+            message: message === "" ? undefined : message.replace(/\s/g, "_"),
+        }, executionId, startTime, endTime));
+    };
+    const onLoadingChanged = ({ isLoading }) => {
+        if (isLoading) {
+            executionIdRef.current = uuid();
+            startTimeRef.current = getTime();
+            dispatch(reportExecutionStarted(executionIdRef.current, startTimeRef.current));
+        }
+    };
+    const onExtendedReferencePointChanged = (referencePoint, sortConfig) => {
+        const { properties } = referencePoint;
+        handlePropertiesChange(properties, true);
+        dispatch(uiExtendedReferencePointChanged(referencePoint, sortConfig));
+    };
+    const pushData = (data) => {
+        const { properties, propertiesMeta, initialProperties, openAsReport, ignoreUndoRedo = false, dataView, } = data;
+        if (initialProperties) {
+            dispatch(visualizationPropertiesInitialized(initialProperties));
+        }
+        if (propertiesMeta) {
+            dispatch(visualizationPropertiesMetaChanged(propertiesMeta));
+        }
+        handlePropertiesChange(properties, ignoreUndoRedo);
+        if (openAsReport !== undefined) {
+            dispatch(openAsReportToggled(openAsReport));
+        }
+        if (dataView) {
+            const typedDataView = dataView;
+            endTimeRef.current = getTime();
+            const executionId = executionIdRef.current;
+            const startTime = startTimeRef.current;
+            // TODO we don't want to save the execution result anymore
+            dispatch(reportExecutionFinished(typedDataView.result, executionId, startTime, endTimeRef.current));
+            const limitBreaks = typedDataView.metadata?.limitBreaks ?? [];
+            if (limitBreaks.length > 0) {
+                dispatch(reportExecutionWarning({
+                    limitBreaks,
+                }, executionId, startTime, endTimeRef.current));
+            }
+        }
+    };
+    const onExportReady = (exportResultFunction) => {
+        dispatch(exportResultReady(exportResultFunction));
+    };
+    const handlePropertiesChange = (properties, ignoreUndoRedo) => {
+        if (properties) {
+            const currentProperties = visualizationPropertiesRef.current;
+            if (!areSameVisualizationProperties(currentProperties, properties)) {
+                dispatch(visualizationPropertiesChanged(properties, ignoreUndoRedo));
+            }
+        }
+    };
+    const onSortingChanged = (sortConfig) => {
+        dispatch(updateChartSortConfig(sortConfig));
+    };
+    const onResize = (contentRect) => {
+        setContainerHeight(contentRect.bounds.height);
+        setContainerWidth(contentRect.bounds.width);
+    };
+    const onDrill = (drillEvent) => {
+        dispatch(createDrillPerformedAction(drillEvent));
+    };
+    // the one visualization prop that needs a stable identity across renders
+    const onNewDerivedBucketItemsPlaced = useCallback((referencePoint) => {
+        dispatch(newDerivedBucketItemsPlaced(referencePoint));
+    }, [dispatch]);
+    if (!visualizationClass) {
+        return false;
+    }
+    const type = visClassUrl(visualizationClass).split(":")[1];
+    const className = classNames([
+        "adi-report-visualization",
+        getCssClass(type, "s-visualization-"),
+        getCssClass(type, "gd-visualization-"),
+    ]);
+    const containerClassNames = classNames("adi-chart-container", {
+        "adi-chart-container-narrow": isNarrow,
+    });
+    const VisualizationGeneric = visualizationGenericComponent;
+    const extendedConfig = {
+        ...config,
+        maxHeight: containerHeight,
+        maxWidth: containerWidth,
+    };
+    const configurationPanelRenderers = {
+        InteractionsDetailRenderer: () => _jsx(DrillDownList, {}),
+    };
+    // Localization bundles are loaded asynchronously; only en-US is seeded synchronously.
+    // The pluggable visualization bakes the messages it is constructed with into the extended
+    // reference point (bucket titles, subtitles, ...) and never picks up later message updates.
+    // Mounting it before the active locale's messages arrive would therefore freeze raw i18n
+    // keys (e.g. "dashboard.bucket.measures_title.column") into the bucket panel. Wait for the
+    // messages to be available so the very first reference point is computed with real strings.
+    if (isEmpty(messages)) {
+        return null;
+    }
+    return (_jsx("div", { className: className, children: _jsx(Measure, { onResize: onResize, bounds: true, children: ({ measureRef }) => (_jsx("div", { className: containerClassNames, ref: measureRef, children: _jsx(VisualizationGeneric, { appSessionId: appSessionId, 
+                    // the state currencies ARE what the plug viz consumes at runtime; the
+                    // SDK prop types describe the same shapes from its side of the boundary
+                    newDerivedBucketItems: newDerivedBucketItems, referencePoint: referencePoint, onExtendedReferencePointChanged: onExtendedReferencePointChanged, onNewDerivedBucketItemsPlaced: onNewDerivedBucketItemsPlaced, projectId: projectId, visualizationClass: visualizationClass, isMdObjectValid: isMdObjectValid, onError: onError, onExportReady: onExportReady, onLoadingChanged: onLoadingChanged, pushData: pushData, drillableItems: drillableItems, locale: locale, messages: messages, dateFormat: dateFormat, featureFlags: featureFlags, permissions: permissions, config: extendedConfig, onDrill: onDrill, insight: insight, 
+                    // A COPY, not the stored object: sdk-ui-ext's controlsHelper mutates
+                    // the meta it receives (`set(propertiesMeta, "undoApplied", false)`)
+                    // before pushing it back, and the slice state is frozen by immer.
+                    visualizationPropertiesMeta: visualizationPropertiesMeta ? { ...visualizationPropertiesMeta } : null, executionConfig: executionConfig, onSortingChanged: onSortingChanged, lastSavedVisClassUrl: lastSavedVisClassUrl, sourceInsightId: sourceInsightId, configurationPanelRenderers: configurationPanelRenderers, supportsChartFill: supportsChartFill }) })) }) }));
+}

package/esm/components/report/TraceIdMessage.d.ts

@@ -0,0 +1,9 @@
+import { type IShowAddMessagePayload } from "../../actions/messages_actions.js";
+interface ITraceIdMessageProps {
+    traceId: string;
+    canManageProject: boolean;
+    showToastMessage: (payload: IShowAddMessagePayload) => void;
+}
+export declare function TraceIdMessage({ traceId, canManageProject, showToastMessage }: ITraceIdMessageProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=TraceIdMessage.d.ts.map

package/esm/components/report/TraceIdMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TraceIdMessage.d.ts","sourceRoot":"","sources":["../../../src/components/report/TraceIdMessage.tsx"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAEhF,UAAU,oBAAoB;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,gBAAgB,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,IAAI,CAAC;CAC/D;AAKD,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,EAAE,oBAAoB,2CA0DnG"}

package/esm/components/report/TraceIdMessage.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2023-2026 GoodData Corporation
+import { useCallback, useMemo } from "react";
+import { FormattedMessage, defineMessage } from "react-intl";
+import { Bubble, BubbleHoverTrigger, IconCopy } from "@gooddata/sdk-ui-kit";
+const ERROR_MESSAGE_TOOLTIP_ALIGN_POINTS = [{ align: "tc bc" }];
+const COPY_ICON_TOOLTIP_ALIGN_POINTS = [{ align: "cr cl", offset: { x: 5, y: 0 } }];
+export function TraceIdMessage({ traceId, canManageProject, showToastMessage }) {
+    const copyTraceId = useCallback(() => navigator.clipboard.writeText(traceId).then(() => showToastMessage({
+        translationKey: defineMessage({
+            id: "dashboard.message.invalid_configuration.trace_id_message.copy_to_clipboard.success",
+        }).id,
+        type: "success",
+        durationInMs: 3000,
+    })), [traceId, showToastMessage]);
+    const traceIdTooltipKey = useMemo(() => {
+        return canManageProject
+            ? defineMessage({ id: "dashboard.message.invalid_configuration.trace_id_message.tooltip.manage" })
+                .id
+            : defineMessage({
+                id: "dashboard.message.invalid_configuration.trace_id_message.tooltip.analyze",
+            }).id;
+    }, [canManageProject]);
+    return (_jsx("div", { className: "report-error-trace-id s-report-error-trace-id", children: _jsx(FormattedMessage, { id: "dashboard.message.invalid_configuration.trace_id_message", values: {
+                span: (chunk) => (_jsxs(BubbleHoverTrigger, { hideDelay: 0, showDelay: 0, children: [_jsx("span", { className: "report-error-trace-id-title", children: chunk }), _jsx(Bubble, { className: "bubble-primary trace-id-title-bubble", alignPoints: ERROR_MESSAGE_TOOLTIP_ALIGN_POINTS, children: _jsx(FormattedMessage, { id: traceIdTooltipKey }) })] })),
+                traceId: (_jsxs(BubbleHoverTrigger, { hideDelay: 0, showDelay: 0, children: [_jsxs("span", { className: "report-error-trace-id-data s-report-error-trace-id-data", onClick: copyTraceId, children: [traceId, _jsx(IconCopy, { className: "adi-catalog-identifier-icon", width: 14, height: 14 })] }), _jsx(Bubble, { className: "bubble-primary", alignPoints: COPY_ICON_TOOLTIP_ALIGN_POINTS, children: _jsx(FormattedMessage, { id: "dashboard.message.invalid_configuration.trace_id_message.copy_icon.tooltip" }) })] })),
+            } }) }));
+}

package/esm/components/report/WorkspaceEmpty.d.ts

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

package/esm/components/report/WorkspaceEmpty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkspaceEmpty.d.ts","sourceRoot":"","sources":["../../../src/components/report/WorkspaceEmpty.tsx"],"names":[],"mappings":"AAsCA,wBAAgB,cAAc,4CAmB7B"}

package/esm/components/report/WorkspaceEmpty.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { FormattedMessage, defineMessage } from "react-intl";
+import { useSelector } from "react-redux";
+import { getLinkToLoadDataPage } from "../../selectors/data_page_selector.js";
+import { isFreemiumEdition } from "../../selectors/feature_flag_selector.js";
+import { canManageProject } from "../../selectors/permissions_selector.js";
+import { ReportMessage } from "./ReportMessage.js";
+function FreemiumMessage({ linkToLoadDataPage, isFreemiumEdition }) {
+    return isFreemiumEdition ? (_jsx("span", { className: "s-workspace-empty-data-load-link", children: _jsx(FormattedMessage, { id: "dashboard.message.workspace_empty.description_link", values: {
+                dataLoadLink: (chunks) => (_jsx("a", { href: linkToLoadDataPage, rel: "noopener noreferrer", target: "_blank", children: chunks })),
+            } }) })) : (_jsx("span", { className: "s-workspace-empty-data-load", children: _jsx(FormattedMessage, { id: "dashboard.message.workspace_empty.description_question" }) }));
+}
+export function WorkspaceEmpty() {
+    const linkToLoadDataPage = useSelector((state) => getLinkToLoadDataPage(state));
+    const isFreemium = useSelector((state) => isFreemiumEdition(state));
+    const canManage = useSelector((state) => canManageProject(state));
+    return (_jsx(ReportMessage, { headerMessageId: defineMessage({ id: "dashboard.message.workspace_empty.header" }).id, className: "adi-canvas-message-workspace-empty-result s-error-workspace-empty-result s-report-message-type-workspace_empty", children: canManage ? (_jsx(FreemiumMessage, { isFreemiumEdition: isFreemium, linkToLoadDataPage: linkToLoadDataPage })) : (_jsx("span", { className: "s-workspace-empty", children: _jsx(FormattedMessage, { id: "dashboard.message.workspace_empty.description" }) })) }));
+}

package/esm/components/report/drillDown/AttributeHierarchyItem.d.ts

@@ -0,0 +1,6 @@
+import { type ICatalogAttributeHierarchy, type ICatalogDateAttributeHierarchy } from "@gooddata/sdk-model";
+export interface IAttributeHierarchyItemProps {
+    item: ICatalogAttributeHierarchy | ICatalogDateAttributeHierarchy;
+}
+export declare function AttributeHierarchyItem({ item }: IAttributeHierarchyItemProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AttributeHierarchyItem.d.ts.map

package/esm/components/report/drillDown/AttributeHierarchyItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeHierarchyItem.d.ts","sourceRoot":"","sources":["../../../../src/components/report/drillDown/AttributeHierarchyItem.tsx"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,0BAA0B,EAC/B,KAAK,8BAA8B,EAEtC,MAAM,qBAAqB,CAAC;AAwB7B,MAAM,WAAW,4BAA4B;IACzC,IAAI,EAAE,0BAA0B,GAAG,8BAA8B,CAAC;CACrE;AAED,wBAAgB,sBAAsB,CAAC,EAAE,IAAI,EAAE,EAAE,4BAA4B,2CAU5E"}

package/esm/components/report/drillDown/AttributeHierarchyItem.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2023-2026 GoodData Corporation
+import { FormattedMessage } from "react-intl";
+import { isCatalogAttributeHierarchy, } from "@gooddata/sdk-model";
+import { AttributeHierarchyIconWithTooltip } from "../../catalog/item/AttributeHierarchyIconWithTooltip.js";
+function AttributeHierarchyIcon() {
+    return (_jsxs("svg", { width: "13", height: "14", viewBox: "0 0 13 14", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [_jsx("path", { d: "M0.5 1C0.223858 1 0 1.22386 0 1.5V2.5C0 2.77614 0.223858 3 0.5 3H7.5C7.77614 3 8 2.77614 8 2.5V1.5C8 1.22386 7.77614 1 7.5 1H0.5Z", fill: "#94A1AD" }), _jsx("path", { d: "M6.5 6C6.22386 6 6 6.22386 6 6.5V7.5C6 7.77614 6.22386 8 6.5 8H12.5C12.7761 8 13 7.77614 13 7.5V6.5C13 6.22386 12.7761 6 12.5 6H6.5Z", fill: "#94A1AD" }), _jsx("path", { d: "M6 10.5C6 10.2239 6.22386 10 6.5 10H12.5C12.7761 10 13 10.2239 13 10.5V11.5C13 11.7761 12.7761 12 12.5 12H6.5C6.22386 12 6 11.7761 6 11.5V10.5Z", fill: "#94A1AD" }), _jsx("path", { d: "M2 4H1V10C1 10.5523 1.44772 11 2 11H5V10H2V7H5V6H2V4Z", fill: "#94A1AD" })] }));
+}
+export function AttributeHierarchyItem({ item }) {
+    const title = isCatalogAttributeHierarchy(item) ? item.attributeHierarchy.title : item.title;
+    return (_jsxs("div", { className: "gd-drill-down-item-hierarchy-item", children: [_jsx(FormattedMessage, { id: "drillDown.item.in" }), _jsx(AttributeHierarchyIcon, {}), _jsx("div", { className: "gd-drill-down-hierarchy-name", children: title }), _jsx(AttributeHierarchyIconWithTooltip, { attributeHierarchy: item })] }));
+}

package/esm/components/report/drillDown/DrillDownItem.d.ts

@@ -0,0 +1,6 @@
+import { type IDrillDown } from "../../../selectors/drill_down_selectors.js";
+export interface IDrillDownItemProps {
+    item: IDrillDown;
+}
+export declare function DrillDownItem({ item }: IDrillDownItemProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DrillDownItem.d.ts.map