@gooddata/sdk-ui-dashboard 11.65.0-alpha.9 → 11.66.0-alpha.0

package/esm/presentation/insightEditor/useExploreFilterTransfer.js

@@ -0,0 +1,194 @@
+// (C) 2020-2026 GoodData Corporation
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { defineMessages } from "react-intl";
+import { GdcAdCommandType, GdcErrorType, GdcProductName, } from "@gooddata/sdk-embedding";
+import { isInsightWidget } from "@gooddata/sdk-model";
+import { useBackendStrict, useWorkspaceStrict } from "@gooddata/sdk-ui";
+import { useToastMessage } from "@gooddata/sdk-ui-kit";
+import { queryWidgetFilters } from "../../model/queries/widgets.js";
+import { useDashboardDispatch, useDashboardSelector } from "../../model/react/DashboardStoreProvider.js";
+import { queryAndWaitFor } from "../../model/store/_infra/queryAndWaitFor.js";
+import { selectBackendCapabilities } from "../../model/store/backendCapabilities/backendCapabilitiesSelectors.js";
+import { selectEnableComputedAttributes, selectEnableMeasureValueFilterKD, selectEnableTimezoneChange, } from "../../model/store/config/configSelectors.js";
+import { selectInsightByWidgetRef } from "../../model/store/insights/insightsSelectors.js";
+import { selectEffectiveDashboardTimezone } from "../../model/store/meta/metaSelectors.js";
+import { selectAttributeFilterConfigsDisplayAsLabelMap } from "../../model/store/tabs/attributeFilterConfigs/attributeFilterConfigsSelectors.js";
+import { selectFilterContextDateFilter, selectFilterContextMeasureValueFilters, } from "../../model/store/tabs/filterContext/filterContextSelectors.js";
+import { selectAnalyticalWidgetByRef } from "../../model/store/tabs/layout/layoutSelectors.js";
+import { buildInsightEditorFilterContext, loadInsightAvailableAttributes, } from "./filterContext/insightFilterContext.js";
+const KEEP_FILTER_CONTEXT_ID = "keepFilterContext";
+const RETRY_DELAY_MS = 300;
+const MAX_KEEPING_DURATION_MS = 5000;
+const TOAST_DURATION_MS = 5000;
+const messages = defineMessages({
+    dateFilterInapplicable: { id: "insightEditor.filterContext.dateFilterInapplicable" },
+    invalidFilterItemsCount: { id: "insightEditor.filterContext.invalidFilterItemsCount" },
+    tookTooLong: { id: "insightEditor.filterContext.tookTooLong" },
+    failed: { id: "insightEditor.filterContext.failed" },
+});
+/**
+ * Passes the dashboard filters and timezone of the explored widget to Analytical Designer, so the
+ * explored insight shows the same data as the widget.
+ *
+ * @remarks
+ * The transfer starts when the opened insight first renders. Analytical Designer replaces its filters
+ * with each answer of the visualization to a reference point change. An answer that the opened
+ * insight requested can arrive after the filters were set, and then removes them without an error.
+ * When Analytical Designer is not ready yet (its date datasets still load), the command fails and the
+ * transfer retries until it succeeds or takes too long. A later render starts the transfer again if
+ * the retries stopped too early.
+ */
+export function useExploreFilterTransfer(target, isExplore, apiRef) {
+    const dispatch = useDashboardDispatch();
+    const backend = useBackendStrict();
+    const workspace = useWorkspaceStrict();
+    const { addWarning } = useToastMessage();
+    const widgetRef = target.type === "widget" ? target.ref : undefined;
+    const state = {
+        widget: useDashboardSelector(selectAnalyticalWidgetByRef(widgetRef)),
+        insight: useDashboardSelector(selectInsightByWidgetRef(widgetRef)),
+        capabilities: useDashboardSelector(selectBackendCapabilities),
+        displayAsLabelMap: useDashboardSelector(selectAttributeFilterConfigsDisplayAsLabelMap),
+        dateFilter: useDashboardSelector(selectFilterContextDateFilter),
+        isMeasureValueFilterEnabled: useDashboardSelector(selectEnableMeasureValueFilterKD),
+        measureValueFilters: useDashboardSelector(selectFilterContextMeasureValueFilters),
+        enableComputedAttributes: useDashboardSelector(selectEnableComputedAttributes),
+        isTimezoneEnabled: useDashboardSelector(selectEnableTimezoneChange),
+        timezone: useDashboardSelector(selectEffectiveDashboardTimezone),
+    };
+    const stateRef = useRef(state);
+    useEffect(() => {
+        stateRef.current = state;
+    });
+    const progress = useRef({
+        isInsightOpened: false,
+        isFilterContextKept: false,
+        isFailureReported: false,
+        startTime: 0,
+    });
+    const availableAttributes = useRef(null);
+    const retryTimeout = useRef(undefined);
+    const latestRun = useRef(0);
+    // The attributes load while Analytical Designer starts, so the transfer does not wait for them.
+    const getAvailableAttributes = useCallback(() => {
+        const { insight, enableComputedAttributes } = stateRef.current;
+        if (!availableAttributes.current) {
+            const load = insight
+                ? loadInsightAvailableAttributes(backend, workspace, insight, enableComputedAttributes)
+                : Promise.resolve([]);
+            // A failed load is not cached, so the next transfer loads the attributes again.
+            availableAttributes.current = load.catch((error) => {
+                availableAttributes.current = null;
+                throw error;
+            });
+        }
+        return availableAttributes.current;
+    }, [backend, workspace]);
+    useEffect(() => {
+        if (isExplore && widgetRef) {
+            // The transfer reports a failure of this preload.
+            getAvailableAttributes().catch(() => undefined);
+        }
+        return () => clearTimeout(retryTimeout.current);
+    }, [isExplore, widgetRef, getAvailableAttributes]);
+    const transferFilters = useCallback(async (run) => {
+        const attributes = await getAvailableAttributes();
+        const { widget, insight, ...rest } = stateRef.current;
+        if (!isInsightWidget(widget) || !insight) {
+            return;
+        }
+        const appliedFilters = (await queryAndWaitFor(dispatch, queryWidgetFilters(widget.ref)));
+        if (run !== latestRun.current) {
+            return;
+        }
+        const filters = buildInsightEditorFilterContext({
+            widget,
+            insight,
+            appliedFilters,
+            availableAttributes: attributes,
+            attributeFilterConfigsDisplayAsLabelMap: rest.displayAsLabelMap,
+            capabilities: rest.capabilities,
+            dateFilter: rest.dateFilter,
+            isMeasureValueFilterEnabled: rest.isMeasureValueFilterEnabled,
+            measureValueFilters: rest.measureValueFilters,
+        });
+        if (filters.length) {
+            if (!apiRef.current) {
+                return;
+            }
+            apiRef.current.setFilterContext({ filters }, KEEP_FILTER_CONTEXT_ID);
+        }
+        progress.current.isFilterContextKept = true;
+    }, [getAvailableAttributes, dispatch, apiRef]);
+    const keepFilterContext = useCallback(async () => {
+        const current = progress.current;
+        if (!current.isInsightOpened || current.isFilterContextKept) {
+            return;
+        }
+        if (!current.startTime) {
+            current.startTime = Date.now();
+        }
+        if (!widgetRef) {
+            // An insight that is not on the dashboard has no dashboard filters.
+            return;
+        }
+        // Only the latest transfer sends its filters, as an earlier one may still wait for data.
+        const run = ++latestRun.current;
+        try {
+            await transferFilters(run);
+        }
+        catch (error) {
+            // The filters stay not kept, so the next render of the insight tries again.
+            console.error("The dashboard filters cannot pass to Analytical Designer.", error);
+            if (run === latestRun.current && !current.isFailureReported) {
+                current.isFailureReported = true;
+                addWarning(messages.failed, { duration: TOAST_DURATION_MS });
+            }
+        }
+    }, [widgetRef, transferFilters, addWarning]);
+    const onInsightOpened = useCallback(() => {
+        if (!isExplore) {
+            return;
+        }
+        progress.current.isInsightOpened = true;
+        const { isTimezoneEnabled, timezone } = stateRef.current;
+        if (isTimezoneEnabled) {
+            // The explored insight executes in the same timezone as the widget.
+            const command = {
+                gdc: {
+                    product: GdcProductName.ANALYTICAL_DESIGNER,
+                    event: {
+                        name: GdcAdCommandType.SetTimezone,
+                        data: timezone === undefined ? {} : { timezoneId: timezone },
+                    },
+                },
+            };
+            apiRef.current?.sendCommand(command);
+        }
+    }, [isExplore, apiRef]);
+    const onInsightRendered = useCallback(() => {
+        if (isExplore) {
+            void keepFilterContext();
+        }
+    }, [isExplore, keepFilterContext]);
+    const onCommandFailed = useCallback((data, contextId) => {
+        if (!isExplore || contextId !== KEEP_FILTER_CONTEXT_ID) {
+            return;
+        }
+        progress.current.isFilterContextKept = false;
+        if (data.errorCode === GdcErrorType.InvalidArgument) {
+            const isInvalidFilterItemsCount = (data.errorMessage?.indexOf("more than 30 attribute") ?? -1) > 0;
+            addWarning(isInvalidFilterItemsCount
+                ? messages.invalidFilterItemsCount
+                : messages.dateFilterInapplicable, { duration: TOAST_DURATION_MS });
+            return;
+        }
+        if (Date.now() - progress.current.startTime > MAX_KEEPING_DURATION_MS) {
+            addWarning(messages.tookTooLong, { duration: TOAST_DURATION_MS });
+            return;
+        }
+        clearTimeout(retryTimeout.current);
+        retryTimeout.current = setTimeout(() => void keepFilterContext(), RETRY_DELAY_MS);
+    }, [isExplore, addWarning, keepFilterContext]);
+    return useMemo(() => ({ onInsightOpened, onInsightRendered, onCommandFailed }), [onInsightOpened, onInsightRendered, onCommandFailed]);
+}

