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

package/esm/presentation/insightEditor/InsightEditorContent.js

@@ -0,0 +1,158 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useEffect, useMemo, useRef, useState } from "react";
+import { insightIsLocked, insightRef } from "@gooddata/sdk-model";
+import { useBackendStrict, useWorkspaceStrict } from "@gooddata/sdk-ui";
+import { AnalyticalDesigner, } from "@gooddata/sdk-ui-analytical-designer";
+import { useTheme } from "@gooddata/sdk-ui-theme-provider";
+import { attributeHierarchyModified } from "../../model/commands/insight.js";
+import { insightEditorCacheResetRequested } from "../../model/events/insightEditor.js";
+import { useDashboardDispatch, useDashboardSelector } from "../../model/react/DashboardStoreProvider.js";
+import { useDashboardEventDispatch } from "../../model/react/useDashboardEventDispatch.js";
+import { selectAgGridToken, selectColorPalette, selectIsEmbedded, selectIsWhiteLabeled, selectLocale, selectMapboxToken, selectObjectAvailabilityConfig, selectSeparators, selectSettings, } from "../../model/store/config/configSelectors.js";
+import { selectEntitlements } from "../../model/store/entitlements/entitlementsSelectors.js";
+import { selectInsightByWidgetRef } from "../../model/store/insights/insightsSelectors.js";
+import { selectDashboardId } from "../../model/store/meta/metaSelectors.js";
+import { selectCanCreateVisualization, selectCanManageWorkspace, selectPermissions, } from "../../model/store/permissions/permissionsSelectors.js";
+import { selectIsInEditMode } from "../../model/store/renderMode/renderModeSelectors.js";
+import { selectExecutionTimestamp } from "../../model/store/ui/uiSelectors.js";
+import { selectCurrentUser } from "../../model/store/user/userSelectors.js";
+import { getInsightEditorRoute } from "./insightEditorRoute.js";
+import { useExploreFilterTransfer } from "./useExploreFilterTransfer.js";
+// The stylesheets Analytical Designer needs load with its lazy chunk, the SDK ones first, so the
+// rules of Analytical Designer win.
+// oxlint-disable-next-line import/no-unassigned-import
+import "@gooddata/sdk-ui-kit/styles/css/main.css";
+// oxlint-disable-next-line import/no-unassigned-import
+import "@gooddata/sdk-ui-pivot/styles/css/main.css";
+// oxlint-disable-next-line import/no-unassigned-import
+import "@gooddata/sdk-ui-geo/styles/css/main.css";
+// oxlint-disable-next-line import/no-unassigned-import
+import "@gooddata/sdk-ui-charts/styles/css/main.css";
+// oxlint-disable-next-line import/no-unassigned-import
+import "@gooddata/sdk-ui-filters/styles/css/measureValueFilter.css";
+// oxlint-disable-next-line import/no-unassigned-import
+import "@gooddata/sdk-ui-filters/styles/css/dateFilter.css";
+// oxlint-disable-next-line import/no-unassigned-import
+import "@gooddata/sdk-ui-filters/styles/css/rankingFilter.css";
+// oxlint-disable-next-line import/no-unassigned-import
+import "@gooddata/sdk-ui-filters/styles/css/attributeFilterNext.css";
+// oxlint-disable-next-line import/no-unassigned-import
+import "@gooddata/sdk-ui-ext/styles/css/main.css";
+// oxlint-disable-next-line import/no-unassigned-import
+import "@gooddata/sdk-ui-semantic-search/styles/css/internal.css";
+// oxlint-disable-next-line import/no-unassigned-import
+import "@gooddata/sdk-ui-analytical-designer/styles/css/main.css";
+/**
+ * Analytical Designer in the insight editor overlay. It lives in a lazily loaded chunk together with
+ * the whole Analytical Designer.
+ */
+export function InsightEditorContent({ target, session, closeHandleRef }) {
+    const backend = useBackendStrict();
+    const workspace = useWorkspaceStrict();
+    const dispatch = useDashboardDispatch();
+    const eventDispatch = useDashboardEventDispatch();
+    const hostConfig = useHostConfig();
+    const theme = useTheme();
+    const permissions = useDashboardSelector(selectPermissions);
+    const isEditMode = useDashboardSelector(selectIsInEditMode);
+    const route = useRoute(target, isEditMode);
+    const apiRef = useRef(null);
+    const [isFailed, setIsFailed] = useState(false);
+    useEffect(() => {
+        closeHandleRef.current = isFailed
+            ? null
+            : { requestClose: () => apiRef.current?.requestCancellation() };
+        return () => {
+            closeHandleRef.current = null;
+        };
+    }, [closeHandleRef, isFailed]);
+    const isExplore = !isEditMode && (target.type === "widget" || target.type === "insight");
+    const filterTransfer = useExploreFilterTransfer(target, isExplore, apiRef);
+    const cacheReset = useMemo(() => ({
+        resetAll: () => eventDispatch(insightEditorCacheResetRequested("all")),
+        resetCatalogs: () => eventDispatch(insightEditorCacheResetRequested("catalogs")),
+    }), [eventDispatch]);
+    const config = useMemo(() => ({ ...hostConfig, ...route.config }), [hostConfig, route.config]);
+    return (_jsx(AnalyticalDesigner, { backend: backend, workspace: workspace, insight: route.insight, config: config, permissions: permissions, theme: theme, 
+        // The dashboard already resolved the theme of the workspace.
+        disableThemeLoading: true, cacheReset: cacheReset, onInsightSaved: (data) => void session.save(data.insight.identifier), onInsightEditingCancelled: session.cancel, onInsightOpened: filterTransfer.onInsightOpened, onInsightRendered: filterTransfer.onInsightRendered, onCommandFailed: filterTransfer.onCommandFailed, onAttributeHierarchyModified: () => {
+            eventDispatch(insightEditorCacheResetRequested("catalogs"));
+            dispatch(attributeHierarchyModified());
+        }, 
+        // A failed Analytical Designer never answers a command, so the overlay closes directly.
+        onError: () => setIsFailed(true), apiRef: apiRef }));
+}
+/**
+ * The values that Analytical Designer would otherwise load when it starts. The dashboard has them
+ * already.
+ */
+function useHostConfig() {
+    const locale = useDashboardSelector(selectLocale);
+    const separators = useDashboardSelector(selectSeparators);
+    const settings = useDashboardSelector(selectSettings);
+    const mapboxToken = useDashboardSelector(selectMapboxToken);
+    const agGridToken = useDashboardSelector(selectAgGridToken);
+    const colorPalette = useDashboardSelector(selectColorPalette);
+    const isWhiteLabeled = useDashboardSelector(selectIsWhiteLabeled);
+    const user = useDashboardSelector(selectCurrentUser);
+    const entitlements = useDashboardSelector(selectEntitlements);
+    const objectAvailability = useDashboardSelector(selectObjectAvailabilityConfig);
+    const asOfDate = useDashboardSelector(selectExecutionTimestamp);
+    return useMemo(() => ({
+        locale,
+        separators,
+        // The dashboard keeps the settings of the user in the workspace.
+        settings: settings,
+        mapboxToken,
+        agGridToken,
+        colorPalette,
+        whiteLabeling: { isBranded: isWhiteLabeled },
+        user,
+        organization: { entitlements },
+        asOfDate,
+        includeObjectsWithTags: objectAvailability?.includeObjectsWithTags,
+        excludeObjectsWithTags: objectAvailability?.excludeObjectsWithTags,
+    }), [
+        locale,
+        separators,
+        settings,
+        mapboxToken,
+        agGridToken,
+        colorPalette,
+        isWhiteLabeled,
+        user,
+        entitlements,
+        objectAvailability,
+        asOfDate,
+    ]);
+}
+function useRoute(target, isEditMode) {
+    const widgetRef = target.type === "widget" ? target.ref : undefined;
+    const widgetInsight = useDashboardSelector(selectInsightByWidgetRef(widgetRef));
+    const dashboardId = useDashboardSelector(selectDashboardId);
+    const isEmbedded = useDashboardSelector(selectIsEmbedded);
+    const canManageWorkspace = useDashboardSelector(selectCanManageWorkspace);
+    const canCreateVisualization = useDashboardSelector(selectCanCreateVisualization);
+    const widgetInsightRef = useMemo(() => (widgetInsight ? insightRef(widgetInsight) : undefined), [widgetInsight]);
+    const isWidgetInsightLocked = widgetInsight ? insightIsLocked(widgetInsight) : false;
+    return useMemo(() => getInsightEditorRoute({
+        target,
+        widgetInsightRef,
+        isWidgetInsightLocked,
+        dashboardId,
+        isEditMode,
+        isEmbedded,
+        canManageWorkspace,
+        canCreateVisualization,
+    }), [
+        target,
+        widgetInsightRef,
+        isWidgetInsightLocked,
+        dashboardId,
+        isEditMode,
+        isEmbedded,
+        canManageWorkspace,
+        canCreateVisualization,
+    ]);
+}

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

