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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"filterIntersection.d.ts","sourceRoot":"","sources":["../../../../src/presentation/insightEditor/filterContext/filterIntersection.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,wBAAwB,IAAI,6BAA6B,EAC9D,KAAK,wBAAwB,IAAI,6BAA6B,EAGjE,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEH,KAAK,6BAA6B,EAClC,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAUhC,MAAM,qBAAqB,CAAC;AAQ7B,wBAAgB,wCAAwC,CACpD,kBAAkB,EAAE,wBAAwB,EAC5C,kBAAkB,EAAE,6BAA6B,GAClD,6BAA6B,CAiC/B;AAED,wBAAgB,yCAAyC,CACrD,kBAAkB,EAAE,6BAA6B,EACjD,kBAAkB,EAAE,wBAAwB,GAC7C,6BAA6B,CA0B/B;AACD,wBAAgB,gBAAgB,CAC5B,iBAAiB,EAAE,6BAA6B,EAChD,iBAAiB,EAAE,6BAA6B,GAAG,6BAA6B,GACjF,6BAA6B,GAAG,6BAA6B,CA+D/D;AAED,wBAAgB,0BAA0B,CACtC,iBAAiB,EAAE,6BAA6B,EAChD,iBAAiB,EAAE,6BAA6B,GAAG,6BAA6B,GACjF,OAAO,CAsDT"}

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