package/esm/presentation/insightEditor/useInsightEditPermissions.d.ts

@@ -0,0 +1,17 @@
+import { type IAnalyticalBackend } from "@gooddata/sdk-backend-spi";
+import { type AccessGranularPermission, type IInsight } from "@gooddata/sdk-model";
+/**
+ * The current user's own permissions on each visualization of the dashboard, keyed by visualization id.
+ */
+export type InsightPermissionsById = Record<string, AccessGranularPermission[]>;
+export declare function indexInsightPermissions(insights: IInsight[]): InsightPermissionsById;
+export declare function loadInsightPermissions(backend: IAnalyticalBackend, workspace: string, ids: string[]): Promise<InsightPermissionsById>;
+/**
+ * The user's own permissions on the dashboard's visualizations, read in one query once the dashboard
+ * is in (its own load brings the visualizations without permissions). Only users without the MANAGE
+ * role while visualization permissions are on need them; for everyone else no request is made.
+ * `undefined` until the map is in, so a visualization counts as not editable while loading or after a
+ * failed read.
+ */
+export declare function useInsightEditPermissions(isActive?: boolean): InsightPermissionsById | undefined;
+//# sourceMappingURL=useInsightEditPermissions.d.ts.map

package/esm/presentation/insightEditor/useInsightEditPermissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInsightEditPermissions.d.ts","sourceRoot":"","sources":["../../../src/presentation/insightEditor/useInsightEditPermissions.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,KAAK,wBAAwB,EAAE,KAAK,QAAQ,EAAa,MAAM,qBAAqB,CAAC;AAQ9F;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,wBAAwB,EAAE,CAAC,CAAC;AAEhF,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,sBAAsB,CAIpF;AAED,wBAAsB,sBAAsB,CACxC,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,sBAAsB,CAAC,CAWjC;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,UAAO,GAAG,sBAAsB,GAAG,SAAS,CAe7F"}