@@ -0,0 +1,7 @@
+import { type ICreatePanelItemComponentProps } from "../componentDefinition/types.js";
+/**
+ * The item of the edit mode panel that the user drags to the layout to create a new insight in the
+ * embedded Analytical Designer.
+ */
+export declare function InsightEditorCreatePanelItem({ WrapCreatePanelItemWithDragComponent, disabled, }: ICreatePanelItemComponentProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=InsightEditorCreatePanelItem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InsightEditorCreatePanelItem.d.ts","sourceRoot":"","sources":["../../../src/presentation/insightEditor/InsightEditorCreatePanelItem.tsx"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AAuBtF;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,EACzC,oCAAoC,EACpC,QAAQ,GACX,EAAE,8BAA8B,2CAYhC"}

package/esm/presentation/insightEditor/InsightEditorCreatePanelItem.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2022-2026 GoodData Corporation
+import { FormattedMessage } from "react-intl";
+import { INSIGHT_WIDGET_SIZE_INFO_NEW_DEFAULT } from "@gooddata/sdk-ui-ext";
+import { UiIcon } from "@gooddata/sdk-ui-kit";
+import { useWidgetSelection } from "../../model/react/useWidgetSelection.js";
+import { DraggableCreatePanelItem } from "../dragAndDrop/DraggableCreatePanelItem.js";
+const dragItem = {
+    type: "insight-placeholder",
+    size: {
+        gridWidth: INSIGHT_WIDGET_SIZE_INFO_NEW_DEFAULT.width.default,
+        gridHeight: INSIGHT_WIDGET_SIZE_INFO_NEW_DEFAULT.height.default,
+    },
+};
+function AddInsightPlaceholder() {
+    return (_jsxs("div", { className: "add-item-placeholder add-insight-placeholder s-add-insight", children: [_jsx("div", { className: "add-item-placeholder__icon", children: _jsx(UiIcon, { type: "visualization", size: 18, layout: "block" }) }), _jsx(FormattedMessage, { id: "addPanel.insight" })] }));
+}
+/**
+ * The item of the edit mode panel that the user drags to the layout to create a new insight in the
+ * embedded Analytical Designer.
+ */
+export function InsightEditorCreatePanelItem({ WrapCreatePanelItemWithDragComponent, disabled, }) {
+    const { deselectWidgets } = useWidgetSelection();
+    return (_jsx(DraggableCreatePanelItem, { Component: AddInsightPlaceholder, WrapCreatePanelItemWithDragComponent: WrapCreatePanelItemWithDragComponent, disabled: disabled, dragItem: dragItem, hideDefaultPreview: false, onDragStart: () => deselectWidgets() }));
+}

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