@@ -0,0 +1,149 @@
+// (C) 2007-2026 GoodData Corporation
+import { uniq } from "lodash-es";
+import { isNegativeAttributeFilter as isEmbedNegativeAttributeFilter, isPositiveAttributeFilter as isEmbedPositiveAttributeFilter, } from "@gooddata/sdk-embedding";
+import { filterAttributeElements, filterIsEmpty, isAttributeElementsByRef, isAttributeElementsByValue, isNegativeAttributeFilter, isObjRef, isPositiveAttributeFilter, newNegativeAttributeFilter, newPositiveAttributeFilter, } from "@gooddata/sdk-model";
+// The embedding API types the element lists as strings. The null element (an empty value) passes
+// through as it is.
+function elementIds(elements) {
+    return (isAttributeElementsByRef(elements) ? elements.uris : elements.values);
+}
+export function intersectPositiveWithNegativeAttrFilters(positiveAttrFilter, negativeAttrFilter) {
+    const normalizedPositiveAttrFilter = normalizeEmptyFilterElements(positiveAttrFilter);
+    const attributeElements = normalizedPositiveAttrFilter.positiveAttributeFilter.in;
+    //NOTE: Currently in dashboard filters we are not support local identifiers, so we can safely assume that
+    // that displayForm is ObjRef
+    if (!isObjRef(normalizedPositiveAttrFilter.positiveAttributeFilter.displayForm)) {
+        throw new Error("Expected positive attribute filter display form to be ObjRef");
+    }
+    if (!isAttributeElementsByRef(attributeElements)) {
+        return {
+            positiveAttributeFilter: {
+                displayForm: normalizedPositiveAttrFilter.positiveAttributeFilter.displayForm,
+                in: elementIds(attributeElements).filter((identifier) => !negativeAttrFilter.negativeAttributeFilter.notIn.includes(identifier)),
+            },
+        };
+    }
+    return {
+        positiveAttributeFilter: {
+            displayForm: normalizedPositiveAttrFilter.positiveAttributeFilter.displayForm,
+            in: elementIds(attributeElements).filter((uri) => !negativeAttrFilter.negativeAttributeFilter.notIn.includes(uri)),
+        },
+    };
+}
+export function intersectPositiveWithNegativeAttrFilters2(positiveAttrFilter, negativeAttrFilter) {
+    const normalizedNegativeAttrFilter = normalizeEmptyFilterElements(negativeAttrFilter);
+    const attributeElements = normalizedNegativeAttrFilter.negativeAttributeFilter.notIn;
+    if (!isAttributeElementsByRef(attributeElements)) {
+        return {
+            positiveAttributeFilter: {
+                displayForm: positiveAttrFilter.positiveAttributeFilter.displayForm,
+                in: positiveAttrFilter.positiveAttributeFilter.in.filter((identifier) => !elementIds(attributeElements).includes(identifier)),
+            },
+        };
+    }
+    return {
+        positiveAttributeFilter: {
+            displayForm: positiveAttrFilter.positiveAttributeFilter.displayForm,
+            in: positiveAttrFilter.positiveAttributeFilter.in.filter((uri) => !elementIds(attributeElements).includes(uri)),
+        },
+    };
+}
+export function intersectFilters(insightAttrFilter, attrFilterContext) {
+    const normalizedInsightAttrFilter = normalizeEmptyFilterElements(insightAttrFilter);
+    const attributeElements = filterAttributeElements(normalizedInsightAttrFilter);
+    if (!isAttributeElementsByRef(attributeElements)) {
+        if (isPositiveAttributeFilter(normalizedInsightAttrFilter)) {
+            if (isEmbedPositiveAttributeFilter(attrFilterContext)) {
+                return {
+                    positiveAttributeFilter: {
+                        displayForm: attrFilterContext.positiveAttributeFilter.displayForm,
+                        in: attrFilterContext.positiveAttributeFilter.in.filter((identifier) => elementIds(attributeElements).includes(identifier)),
+                    },
+                };
+            }
+            return intersectPositiveWithNegativeAttrFilters(normalizedInsightAttrFilter, attrFilterContext);
+        }
+        else {
+            if (isEmbedNegativeAttributeFilter(attrFilterContext)) {
+                return {
+                    negativeAttributeFilter: {
+                        displayForm: attrFilterContext.negativeAttributeFilter.displayForm,
+                        notIn: uniq(elementIds(attributeElements).concat(attrFilterContext.negativeAttributeFilter.notIn)),
+                    },
+                };
+            }
+            return intersectPositiveWithNegativeAttrFilters2(attrFilterContext, normalizedInsightAttrFilter);
+        }
+    }
+    if (isPositiveAttributeFilter(normalizedInsightAttrFilter)) {
+        if (isEmbedPositiveAttributeFilter(attrFilterContext)) {
+            return {
+                positiveAttributeFilter: {
+                    displayForm: attrFilterContext.positiveAttributeFilter.displayForm,
+                    in: attrFilterContext.positiveAttributeFilter.in.filter((uri) => elementIds(attributeElements).includes(uri)),
+                },
+            };
+        }
+        return intersectPositiveWithNegativeAttrFilters(normalizedInsightAttrFilter, attrFilterContext);
+    }
+    else {
+        if (isEmbedNegativeAttributeFilter(attrFilterContext)) {
+            return {
+                negativeAttributeFilter: {
+                    displayForm: attrFilterContext.negativeAttributeFilter.displayForm,
+                    notIn: uniq(elementIds(attributeElements).concat(attrFilterContext.negativeAttributeFilter.notIn)),
+                },
+            };
+        }
+        return intersectPositiveWithNegativeAttrFilters2(attrFilterContext, normalizedInsightAttrFilter);
+    }
+}
+export function areFiltersWithSameElements(insightAttrFilter, attrFilterContext) {
+    const normalizedInsightAttrFilter = normalizeEmptyFilterElements(insightAttrFilter);
+    const attributeElements = filterAttributeElements(normalizedInsightAttrFilter);
+    if (!isAttributeElementsByRef(attributeElements)) {
+        if (isPositiveAttributeFilter(normalizedInsightAttrFilter) &&
+            isEmbedPositiveAttributeFilter(attrFilterContext)) {
+            return (elementIds(attributeElements).length ===
+                attrFilterContext.positiveAttributeFilter.in.length &&
+                elementIds(attributeElements).every((identifier) => attrFilterContext.positiveAttributeFilter.in.includes(identifier)));
+        }
+        else if (isNegativeAttributeFilter(normalizedInsightAttrFilter) &&
+            isEmbedNegativeAttributeFilter(attrFilterContext)) {
+            return (elementIds(attributeElements).length ===
+                attrFilterContext.negativeAttributeFilter.notIn.length &&
+                elementIds(attributeElements).every((identifier) => attrFilterContext.negativeAttributeFilter.notIn.includes(identifier)));
+        }
+        return false;
+    }
+    if (isPositiveAttributeFilter(normalizedInsightAttrFilter) &&
+        isEmbedPositiveAttributeFilter(attrFilterContext)) {
+        return (elementIds(attributeElements).length === attrFilterContext.positiveAttributeFilter.in.length &&
+            elementIds(attributeElements).every((uri) => attrFilterContext.positiveAttributeFilter.in.includes(uri)));
+    }
+    else if (isNegativeAttributeFilter(normalizedInsightAttrFilter) &&
+        isEmbedNegativeAttributeFilter(attrFilterContext)) {
+        return (elementIds(attributeElements).length === attrFilterContext.negativeAttributeFilter.notIn.length &&
+            elementIds(attributeElements).every((uri) => attrFilterContext.negativeAttributeFilter.notIn.includes(uri)));
+    }
+    return false;
+}
+/**
+ * Empty attribute filters by value and by uri are same, so we want to sometimes normalize them to uris.
+ * If filter is not empty it can't be normalized, so same filter is returned
+ * @param filter -
+ * @returns empty filter with uri elements or original filter
+ */
+function normalizeEmptyFilterElements(filter) {
+    const attributeElements = filterAttributeElements(filter);
+    if (filterIsEmpty(filter) && isAttributeElementsByValue(attributeElements)) {
+        if (isPositiveAttributeFilter(filter) && isObjRef(filter.positiveAttributeFilter.displayForm)) {
+            return newPositiveAttributeFilter(filter.positiveAttributeFilter.displayForm, { uris: [] });
+        }
+        if (isNegativeAttributeFilter(filter) && isObjRef(filter.negativeAttributeFilter.displayForm)) {
+            return newNegativeAttributeFilter(filter.negativeAttributeFilter.displayForm, { uris: [] });
+        }
+        throw new Error("Invariant: expected positive or negative filter");
+    }
+    return filter;
+}