package/esm/presentation/insightEditor/useInsightEditPermissions.js

@@ -0,0 +1,42 @@
+// (C) 2026 GoodData Corporation
+import { useMemo } from "react";
+import { insightId } from "@gooddata/sdk-model";
+import { useBackendStrict, useCancelablePromise, useWorkspaceStrict } from "@gooddata/sdk-ui";
+import { useDashboardSelector } from "../../model/react/DashboardStoreProvider.js";
+import { selectEnableVisualizationPermissions } from "../../model/store/config/configSelectors.js";
+import { selectInsights } from "../../model/store/insights/insightsSelectors.js";
+import { selectCanManageWorkspace } from "../../model/store/permissions/permissionsSelectors.js";
+export function indexInsightPermissions(insights) {
+    return Object.fromEntries(insights.map((insight) => [insightId(insight), insight.insight.permissions ?? []]));
+}
+export async function loadInsightPermissions(backend, workspace, ids) {
+    const page = await backend
+        .workspace(workspace)
+        .insights()
+        .getInsightsQuery()
+        // the id list travels in the body, a dashboard with many widgets would not fit a URL
+        .withMethod("POST")
+        .withFilter({ id: ids })
+        .withMetaInclude(["permissions"])
+        .query();
+    return indexInsightPermissions(await page.all());
+}
+/**
+ * The user's own permissions on the dashboard's visualizations, read in one query once the dashboard
+ * is in (its own load brings the visualizations without permissions). Only users without the MANAGE
+ * role while visualization permissions are on need them; for everyone else no request is made.
+ * `undefined` until the map is in, so a visualization counts as not editable while loading or after a
+ * failed read.
+ */
+export function useInsightEditPermissions(isActive = true) {
+    const backend = useBackendStrict();
+    const workspace = useWorkspaceStrict();
+    const enabled = useDashboardSelector(selectEnableVisualizationPermissions);
+    const canManageProject = useDashboardSelector(selectCanManageWorkspace);
+    const insights = useDashboardSelector(selectInsights);
+    const ids = useMemo(() => (insights ?? []).map(insightId).sort(), [insights]);
+    const key = ids.join(",");
+    const needed = isActive && enabled && !canManageProject && ids.length > 0;
+    const { result } = useCancelablePromise({ promise: needed ? () => loadInsightPermissions(backend, workspace, ids) : null }, [backend, workspace, needed, key]);
+    return result;
+}

package/esm/presentation/insightEditor/useInsightEditorMenuItems.d.ts