@@ -0,0 +1,6 @@
+/**
+ * The embedded Analytical Designer on top of the dashboard. It renders only when the dashboard config
+ * enables insight editing.
+ */
+export declare function InsightEditorOverlay(): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=InsightEditorOverlay.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InsightEditorOverlay.d.ts","sourceRoot":"","sources":["../../../src/presentation/insightEditor/InsightEditorOverlay.tsx"],"names":[],"mappings":"AAsCA;;;GAGG;AACH,wBAAgB,oBAAoB,mDAGnC"}

package/esm/presentation/insightEditor/InsightEditorOverlay.js

@@ -0,0 +1,110 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2020-2026 GoodData Corporation
+import { Suspense, lazy, useCallback, useEffect, useRef, useState } from "react";
+import { useIntl } from "react-intl";
+import { objRefToString } from "@gooddata/sdk-model";
+import { LoadingMask, Overlay, OverlayController, OverlayControllerProvider, useMediaQuery, } from "@gooddata/sdk-ui-kit";
+import { insightEditorOpened } from "../../model/events/insightEditor.js";
+import { useDashboardDispatch, useDashboardSelector } from "../../model/react/DashboardStoreProvider.js";
+import { useDashboardEventDispatch } from "../../model/react/useDashboardEventDispatch.js";
+import { selectEnableInsightEditing } from "../../model/store/config/configSelectors.js";
+import { uiActions } from "../../model/store/ui/index.js";
+import { selectInsightEditorTarget } from "../../model/store/ui/uiSelectors.js";
+import { isInsightOverlayTopmost } from "./insightEditorEscapeGuard.js";
+import { useInsightEditorSession } from "./useInsightEditorSession.js";
+// Analytical Designer downloads when the editor first opens, not with the dashboard.
+const LazyInsightEditorContent = lazy(() => import("./InsightEditorContent.js").then((module) => ({ default: module.InsightEditorContent })));
+// AD renders the configuration panels of visualizations in a separate React root, so the overlays it
+// opens from there (dropdowns, color pickers) see no OverlayControllerProvider and fall back to the
+// ui-kit default z-index 5001. The editor overlay must not paint above them: its controller base 5000
+// gives it 5001 too, and the config panel popups win by DOM order.
+const overlayController = OverlayController.getInstance(5000);
+/**
+ * The embedded Analytical Designer on top of the dashboard. It renders only when the dashboard config
+ * enables insight editing.
+ */
+export function InsightEditorOverlay() {
+    const isEnabled = useDashboardSelector(selectEnableInsightEditing);
+    return isEnabled ? _jsx(InsightEditorOverlayCore, {}) : null;
+}
+function InsightEditorOverlayCore() {
+    const dispatch = useDashboardDispatch();
+    const target = useDashboardSelector(selectInsightEditorTarget);
+    const isMobile = useMediaQuery("mobileDevice");
+    // The editor has no mobile layout, so it does not open on a mobile screen. A breakpoint change
+    // after the editor opened keeps it open: an unmount would drop the editing session silently.
+    const [openedTarget, setOpenedTarget] = useState({ target, isMobile });
+    if (openedTarget.target !== target) {
+        setOpenedTarget({ target, isMobile });
+    }
+    const isBlocked = openedTarget.target === target ? openedTarget.isMobile : isMobile;
+    useEffect(() => {
+        if (target && isBlocked) {
+            dispatch(uiActions.closeInsightEditor());
+        }
+    }, [dispatch, target, isBlocked]);
+    if (!target || isBlocked) {
+        return null;
+    }
+    // Each target gets its own session, so an open of another target never reuses its state.
+    return _jsx(InsightEditorModal, { target: target }, getTargetKey(target));
+}
+function getTargetKey(target) {
+    return target.type === "widget" || target.type === "insight"
+        ? `${target.type}:${objRefToString(target.ref)}`
+        : target.type;
+}
+function InsightEditorModal({ target }) {
+    const eventDispatch = useDashboardEventDispatch();
+    const session = useInsightEditorSession(target);
+    const closeHandleRef = useRef(null);
+    const intl = useIntl();
+    useEffect(() => {
+        eventDispatch(insightEditorOpened(target));
+    }, [eventDispatch, target]);
+    // No focus trap: Analytical Designer portals its dropdowns and dialogs to the body, out of the
+    // modal. The dialog takes the focus when it mounts, and the focus returns when the editor closes.
+    // The render reads the prior focus: the ref callback moves it before any effect runs.
+    const [previouslyFocused] = useState(() => document.activeElement);
+    const focusDialog = useCallback((dialog) => {
+        dialog?.focus({ preventScroll: true });
+    }, []);
+    useEffect(() => {
+        return () => {
+            if (previouslyFocused instanceof HTMLElement && previouslyFocused.isConnected) {
+                previouslyFocused.focus();
+            }
+        };
+    }, [previouslyFocused]);
+    // Before the AD chunk loads, or when AD fails to start, nothing can confirm the cancellation.
+    const requestClose = useCallback(() => {
+        if (closeHandleRef.current) {
+            closeHandleRef.current.requestClose();
+        }
+        else {
+            session.cancel();
+        }
+    }, [session]);
+    // The Overlay closeOnEscape listens on window with no stack awareness. An Escape meant for nested
+    // AD UI (a filter dropdown, the save dialog) would cancel the whole editing session. Close only
+    // when this overlay is the topmost one, so Escape peels one layer per press.
+    useEffect(() => {
+        const onKeyDown = (e) => {
+            if (e.key === "Escape" && isInsightOverlayTopmost()) {
+                requestClose();
+            }
+        };
+        window.addEventListener("keydown", onKeyDown);
+        return () => window.removeEventListener("keydown", onKeyDown);
+    }, [requestClose]);
+    return (_jsx(OverlayControllerProvider, { overlayController: overlayController, children: _jsx(Overlay, { containerClassName: "gd-insight-editor-overlay", className: "gd-edit-insight-modal-overlay", isModal: true, 
+            // closeOnOutsideClick stops the propagation of the document mousedowns inside the
+            // overlay. AD registers its drag-start listener in the capture phase to survive it.
+            closeOnOutsideClick: true, closeOnEscape: false, ignoreClicksOnByClass: [".s-sort-direction-arrow", ".dash-content"], onClose: requestClose, shouldCloseOnClick: isNotBodyClick, positionType: "fixed", children: _jsx("div", { ref: focusDialog, tabIndex: -1, className: "gd-edit-insight-overlay-content s-edit-insight-overlay-content overlay-move-left", role: "dialog", "aria-modal": "true", "aria-label": intl.formatMessage({ id: "insightEditor.dialog.label" }), children: _jsx(Suspense, { fallback: _jsx(LoadingMask, { height: "100%" }), children: _jsx(LazyInsightEditorContent, { target: target, session: session, closeHandleRef: closeHandleRef }) }) }) }) }));
+}
+// The menu item that opens the overlay leaves the DOM during the click, so the browser retargets the
+// rest of that click to bare <body>. A click meant to close the overlay lands on a real element (the
+// modal mask or a dashboard node), never on bare <body>.
+function isNotBodyClick(e) {
+    return e.target !== document.body;
+}

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