@@ -0,0 +1,23 @@
+import { type IInsight, type IInsightWidget } from "@gooddata/sdk-model";
+import { type IInsightMenuItem, type IInsightMenuItemButton } from "../widget/insightMenu/types.js";
+export declare const EXPLORE_INSIGHT_MENU_ITEM_ID = "explore";
+export declare const EXPLORE_INSIGHT_SEPARATOR_ID = "explore-separator";
+export declare const EDIT_INSIGHT_MENU_ITEM_ID = "options-menu-edit-insight";
+export declare const EDIT_INSIGHT_SEPARATOR_ID = "edit-insight-separator";
+/**
+ * The "Explore from here" item of the widget menu in view mode.
+ */
+export declare function useExploreInsightMenuItem(insight: IInsight | undefined, widget: IInsightWidget, closeMenu: () => void): IInsightMenuItemButton | undefined;
+/**
+ * The "Edit" item of the widget menu in edit mode.
+ */
+export declare function useEditInsightMenuItem(insight: IInsight | undefined, widget: IInsightWidget): IInsightMenuItemButton | undefined;
+/**
+ * Puts the explore item first, separated from the other items.
+ */
+export declare function addExploreMenuItem(items: IInsightMenuItem[], exploreItem: IInsightMenuItemButton | undefined): IInsightMenuItem[];
+/**
+ * Puts the edit item last, but before the remove item, which stays the last one.
+ */
+export declare function addEditMenuItem(items: IInsightMenuItem[], editItem: IInsightMenuItemButton | undefined): IInsightMenuItem[];
+//# sourceMappingURL=useInsightEditorMenuItems.d.ts.map

package/esm/presentation/insightEditor/useInsightEditorMenuItems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInsightEditorMenuItems.d.ts","sourceRoot":"","sources":["../../../src/presentation/insightEditor/useInsightEditorMenuItems.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAmC,MAAM,qBAAqB,CAAC;AAc1G,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAIpG,eAAO,MAAM,4BAA4B,YAAY,CAAC;AACtD,eAAO,MAAM,4BAA4B,sBAAsB,CAAC;AAChE,eAAO,MAAM,yBAAyB,8BAA8B,CAAC;AACrE,eAAO,MAAM,yBAAyB,2BAA2B,CAAC;AAGlE;;GAEG;AACH,wBAAgB,yBAAyB,CACrC,OAAO,EAAE,QAAQ,GAAG,SAAS,EAC7B,MAAM,EAAE,cAAc,EACtB,SAAS,EAAE,MAAM,IAAI,GACtB,sBAAsB,GAAG,SAAS,CAsCpC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAClC,OAAO,EAAE,QAAQ,GAAG,SAAS,EAC7B,MAAM,EAAE,cAAc,GACvB,sBAAsB,GAAG,SAAS,CA0CpC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,gBAAgB,EAAE,EACzB,WAAW,EAAE,sBAAsB,GAAG,SAAS,GAChD,gBAAgB,EAAE,CAUpB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC3B,KAAK,EAAE,gBAAgB,EAAE,EACzB,QAAQ,EAAE,sBAAsB,GAAG,SAAS,GAC7C,gBAAgB,EAAE,CAYpB"}

package/esm/presentation/insightEditor/useInsightEditorMenuItems.js

@@ -0,0 +1,126 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2021-2026 GoodData Corporation
+import { useMemo } from "react";
+import { useIntl } from "react-intl";
+import { canEditVisualization, insightId } from "@gooddata/sdk-model";
+import { IconExplore, useMediaQuery } from "@gooddata/sdk-ui-kit";
+import { useTheme } from "@gooddata/sdk-ui-theme-provider";
+import { useDashboardDispatch, useDashboardSelector } from "../../model/react/DashboardStoreProvider.js";
+import { selectEnableInsightEditing, selectEnableVisualizationPermissions, } from "../../model/store/config/configSelectors.js";
+import { selectCanCreateVisualization, selectPermissions, } from "../../model/store/permissions/permissionsSelectors.js";
+import { uiActions } from "../../model/store/ui/index.js";
+import { useInsightEditorPermissions } from "./InsightEditorPermissionsContext.js";
+export const EXPLORE_INSIGHT_MENU_ITEM_ID = "explore";
+export const EXPLORE_INSIGHT_SEPARATOR_ID = "explore-separator";
+export const EDIT_INSIGHT_MENU_ITEM_ID = "options-menu-edit-insight";
+export const EDIT_INSIGHT_SEPARATOR_ID = "edit-insight-separator";
+const REMOVE_MENU_ITEM_ID = "InteractionPanelRemove";
+/**
+ * The "Explore from here" item of the widget menu in view mode.
+ */
+export function useExploreInsightMenuItem(insight, widget, closeMenu) {
+    const intl = useIntl();
+    const theme = useTheme();
+    const dispatch = useDashboardDispatch();
+    const isEnabled = useDashboardSelector(selectEnableInsightEditing);
+    const canCreateVisualization = useDashboardSelector(selectCanCreateVisualization);
+    const isMobile = useMediaQuery("mobileDevice");
+    const iconColor = theme?.palette?.complementary?.c5;
+    return useMemo(() => {
+        // Explore opens a draft the user may save as a new visualization, so it is a create path.
+        if (!isEnabled || !insight || !canCreateVisualization || isMobile) {
+            return undefined;
+        }
+        return {
+            type: "button",
+            itemId: EXPLORE_INSIGHT_MENU_ITEM_ID,
+            className: "s-options-menu-explore-insight",
+            itemName: intl.formatMessage({ id: "insightEditor.menu.explore" }),
+            icon: (_jsx(IconExplore, { className: "gd-icon-explore gd-icon-explore-sdk", color: iconColor, ariaHidden: true })),
+            onClick: () => {
+                dispatch(uiActions.openInsightEditor({ type: "widget", ref: widget.ref }));
+                closeMenu();
+            },
+        };
+    }, [
+        isEnabled,
+        insight,
+        canCreateVisualization,
+        isMobile,
+        intl,
+        iconColor,
+        dispatch,
+        widget.ref,
+        closeMenu,
+    ]);
+}
+/**
+ * The "Edit" item of the widget menu in edit mode.
+ */
+export function useEditInsightMenuItem(insight, widget) {
+    const intl = useIntl();
+    const dispatch = useDashboardDispatch();
+    const isEnabled = useDashboardSelector(selectEnableInsightEditing);
+    const workspacePermissions = useDashboardSelector(selectPermissions);
+    const visualizationPermissionsEnabled = useDashboardSelector(selectEnableVisualizationPermissions);
+    const insightPermissions = useInsightEditorPermissions();
+    return useMemo(() => {
+        // Editing a visualization follows the right to save it in place, not the right to create one.
+        const canEditInsight = isEnabled &&
+            !!insight &&
+            !!workspacePermissions &&
+            canEditVisualization(insightPermissions?.[insightId(insight)], workspacePermissions, visualizationPermissionsEnabled);
+        if (!canEditInsight) {
+            return undefined;
+        }
+        return {
+            type: "button",
+            itemId: EDIT_INSIGHT_MENU_ITEM_ID,
+            className: "s-options-menu-edit-insight",
+            itemName: intl.formatMessage({ id: "controlButtons.edit.value" }),
+            icon: "gd-icon-pencil",
+            onClick: () => {
+                dispatch(uiActions.openInsightEditor({ type: "widget", ref: widget.ref }));
+            },
+        };
+    }, [
+        isEnabled,
+        insight,
+        workspacePermissions,
+        insightPermissions,
+        visualizationPermissionsEnabled,
+        intl,
+        dispatch,
+        widget.ref,
+    ]);
+}
+/**
+ * Puts the explore item first, separated from the other items.
+ */
+export function addExploreMenuItem(items, exploreItem) {
+    if (!exploreItem) {
+        return items;
+    }
+    const needsSeparator = items.length > 0 && items[0].type !== "separator";
+    return [
+        exploreItem,
+        ...(needsSeparator ? [{ type: "separator", itemId: EXPLORE_INSIGHT_SEPARATOR_ID }] : []),
+        ...items,
+    ];
+}
+/**
+ * Puts the edit item last, but before the remove item, which stays the last one.
+ */
+export function addEditMenuItem(items, editItem) {
+    if (!editItem) {
+        return items;
+    }
+    const removeItem = items.find((item) => item.itemId === REMOVE_MENU_ITEM_ID);
+    const otherItems = items.filter((item) => item !== removeItem);
+    return [
+        ...otherItems,
+        editItem,
+        ...(items.length > 0 ? [{ type: "separator", itemId: EDIT_INSIGHT_SEPARATOR_ID }] : []),
+        ...(removeItem ? [removeItem] : []),
+    ];
+}

package/esm/presentation/insightEditor/useInsightEditorSession.d.ts

@@ -0,0 +1,19 @@
+import { type InsightEditorTarget } from "../../model/types/insightEditorTypes.js";
+export interface IInsightEditorSession {
+    /**
+     * Closes the editor without saving. It removes the placeholder of a new insight. It does nothing
+     * after the session ended or while a save runs.
+     */
+    cancel: () => void;
+    /**
+     * Puts the insight that the user saved in Analytical Designer on the dashboard and closes the
+     * editor.
+     */
+    save: (insightIdentifier: string) => Promise<void>;
+}
+/**
+ * The actions that finish the editing session of the target. They need no Analytical Designer code,
+ * so the editor can close while its chunk still loads.
+ */
+export declare function useInsightEditorSession(target: InsightEditorTarget): IInsightEditorSession;
+//# sourceMappingURL=useInsightEditorSession.d.ts.map

package/esm/presentation/insightEditor/useInsightEditorSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInsightEditorSession.d.ts","sourceRoot":"","sources":["../../../src/presentation/insightEditor/useInsightEditorSession.ts"],"names":[],"mappings":"AAuCA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAenF,MAAM,WAAW,qBAAqB;IAClC;;;OAGG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;IAEnB;;;OAGG;IACH,IAAI,EAAE,CAAC,iBAAiB,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACtD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,mBAAmB,GAAG,qBAAqB,CAmF1F"}