@@ -0,0 +1,10 @@
+import { type ReactNode } from "react";
+import { type InsightPermissionsById } from "./useInsightEditPermissions.js";
+/**
+ * Loads the permissions of the user on the dashboard visualizations once for all widget menus.
+ */
+export declare function InsightEditorPermissionsProvider({ children }: {
+    children?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useInsightEditorPermissions(): InsightPermissionsById | undefined;
+//# sourceMappingURL=InsightEditorPermissionsContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InsightEditorPermissionsContext.d.ts","sourceRoot":"","sources":["../../../src/presentation/insightEditor/InsightEditorPermissionsContext.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAA6B,MAAM,OAAO,CAAC;AAKlE,OAAO,EAAE,KAAK,sBAAsB,EAA6B,MAAM,gCAAgC,CAAC;AAIxG;;GAEG;AACH,wBAAgB,gCAAgC,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,2CAQtF;AAED,wBAAgB,2BAA2B,IAAI,sBAAsB,GAAG,SAAS,CAEhF"}

package/esm/presentation/insightEditor/InsightEditorPermissionsContext.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { createContext, useContext } from "react";
+import { useDashboardSelector } from "../../model/react/DashboardStoreProvider.js";
+import { selectEnableInsightEditing } from "../../model/store/config/configSelectors.js";
+import { useInsightEditPermissions } from "./useInsightEditPermissions.js";
+const InsightEditorPermissionsContext = createContext(undefined);
+/**
+ * Loads the permissions of the user on the dashboard visualizations once for all widget menus.
+ */
+export function InsightEditorPermissionsProvider({ children }) {
+    const isEnabled = useDashboardSelector(selectEnableInsightEditing);
+    const permissions = useInsightEditPermissions(isEnabled);
+    return (_jsx(InsightEditorPermissionsContext.Provider, { value: permissions, children: children }));
+}
+export function useInsightEditorPermissions() {
+    return useContext(InsightEditorPermissionsContext);
+}

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

@@ -0,0 +1,7 @@
+import { type IDashboardWidgetProps } from "../widget/widget/types.js";
+/**
+ * Takes the place of a new insight dropped in the layout. It opens the embedded Analytical Designer
+ * to create the insight.
+ */
+export declare function InsightEditorPlaceholder(_props: IDashboardWidgetProps): null;
+//# sourceMappingURL=InsightEditorPlaceholder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InsightEditorPlaceholder.d.ts","sourceRoot":"","sources":["../../../src/presentation/insightEditor/InsightEditorPlaceholder.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,qBAAqB,GAAG,IAAI,CAO5E"}

package/esm/presentation/insightEditor/InsightEditorPlaceholder.js

@@ -0,0 +1,15 @@
+// (C) 2022-2026 GoodData Corporation
+import { useEffect } from "react";
+import { useDashboardDispatch } from "../../model/react/DashboardStoreProvider.js";
+import { uiActions } from "../../model/store/ui/index.js";
+/**
+ * Takes the place of a new insight dropped in the layout. It opens the embedded Analytical Designer
+ * to create the insight.
+ */
+export function InsightEditorPlaceholder(_props) {
+    const dispatch = useDashboardDispatch();
+    useEffect(() => {
+        dispatch(uiActions.openInsightEditor({ type: "placeholder" }));
+    }, [dispatch]);
+    return null;
+}

package/esm/presentation/insightEditor/filterContext/attributeFilters.d.ts

@@ -0,0 +1,4 @@
+import { type AttributeFilterItem } from "@gooddata/sdk-embedding";
+import { type ICatalogAttribute, type IFilter, type IInsight, type ObjRef } from "@gooddata/sdk-model";
+export declare function getAttributeFilterItems(appliedFilters: IFilter[], insight: IInsight, availableAttributes: ICatalogAttribute[], attributeFilterConfigsDisplayAsLabelMap: Map<string, ObjRef> | undefined, supportsElementUris: boolean): AttributeFilterItem[];
+//# sourceMappingURL=attributeFilters.d.ts.map

package/esm/presentation/insightEditor/filterContext/attributeFilters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributeFilters.d.ts","sourceRoot":"","sources":["../../../../src/presentation/insightEditor/filterContext/attributeFilters.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,mBAAmB,EAI3B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAGH,KAAK,iBAAiB,EACtB,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,KAAK,MAAM,EAWd,MAAM,qBAAqB,CAAC;AAyB7B,wBAAgB,uBAAuB,CACnC,cAAc,EAAE,OAAO,EAAE,EACzB,OAAO,EAAE,QAAQ,EACjB,mBAAmB,EAAE,iBAAiB,EAAE,EACxC,uCAAuC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACxE,mBAAmB,EAAE,OAAO,GAC7B,mBAAmB,EAAE,CAQvB"}

package/esm/presentation/insightEditor/filterContext/attributeFilters.js

@@ -0,0 +1,115 @@
+// (C) 2020-2026 GoodData Corporation
+import { compact } from "lodash-es";
+import { isPositiveAttributeFilter, } from "@gooddata/sdk-embedding";
+import { areObjRefsEqual, filterAttributeElements, filterLocalIdentifier, filterObjRef, insightFilters, isArbitraryAttributeFilter, isAttributeElementsByValue, isAttributeFilter, isMatchAttributeFilter, isNegativeAttributeFilter, } from "@gooddata/sdk-model";
+import { areFiltersWithSameElements, intersectFilters } from "./filterIntersection.js";
+import { toObjIdentifierQualifier } from "./objQualifiers.js";
+function getValidAppliedAttributeFilters(appliedFilters, availableAttributes) {
+    return (appliedFilters
+        .filter(isAttributeFilter)
+        // remove filters not on attributes that are available for the given insight
+        // those are considered invalid
+        .filter((attrFilter) => {
+        const filterDisplayForm = filterObjRef(attrFilter);
+        return availableAttributes.some((available) => {
+            return available.displayForms.some((displayForm) => areObjRefsEqual(displayForm.ref, filterDisplayForm));
+        });
+    }));
+}
+export function getAttributeFilterItems(appliedFilters, insight, availableAttributes, attributeFilterConfigsDisplayAsLabelMap, supportsElementUris) {
+    return getAttributeFilterItemsFromAppliedFilters(getValidAppliedAttributeFilters(appliedFilters, availableAttributes), insightFilters(insight).filter(isAttributeFilter), availableAttributes, attributeFilterConfigsDisplayAsLabelMap, supportsElementUris);
+}
+function getAttributeFilterItemsFromAppliedFilters(appliedFilters, insightAttrFilters, availableAttributes, attributeFilterConfigsDisplayAsLabelMap, supportsElementUris) {
+    const processedFilters = appliedFilters
+        // validate and intersect the dashboard filters with the insight filters
+        .map((attrFilter) => {
+        const filterDisplayForm = filterObjRef(attrFilter);
+        const isInverted = isNegativeAttributeFilter(attrFilter);
+        const selectedElements = filterAttributeElements(attrFilter);
+        const localIdentifier = filterLocalIdentifier(attrFilter);
+        if (isArbitraryAttributeFilter(attrFilter)) {
+            const { label, values, negativeSelection } = attrFilter.arbitraryAttributeFilter;
+            return {
+                arbitraryAttributeFilter: {
+                    displayForm: toObjIdentifierQualifier(label),
+                    values: values,
+                    ...(negativeSelection === undefined ? {} : { negativeSelection }),
+                },
+            };
+        }
+        if (isMatchAttributeFilter(attrFilter)) {
+            const { label, operator, literal, caseSensitive, negativeSelection } = attrFilter.matchAttributeFilter;
+            return {
+                matchAttributeFilter: {
+                    displayForm: toObjIdentifierQualifier(label),
+                    operator,
+                    literal,
+                    ...(caseSensitive === undefined ? {} : { caseSensitive }),
+                    ...(negativeSelection === undefined ? {} : { negativeSelection }),
+                },
+            };
+        }
+        if (isAttributeElementsByValue(selectedElements)) {
+            // effectively skipping insight-based filters by this
+            return undefined;
+        }
+        const filterDisplayAsLabel = localIdentifier
+            ? attributeFilterConfigsDisplayAsLabelMap?.get(localIdentifier)
+            : undefined;
+        // The embedding API types the element lists as strings. The null element passes as it is.
+        const elementUris = [...(selectedElements?.uris ?? [])];
+        const attrFilterContext = isInverted
+            ? {
+                negativeAttributeFilter: {
+                    displayForm: filterDisplayForm,
+                    notIn: elementUris,
+                },
+                ...(filterDisplayAsLabel ? { displayAsLabel: filterDisplayAsLabel } : {}),
+            }
+            : {
+                positiveAttributeFilter: {
+                    displayForm: filterDisplayForm,
+                    in: elementUris,
+                },
+                ...(filterDisplayAsLabel ? { displayAsLabel: filterDisplayAsLabel } : {}),
+            };
+        // Check if the insight contains a filter on the same attribute
+        const insightAttrFilter = getInsightAttrFilter(insightAttrFilters, attrFilter, availableAttributes);
+        if (insightAttrFilter &&
+            !supportsElementUris &&
+            !areObjRefsEqual(filterDisplayForm, filterObjRef(insightAttrFilter))) {
+            // when the display form is different and the backend does not support element uris, skip it and don't transfer the filter
+            // (when uris not supported, we cannot match the elements for filters easily)
+            return undefined;
+        }
+        // If it does, try to merge the two filters so that the resulting elements are the intersection of the two
+        // The intersection might not be possible and return undefined in that case
+        // Only element-based insight filters can be intersected with the dashboard filter
+        return insightAttrFilter &&
+            !isArbitraryAttributeFilter(insightAttrFilter) &&
+            !isMatchAttributeFilter(insightAttrFilter)
+            ? getIntersectedAttrFilterContext(insightAttrFilter, attrFilterContext)
+            : attrFilterContext;
+    });
+    return compact(processedFilters);
+}
+function getInsightAttrFilter(insightAttrFilters, attrFilter, availableAttributes) {
+    const targetDisplayForm = filterObjRef(attrFilter);
+    return insightAttrFilters.find((filterItem) => {
+        const filterItemDisplayForm = filterObjRef(filterItem);
+        const filterItemAttribute = availableAttributes?.find((availableAttribute) => {
+            return availableAttribute.displayForms.some((displayForm) => areObjRefsEqual(displayForm.ref, filterItemDisplayForm));
+        });
+        return filterItemAttribute?.displayForms.some((displayForm) => areObjRefsEqual(displayForm.ref, targetDisplayForm));
+    });
+}
+function getIntersectedAttrFilterContext(insightAttrFilter, attrFilterContext) {
+    const intersectedAttrFilter = intersectFilters(insightAttrFilter, attrFilterContext);
+    const isIntersectedNoop = isPositiveAttributeFilter(intersectedAttrFilter)
+        ? intersectedAttrFilter.positiveAttributeFilter.in.length === 0
+        : false; // strictly speaking, this needs to check whether all the items are selected, however such filter is extremely improbable and not worth the hassle
+    if (isIntersectedNoop || areFiltersWithSameElements(insightAttrFilter, intersectedAttrFilter)) {
+        return undefined;
+    }
+    return intersectedAttrFilter;
+}

package/esm/presentation/insightEditor/filterContext/dateFilters.d.ts

@@ -0,0 +1,5 @@
+import { type DateFilterItem } from "@gooddata/sdk-embedding";
+import { type IDashboardDateFilter, type IFilter, type IInsight, type IWidget } from "@gooddata/sdk-model";
+export declare function getWidgetDateFilterItem(widget: IWidget, dateFilterContextItem: IDashboardDateFilter | undefined): DateFilterItem | undefined;
+export declare function getDateFilterItems(appliedFilters: IFilter[], insight: IInsight): DateFilterItem[];
+//# sourceMappingURL=dateFilters.d.ts.map

package/esm/presentation/insightEditor/filterContext/dateFilters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateFilters.d.ts","sourceRoot":"","sources":["../../../../src/presentation/insightEditor/filterContext/dateFilters.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EACH,KAAK,oBAAoB,EAEzB,KAAK,OAAO,EACZ,KAAK,QAAQ,EAEb,KAAK,OAAO,EAWf,MAAM,qBAAqB,CAAC;AAwC7B,wBAAgB,uBAAuB,CACnC,MAAM,EAAE,OAAO,EACf,qBAAqB,EAAE,oBAAoB,GAAG,SAAS,GACxD,cAAc,GAAG,SAAS,CAK5B;AAoED,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,QAAQ,GAAG,cAAc,EAAE,CAOjG"}

package/esm/presentation/insightEditor/filterContext/dateFilters.js

@@ -0,0 +1,117 @@
+// (C) 2020-2026 GoodData Corporation
+import { absoluteDateFilterValues, areObjRefsEqual, filterObjRef, insightFilters, isAbsoluteDateFilter, isAllTimeDateFilter, isDateFilter, isRelativeDateFilter, relativeDateFilterValues, } from "@gooddata/sdk-model";
+const ALL_TIME_GRANULARITY = "ALL_TIME_GRANULARITY";
+function getDateFilterItem(dataSet, dateFilterContextItem) {
+    if (dateFilterContextItem) {
+        if (dateFilterContextItem.dateFilter.type === "absolute") {
+            return {
+                absoluteDateFilter: {
+                    dataSet,
+                    from: String(dateFilterContextItem.dateFilter.from),
+                    to: String(dateFilterContextItem.dateFilter.to),
+                },
+            };
+        }
+        else {
+            const boundedFilter = dateFilterContextItem.dateFilter.boundedFilter;
+            return {
+                relativeDateFilter: {
+                    dataSet,
+                    granularity: dateFilterContextItem.dateFilter.granularity,
+                    from: Number(dateFilterContextItem.dateFilter.from),
+                    to: Number(dateFilterContextItem.dateFilter.to),
+                    ...(boundedFilter ? { boundedFilter } : {}),
+                },
+            };
+        }
+    }
+    else {
+        return {
+            relativeDateFilter: {
+                dataSet,
+                granularity: ALL_TIME_GRANULARITY,
+                from: -1,
+                to: 1,
+            },
+        };
+    }
+}
+export function getWidgetDateFilterItem(widget, dateFilterContextItem) {
+    if (!widget?.dateDataSet) {
+        return undefined;
+    }
+    return getDateFilterItem(widget.dateDataSet, dateFilterContextItem);
+}
+const sanitizeCorruptedAllTimeFilters = (appliedDateFilter) => {
+    if (!isRelativeDateFilter(appliedDateFilter)) {
+        return appliedDateFilter;
+    }
+    // A corrupted all time filter misses its bounds, although the type requires them.
+    const { from, to, dataSet } = appliedDateFilter.relativeDateFilter;
+    if (from === undefined || to === undefined) {
+        const relativeAllTimeDateFilter = {
+            relativeDateFilter: {
+                dataSet,
+                granularity: ALL_TIME_GRANULARITY,
+                from: 0,
+                to: 0,
+            },
+        };
+        return relativeAllTimeDateFilter;
+    }
+    else {
+        return appliedDateFilter;
+    }
+};
+function getDateFilterContext(dateFilter) {
+    const includeDataSet = true;
+    if (isAllTimeDateFilter(dateFilter)) {
+        const { dataSet } = relativeDateFilterValues(dateFilter, includeDataSet);
+        return {
+            relativeDateFilter: {
+                dataSet,
+                granularity: ALL_TIME_GRANULARITY,
+                from: -1,
+                to: 1,
+            },
+        };
+    }
+    else if (isAbsoluteDateFilter(dateFilter)) {
+        const { dataSet, from, to } = absoluteDateFilterValues(dateFilter, includeDataSet);
+        return {
+            absoluteDateFilter: {
+                dataSet,
+                from,
+                to,
+            },
+        };
+    }
+    else {
+        const { dataSet, from, to, granularity, boundedFilter } = relativeDateFilterValues(dateFilter, includeDataSet);
+        return {
+            relativeDateFilter: {
+                dataSet,
+                granularity,
+                from,
+                to,
+                ...(boundedFilter ? { boundedFilter } : {}),
+            },
+        };
+    }
+}
+export function getDateFilterItems(appliedFilters, insight) {
+    const sanitizedAppliedDateFilters = appliedFilters
+        .filter(isDateFilter)
+        .map(sanitizeCorruptedAllTimeFilters);
+    const insightDateFilters = insightFilters(insight).filter(isDateFilter);
+    return getDateFilterItemsFromAppliedFilters(sanitizedAppliedDateFilters, insightDateFilters);
+}
+function getDateFilterItemsFromAppliedFilters(appliedFilters, insightDateFilters) {
+    const uniqueInsightDateFilters = insightDateFilters.filter((insightDateFilter) => {
+        return !appliedFilters.some((appliedFilter) => {
+            return areObjRefsEqual(filterObjRef(appliedFilter), filterObjRef(insightDateFilter));
+        });
+    });
+    const allDateFilters = [...appliedFilters, ...uniqueInsightDateFilters];
+    return allDateFilters.map((dateFilter) => getDateFilterContext(dateFilter));
+}

package/esm/presentation/insightEditor/filterContext/filterIntersection.d.ts

@@ -0,0 +1,7 @@
+import { type INegativeAttributeFilter as IEmbedNegativeAttributeFilter, type IPositiveAttributeFilter as IEmbedPositiveAttributeFilter } from "@gooddata/sdk-embedding";
+import { type IAttributeFilterWithSelection, type INegativeAttributeFilter, type IPositiveAttributeFilter } from "@gooddata/sdk-model";
+export declare function intersectPositiveWithNegativeAttrFilters(positiveAttrFilter: IPositiveAttributeFilter, negativeAttrFilter: IEmbedNegativeAttributeFilter): IEmbedPositiveAttributeFilter;
+export declare function intersectPositiveWithNegativeAttrFilters2(positiveAttrFilter: IEmbedPositiveAttributeFilter, negativeAttrFilter: INegativeAttributeFilter): IEmbedPositiveAttributeFilter;
+export declare function intersectFilters(insightAttrFilter: IAttributeFilterWithSelection, attrFilterContext: IEmbedPositiveAttributeFilter | IEmbedNegativeAttributeFilter): IEmbedPositiveAttributeFilter | IEmbedNegativeAttributeFilter;
+export declare function areFiltersWithSameElements(insightAttrFilter: IAttributeFilterWithSelection, attrFilterContext: IEmbedPositiveAttributeFilter | IEmbedNegativeAttributeFilter): boolean;
+//# sourceMappingURL=filterIntersection.d.ts.map