package/esm/presentation/insightEditor/useInsightEditorSession.js

@@ -0,0 +1,141 @@
+// (C) 2020-2026 GoodData Corporation
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { defineMessages } from "react-intl";
+import { idRef, insightRef, insightTitle, insightVisualizationType, isInsightWidget, } from "@gooddata/sdk-model";
+import { useBackendStrict, useWorkspaceStrict } from "@gooddata/sdk-ui";
+import { INSIGHT_WIDGET_SIZE_INFO_DEFAULT } from "@gooddata/sdk-ui-ext";
+import { useToastMessage } from "@gooddata/sdk-ui-kit";
+import { getSizeInfo } from "../../_staging/layout/sizing.js";
+import { changeInsightWidgetInsight } from "../../model/commands/insight.js";
+import { eagerRemoveNestedLayoutSectionItem, replaceNestedLayoutSectionItem, } from "../../model/commands/layout.js";
+import { insightEditorCancelled, insightEditorInsightSaved } from "../../model/events/insightEditor.js";
+import { useDashboardDispatch, useDashboardSelector } from "../../model/react/DashboardStoreProvider.js";
+import { useDashboardEventDispatch } from "../../model/react/useDashboardEventDispatch.js";
+import { dispatchAndWaitFor } from "../../model/store/_infra/dispatchAndWaitFor.js";
+import { selectSettings } from "../../model/store/config/configSelectors.js";
+import { selectInsightByWidgetRef } from "../../model/store/insights/insightsSelectors.js";
+import { selectIsInEditMode } from "../../model/store/renderMode/renderModeSelectors.js";
+import { selectInsightWidgetPlaceholderPath, selectWidgetByRef, } from "../../model/store/tabs/layout/layoutSelectors.js";
+import { uiActions } from "../../model/store/ui/index.js";
+const messages = defineMessages({
+    placementFailed: { id: "insightEditor.save.placementFailed" },
+});
+/**
+ * The actions that finish the editing session of the target. They need no Analytical Designer code,
+ * so the editor can close while its chunk still loads.
+ */
+export function useInsightEditorSession(target) {
+    const dispatch = useDashboardDispatch();
+    const eventDispatch = useDashboardEventDispatch();
+    const backend = useBackendStrict();
+    const workspace = useWorkspaceStrict();
+    const { addError } = useToastMessage();
+    const widgetRef = target.type === "widget" ? target.ref : undefined;
+    const state = {
+        isEditMode: useDashboardSelector(selectIsInEditMode),
+        placeholderPath: useDashboardSelector(selectInsightWidgetPlaceholderPath),
+        settings: useDashboardSelector(selectSettings),
+        widget: useDashboardSelector(selectWidgetByRef(widgetRef)),
+        widgetInsight: useDashboardSelector(selectInsightByWidgetRef(widgetRef)),
+    };
+    // The handlers run after AD events, so they read the state of that moment.
+    const stateRef = useRef(state);
+    useEffect(() => {
+        stateRef.current = state;
+    });
+    // AD confirms a cancellation at once after a save. The first save or cancel ends the session, so a
+    // cancellation during a running save cannot remove the placeholder that the save fills.
+    const isSettledRef = useRef(false);
+    const close = useCallback(() => {
+        dispatch(uiActions.closeInsightEditor());
+    }, [dispatch]);
+    const removePlaceholder = useCallback(() => {
+        const { placeholderPath } = stateRef.current;
+        if (target.type === "placeholder" && placeholderPath) {
+            dispatch(eagerRemoveNestedLayoutSectionItem(placeholderPath));
+        }
+    }, [target, dispatch]);
+    const cancel = useCallback(() => {
+        if (isSettledRef.current) {
+            return;
+        }
+        isSettledRef.current = true;
+        close();
+        eventDispatch(insightEditorCancelled(target));
+        removePlaceholder();
+    }, [close, eventDispatch, target, removePlaceholder]);
+    const save = useCallback(async (insightIdentifier) => {
+        if (isSettledRef.current) {
+            return;
+        }
+        isSettledRef.current = true;
+        let insight;
+        try {
+            insight = await backend
+                .workspace(workspace)
+                .insights()
+                .getInsight(idRef(insightIdentifier, "insight"));
+            if (stateRef.current.isEditMode) {
+                await placeInsight(dispatch, target, insight, stateRef.current);
+            }
+            close();
+            eventDispatch(insightEditorInsightSaved(target, insight));
+        }
+        catch (error) {
+            console.error("The insight saved in Analytical Designer cannot be put on the dashboard.", error);
+            close();
+            removePlaceholder();
+            addError(messages.placementFailed);
+            // The insight exists in the backend, so listeners must learn about it when it loaded.
+            eventDispatch(insight ? insightEditorInsightSaved(target, insight) : insightEditorCancelled(target));
+        }
+    }, [backend, workspace, target, dispatch, close, removePlaceholder, addError, eventDispatch]);
+    return useMemo(() => ({ cancel, save }), [cancel, save]);
+}
+async function placeInsight(dispatch, target, insight, { placeholderPath, settings, widget, widgetInsight }) {
+    if (target.type === "placeholder") {
+        if (placeholderPath) {
+            await addInsightToPlaceholder(dispatch, insight, placeholderPath, getSizeInfo(settings, "insight", insight));
+        }
+    }
+    else if (target.type === "widget") {
+        if (isInsightWidget(widget)) {
+            const originalType = widgetInsight && insightVisualizationType(widgetInsight);
+            const newType = insightVisualizationType(insight);
+            // Table sizes reset always, as the buckets may have changed.
+            const sizes = originalType === newType && newType !== "table" ? undefined : {};
+            dispatch(changeInsightWidgetInsight(widget.ref, insightRef(insight), sizes));
+        }
+    }
+    else {
+        // The new insight is not on the dashboard yet, so the list of insights must show it.
+        dispatch(uiActions.requestInsightListUpdate());
+    }
+}
+async function addInsightToPlaceholder(dispatch, insight, placeholderPath, sizeInfo) {
+    const itemReplaced = await dispatchAndWaitFor(dispatch, replaceNestedLayoutSectionItem(placeholderPath, {
+        type: "IDashboardLayoutItem",
+        size: {
+            xl: {
+                gridHeight: sizeInfo.height.default || INSIGHT_WIDGET_SIZE_INFO_DEFAULT.height.default,
+                gridWidth: sizeInfo.width.default || INSIGHT_WIDGET_SIZE_INFO_DEFAULT.width.default,
+            },
+        },
+        widget: {
+            type: "insight",
+            insight: insightRef(insight),
+            ignoreDashboardFilters: [],
+            drills: [],
+            title: insightTitle(insight),
+            description: "",
+            configuration: { hideTitle: false },
+            properties: {},
+        },
+    }, undefined, true));
+    const addedWidgetRef = itemReplaced.payload.items[0]?.widget?.ref;
+    if (addedWidgetRef) {
+        dispatch(uiActions.selectWidget(addedWidgetRef));
+        dispatch(uiActions.setConfigurationPanelOpened(true));
+    }
+    dispatch(uiActions.requestInsightListUpdate());
+}

package/esm/presentation/insightList/InsightList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InsightList.d.ts","sourceRoot":"","sources":["../../../src/presentation/insightList/InsightList.tsx"],"names":[],"mappings":"AAMA,OAAO,EACH,KAAK,QAAQ,EAUhB,MAAM,qBAAqB,CAAC;AAiC7B,OAAO,EAAE,KAAK,iBAAiB,EAAuB,MAAM,YAAY,CAAC;AAKzE,UAAU,gBAAgB;IACtB,OAAO,EAAE,QAAQ,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,QAAQ,GAAG,gBAAgB,CAO5E;AAsCD;;GAEG;AACH,wBAAgB,WAAW,CAAC,EACxB,MAAM,EACN,KAAkB,EAClB,eAAe,EACf,UAAU,EACV,WAAW,EACX,QAAQ,EACR,kBAAkB,EAClB,WAAW,GACd,EAAE,iBAAiB,2CA8OnB"}
+{"version":3,"file":"InsightList.d.ts","sourceRoot":"","sources":["../../../src/presentation/insightList/InsightList.tsx"],"names":[],"mappings":"AAMA,OAAO,EACH,KAAK,QAAQ,EAUhB,MAAM,qBAAqB,CAAC;AAmC7B,OAAO,EAAE,KAAK,iBAAiB,EAAuB,MAAM,YAAY,CAAC;AAKzE,UAAU,gBAAgB;IACtB,OAAO,EAAE,QAAQ,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,QAAQ,GAAG,gBAAgB,CAO5E;AAsCD;;GAEG;AACH,wBAAgB,WAAW,CAAC,EACxB,MAAM,EACN,KAAkB,EAClB,eAAe,EACf,UAAU,EACV,WAAW,EACX,QAAQ,EACR,kBAAkB,EAClB,WAAW,GACd,EAAE,iBAAiB,2CAsPnB"}

package/esm/presentation/insightList/InsightList.js

@@ -9,12 +9,13 @@ import { DropdownList, InsightListItem, UiSkeleton } from "@gooddata/sdk-ui-kit"
 import { customMatcher, useHybridSearch, } from "@gooddata/sdk-ui-semantic-search";
 import { messages } from "../../locales.js";
 import { createInsightRequested } from "../../model/events/lab.js";
-import { useDashboardSelector } from "../../model/react/DashboardStoreProvider.js";
+import { useDashboardDispatch, useDashboardSelector } from "../../model/react/DashboardStoreProvider.js";
 import { useDashboardEventDispatch } from "../../model/react/useDashboardEventDispatch.js";
 import { useDashboardExecConfig } from "../../model/react/useWidgetExecConfig.js";
 import { selectBackendCapabilities } from "../../model/store/backendCapabilities/backendCapabilitiesSelectors.js";
-import { selectAllowCreateInsightRequest, selectEnableCatalogSmartSearchResults, selectEnableVisualizationFilteringByTags, selectObjectAvailabilityConfig, selectSettings, } from "../../model/store/config/configSelectors.js";
+import { selectAllowCreateInsightRequest, selectEnableCatalogSmartSearchResults, selectEnableInsightEditing, selectEnableVisualizationFilteringByTags, selectObjectAvailabilityConfig, selectSettings, } from "../../model/store/config/configSelectors.js";
 import { selectCanCreateVisualization } from "../../model/store/permissions/permissionsSelectors.js";
+import { uiActions } from "../../model/store/ui/index.js";
 import { selectInsightListLastUpdateRequested } from "../../model/store/ui/uiSelectors.js";
 import { selectRestrictedRichTextReferences } from "../../model/store/unavailableObjects/unavailableObjectsSelectors.js";
 import { selectCurrentUser } from "../../model/store/user/userSelectors.js";
@@ -136,12 +137,16 @@ export function InsightList({ height, width = LIST_WIDTH, searchAutofocus, rende
         return isFirstOrLast ? ITEM_HEIGHT + firstLastItemMargin : ITEM_HEIGHT;
     };
     const eventDispatch = useDashboardEventDispatch();
+    const dispatch = useDashboardDispatch();
+    const isInsightEditingEnabled = useDashboardSelector(selectEnableInsightEditing);
     const createInsightRequestedEvent = useCallback((e) => {
         e.preventDefault();
         e.stopPropagation();
         eventDispatch(createInsightRequested());
-        // oxlint-disable-next-line react-hooks/exhaustive-deps
-    }, []);
+        if (isInsightEditingEnabled) {
+            dispatch(uiActions.openInsightEditor({ type: "new" }));
+        }
+    }, [eventDispatch, dispatch, isInsightEditingEnabled]);
     const TABS_AND_SEARCHFIELD_HEIGHT = 70;
     const SEARCHFIELD_HEIGHT = 47;
     // need to subtract height of controls from the overall size which was measured
@@ -149,7 +154,7 @@ export function InsightList({ height, width = LIST_WIDTH, searchAutofocus, rende
     const dropdownListHeight = height && height - controlsHeight;
     const dropdownListLoading = isLoading && pagedInsights.length === 0;
     const showDropdownListTabs = initialLoadCompleted && !search;
-    const showNoDataCreateButton = allowCreateInsightRequest && canCreateVisualization;
+    const showNoDataCreateButton = (allowCreateInsightRequest || isInsightEditingEnabled) && canCreateVisualization;
     return (_jsx(DropdownList, { width: width, height: dropdownListHeight, isMobile: false, isLoading: dropdownListLoading, showSearch: initialLoadCompleted, searchString: search, searchFieldSize: "small", searchPlaceholder: intl.formatMessage({ id: "search_insights" }), onSearch: onSearch, disableAutofocus: !searchAutofocus, showTabs: showDropdownListTabs, tabs: backend.capabilities.supportsOwners && author ? dropdownTabsTranslationIds : undefined, selectedTabId: selectedTabId, onTabSelect: onTabSelect, itemHeight: ITEM_HEIGHT, itemHeightGetter: itemHeightGetter, items: insights, itemsCount: totalItems, body: () => {
             if (!isLoading && pagedInsights.length === 0 && searchRelatedItems.length > 0) {
                 return (_jsx(InsightListNoData, { isUserInsights: selectedTabId === messages.tabsMy.id, hasNoMatchingData: true, showNoDataCreateButton: showNoDataCreateButton, onCreateButtonClick: createInsightRequestedEvent }));

package/esm/presentation/localization/bundles/de-DE.localization-bundle.d.ts

@@ -1,4 +1,6 @@
 export declare const de_DE: {
+    "dashboard.ai.composing.replyNow": string;
+    "dashboard.ai.composing.waiting": string;
     "dashboard.contractExpired.trial.title": string;
     "dashboard.contractExpired.trial.description": string;
     "dashboard.contractExpired.nonTrial.title": string;
@@ -941,5 +943,13 @@ export declare const de_DE: {
     "dashboard_add_filter.button.aria_label": string;
     "dashboard_add_filter.menu.title": string;
     "dashboard_add_filter.menu.parameter": string;
+    "insightEditor.menu.explore": string;
+    "addPanel.insight": string;
+    "insightEditor.filterContext.dateFilterInapplicable": string;
+    "insightEditor.filterContext.invalidFilterItemsCount": string;
+    "insightEditor.filterContext.tookTooLong": string;
+    "insightEditor.filterContext.failed": string;
+    "insightEditor.dialog.label": string;
+    "insightEditor.save.placementFailed": string;
 };
 //# sourceMappingURL=de-DE.localization-bundle.d.ts.map