@gooddata/sdk-ui-dashboard 11.65.0-alpha.8 → 11.65.0

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;
+}

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

@@ -0,0 +1,26 @@
+import { type IAnalyticalBackend, type IBackendCapabilities } from "@gooddata/sdk-backend-spi";
+import { type AttributeFilterItem, type DateFilterItem, type IMeasureValueFilter as IEmbeddingMeasureValueFilter } from "@gooddata/sdk-embedding";
+import { type ICatalogAttribute, type IDashboardDateFilter, type IDashboardMeasureValueFilter, type IFilter, type IInsight, type IInsightWidget, type ObjRef } from "@gooddata/sdk-model";
+export type InsightEditorFilterItem = DateFilterItem | AttributeFilterItem | IEmbeddingMeasureValueFilter;
+export interface IInsightEditorFilterContextInput {
+    widget: IInsightWidget;
+    insight: IInsight;
+    appliedFilters: IFilter[];
+    availableAttributes: ICatalogAttribute[];
+    attributeFilterConfigsDisplayAsLabelMap: Map<string, ObjRef> | undefined;
+    capabilities: IBackendCapabilities;
+    dateFilter: IDashboardDateFilter | undefined;
+    isMeasureValueFilterEnabled: boolean;
+    measureValueFilters: IDashboardMeasureValueFilter[];
+}
+/**
+ * Builds the filters that the explore flow passes to Analytical Designer, so the explored insight
+ * shows the same data as the widget on the dashboard.
+ */
+export declare function buildInsightEditorFilterContext(input: IInsightEditorFilterContextInput): InsightEditorFilterItem[];
+/**
+ * Loads the attributes that can filter the insight. Dashboard filters on other attributes do not
+ * pass to Analytical Designer.
+ */
+export declare function loadInsightAvailableAttributes(backend: IAnalyticalBackend, workspace: string, insight: IInsight, enableComputedAttributes: boolean): Promise<ICatalogAttribute[]>;
+//# sourceMappingURL=insightFilterContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"insightFilterContext.d.ts","sourceRoot":"","sources":["../../../../src/presentation/insightEditor/filterContext/insightFilterContext.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAC/F,OAAO,EACH,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,mBAAmB,IAAI,4BAA4B,EAC3D,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACH,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,4BAA4B,EACjC,KAAK,OAAO,EACZ,KAAK,QAAQ,EAEb,KAAK,cAAc,EACnB,KAAK,MAAM,EAEd,MAAM,qBAAqB,CAAC;AAQ7B,MAAM,MAAM,uBAAuB,GAAG,cAAc,GAAG,mBAAmB,GAAG,4BAA4B,CAAC;AAE1G,MAAM,WAAW,gCAAgC;IAC7C,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,QAAQ,CAAC;IAClB,cAAc,EAAE,OAAO,EAAE,CAAC;IAC1B,mBAAmB,EAAE,iBAAiB,EAAE,CAAC;IACzC,uCAAuC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACzE,YAAY,EAAE,oBAAoB,CAAC;IACnC,UAAU,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAC7C,2BAA2B,EAAE,OAAO,CAAC;IACrC,mBAAmB,EAAE,4BAA4B,EAAE,CAAC;CACvD;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC3C,KAAK,EAAE,gCAAgC,GACxC,uBAAuB,EAAE,CAoB3B;AAKD;;;GAGG;AACH,wBAAsB,8BAA8B,CAChD,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,QAAQ,EACjB,wBAAwB,EAAE,OAAO,GAClC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAa9B"}

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

@@ -0,0 +1,72 @@
+// (C) 2020-2026 GoodData Corporation
+import { compact } from "lodash-es";
+import { catalogComputedAttributeAsCatalogAttribute, } from "@gooddata/sdk-model";
+import { isComputedAttributesUnavailableError } from "../../../_staging/catalog/computedAttributes.js";
+import { getAttributeFilterItems } from "./attributeFilters.js";
+import { getDateFilterItems, getWidgetDateFilterItem } from "./dateFilters.js";
+import { filterDashboardMvfsForWidget, toMeasureValueFilterItems } from "./measureValueFilters.js";
+/**
+ * Builds the filters that the explore flow passes to Analytical Designer, so the explored insight
+ * shows the same data as the widget on the dashboard.
+ */
+export function buildInsightEditorFilterContext(input) {
+    const { widget, insight, appliedFilters, capabilities } = input;
+    const attributeFilters = getAttributeFilterItems(appliedFilters, insight, input.availableAttributes, input.attributeFilterConfigsDisplayAsLabelMap, !!capabilities.supportsElementUris);
+    const measureValueFilters = input.isMeasureValueFilterEnabled
+        ? toMeasureValueFilterItems(filterDashboardMvfsForWidget(widget, input.measureValueFilters, insight))
+        : [];
+    const dateFilters = capabilities.supportsMultipleDateFilters
+        ? getDateFilterItems(appliedFilters, insight)
+        : compact([getWidgetDateFilterItem(widget, input.dateFilter)]);
+    return [...dateFilters, ...attributeFilters, ...measureValueFilters];
+}
+// The production dataset needs no ref. Its presence is represented by undefined.
+const PRODUCTION_DATASET_REF = undefined;
+/**
+ * Loads the attributes that can filter the insight. Dashboard filters on other attributes do not
+ * pass to Analytical Designer.
+ */
+export async function loadInsightAvailableAttributes(backend, workspace, insight, enableComputedAttributes) {
+    const nonDateDataSetRefs = await getNonDateDataSetRefs(backend, workspace, insight);
+    // Computed attributes load separately, so they can never fail a plain attributes request.
+    // The listing is skipped when the setting is off: the backend then refuses it (400).
+    const loads = [
+        ...nonDateDataSetRefs.map((dataSetRef) => loadDataSetAttributes(backend, workspace, dataSetRef, insight)),
+        ...(enableComputedAttributes ? [loadComputedAttributes(backend, workspace, insight)] : []),
+    ];
+    const attributesPerDataSet = await Promise.all(loads);
+    return attributesPerDataSet.flat();
+}
+async function getNonDateDataSetRefs(backend, workspace, insight) {
+    if (!backend.capabilities.supportsNonProductionDatasets) {
+        return [PRODUCTION_DATASET_REF];
+    }
+    const referencedObjects = await backend
+        .workspace(workspace)
+        .insights()
+        .getInsightReferencedObjects(insight, ["dataSet"]);
+    const dataSetMeta = referencedObjects.dataSetMeta ?? [];
+    const nonProductionRefs = dataSetMeta.filter((meta) => !meta.production).map((meta) => meta.ref);
+    const containsProduction = dataSetMeta.some((meta) => meta.production);
+    return containsProduction ? [PRODUCTION_DATASET_REF, ...nonProductionRefs] : nonProductionRefs;
+}
+async function loadDataSetAttributes(backend, workspace, dataSetRef, insight) {
+    const loader = backend.workspace(workspace).catalog().forTypes(["attribute"]);
+    const catalog = await (dataSetRef ? loader.forDataset(dataSetRef) : loader.withOptions({ production: true })).load();
+    const availableItems = await catalog.availableItems().forInsight(insight).load();
+    return availableItems.availableAttributes();
+}
+async function loadComputedAttributes(backend, workspace, insight) {
+    try {
+        const catalog = await backend.workspace(workspace).catalog().forTypes(["computedAttribute"]).load();
+        const availableItems = await catalog.availableItems().forInsight(insight).load();
+        return availableItems.availableComputedAttributes().map(catalogComputedAttributeAsCatalogAttribute);
+    }
+    catch (error) {
+        // Degrade only when computed attributes are not available. A genuine failure propagates.
+        if (isComputedAttributesUnavailableError(error)) {
+            return [];
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +1,20 @@
+import { type IMeasureValueFilter as IEmbeddingMeasureValueFilter } from "@gooddata/sdk-embedding";
+import { type IDashboardMeasureValueFilter, type IInsight, type IInsightWidget } from "@gooddata/sdk-model";
+/**
+ * Drops dashboard MVFs the widget is configured to ignore (mirrors `resolveDashboardMeasureValueFilters`
+ * in `queryWidgetFilters`) and emits a `console.warn` when the insight already has its own MVF on the
+ * same metric. The dashboard MVF is still emitted in the overlap case — both filters apply via logical
+ * AND at execution and warning keeps parity with that runtime behavior so the embedding caller can
+ * observe the clash without changing semantics.
+ */
+export declare function filterDashboardMvfsForWidget(widget: IInsightWidget, dashboardMvfs: IDashboardMeasureValueFilter[], insight: IInsight | undefined): IDashboardMeasureValueFilter[];
+/**
+ * Converts dashboard measure value filters to the embedding {@link IEmbeddingMeasureValueFilter}
+ * format used by the AD `SetFilterContext` command. The target measure is forwarded as the
+ * catalog identifier (Tiger; URI refs are unsupported and such MVFs are skipped). Each filter
+ * carries its dashboard `localIdentifier` so AD can disambiguate individual filter instances
+ * (currently the dashboard model permits at most one MVF per metric, but `localIdentifier`
+ * is part of the contract in preparation for multi-MVF-per-metric support).
+ */
+export declare function toMeasureValueFilterItems(dashboardMvfs: IDashboardMeasureValueFilter[]): IEmbeddingMeasureValueFilter[];
+//# sourceMappingURL=measureValueFilters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"measureValueFilters.d.ts","sourceRoot":"","sources":["../../../../src/presentation/insightEditor/filterContext/measureValueFilters.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,mBAAmB,IAAI,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AACnG,OAAO,EACH,KAAK,4BAA4B,EACjC,KAAK,QAAQ,EACb,KAAK,cAAc,EAetB,MAAM,qBAAqB,CAAC;AAkB7B;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CACxC,MAAM,EAAE,cAAc,EACtB,aAAa,EAAE,4BAA4B,EAAE,EAC7C,OAAO,EAAE,QAAQ,GAAG,SAAS,GAC9B,4BAA4B,EAAE,CAgChC;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACrC,aAAa,EAAE,4BAA4B,EAAE,GAC9C,4BAA4B,EAAE,CAmBhC"}

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

@@ -0,0 +1,76 @@
+// (C) 2026 GoodData Corporation
+import { areObjRefsEqual, dashboardFilterObjRef, insightFilters, insightMeasures, isDashboardMeasureValueFilterReference, isIdentifierRef, isLocalIdRef, isMeasureValueFilter, measureItem, measureLocalId, measureValueFilterMeasure, objRefToString, } from "@gooddata/sdk-model";
+/**
+ * Resolves the metric ObjRef behind an insight MVF's measure reference. Insight MVFs reference
+ * their target measure either directly (`ObjRef`) or via a bucket-local id (`LocalIdRef`); the
+ * latter must be looked up in the insight's measures and mapped to the catalog `ObjRef` carried
+ * on the simple measure definition. Returns `undefined` when the local id does not resolve or
+ * the matched measure is non-simple (arithmetic, previous-period, …) and therefore has no LDM
+ * item to compare against.
+ */
+function resolveInsightMvfMetric(ref, insight) {
+    if (!isLocalIdRef(ref)) {
+        return ref;
+    }
+    const matched = insightMeasures(insight).find((m) => measureLocalId(m) === ref.localIdentifier);
+    return matched ? measureItem(matched) : undefined;
+}
+/**
+ * Drops dashboard MVFs the widget is configured to ignore (mirrors `resolveDashboardMeasureValueFilters`
+ * in `queryWidgetFilters`) and emits a `console.warn` when the insight already has its own MVF on the
+ * same metric. The dashboard MVF is still emitted in the overlap case — both filters apply via logical
+ * AND at execution and warning keeps parity with that runtime behavior so the embedding caller can
+ * observe the clash without changing semantics.
+ */
+export function filterDashboardMvfsForWidget(widget, dashboardMvfs, insight) {
+    const ignoredRefs = widget.ignoreDashboardFilters?.filter(isDashboardMeasureValueFilterReference) ?? [];
+    const widgetEffective = ignoredRefs.length === 0
+        ? dashboardMvfs
+        : dashboardMvfs.filter((mvf) => !ignoredRefs.some((ref) => areObjRefsEqual(ref.measure, dashboardFilterObjRef(mvf))));
+    // Insight MVFs may reference their measure by LocalIdRef (bucket-local) — resolve those to the
+    // catalog ObjRef via the insight's measures so we can compare against dashboard MVFs (which
+    // always reference the catalog metric directly).
+    const insightMvfMetrics = insight
+        ? insightFilters(insight)
+            .filter(isMeasureValueFilter)
+            .map((f) => resolveInsightMvfMetric(measureValueFilterMeasure(f), insight))
+            .filter((ref) => ref !== undefined)
+        : [];
+    if (insightMvfMetrics.length > 0) {
+        widgetEffective.forEach((mvf) => {
+            const dashMeasure = dashboardFilterObjRef(mvf);
+            if (insightMvfMetrics.some((m) => areObjRefsEqual(m, dashMeasure))) {
+                console.warn(`Dashboard MVF on metric ${objRefToString(dashMeasure)} overlaps with an insight-level MVF on the same metric; both will be transferred to AD and applied together.`);
+            }
+        });
+    }
+    return widgetEffective;
+}
+/**
+ * Converts dashboard measure value filters to the embedding {@link IEmbeddingMeasureValueFilter}
+ * format used by the AD `SetFilterContext` command. The target measure is forwarded as the
+ * catalog identifier (Tiger; URI refs are unsupported and such MVFs are skipped). Each filter
+ * carries its dashboard `localIdentifier` so AD can disambiguate individual filter instances
+ * (currently the dashboard model permits at most one MVF per metric, but `localIdentifier`
+ * is part of the contract in preparation for multi-MVF-per-metric support).
+ */
+export function toMeasureValueFilterItems(dashboardMvfs) {
+    if (!dashboardMvfs.length) {
+        return [];
+    }
+    return dashboardMvfs.flatMap((mvf) => {
+        const { measure, localIdentifier, conditions } = mvf.dashboardMeasureValueFilter;
+        if (!isIdentifierRef(measure)) {
+            return [];
+        }
+        return [
+            {
+                measureValueFilter: {
+                    measure: { identifier: measure.identifier },
+                    localIdentifier,
+                    ...(conditions && conditions.length > 0 ? { conditions } : {}),
+                },
+            },
+        ];
+    });
+}

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

@@ -0,0 +1,11 @@
+import { type IObjIdentifierQualifier } from "@gooddata/sdk-embedding";
+import { type ObjRef } from "@gooddata/sdk-model";
+/**
+ * Converts a model ref to the identifier qualifier of the embedding API.
+ *
+ * The ref type is kept: it is the only thing telling a computed attribute reference from a label
+ * reference (a computed attribute has no labels and is referenced directly), so dropping it would make
+ * a filter on a computed attribute indistinguishable from a filter on a label of the same identifier.
+ */
+export declare function toObjIdentifierQualifier(ref: ObjRef): IObjIdentifierQualifier;
+//# sourceMappingURL=objQualifiers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"objQualifiers.d.ts","sourceRoot":"","sources":["../../../../src/presentation/insightEditor/filterContext/objQualifiers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,EAAE,KAAK,MAAM,EAAmB,MAAM,qBAAqB,CAAC;AAEnE;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,uBAAuB,CAQ7E"}

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

@@ -0,0 +1,18 @@
+// (C) 2026 GoodData Corporation
+import { isIdentifierRef } from "@gooddata/sdk-model";
+/**
+ * Converts a model ref to the identifier qualifier of the embedding API.
+ *
+ * The ref type is kept: it is the only thing telling a computed attribute reference from a label
+ * reference (a computed attribute has no labels and is referenced directly), so dropping it would make
+ * a filter on a computed attribute indistinguishable from a filter on a label of the same identifier.
+ */
+export function toObjIdentifierQualifier(ref) {
+    if (isIdentifierRef(ref)) {
+        return {
+            identifier: ref.identifier,
+            ...(ref.type ? { type: ref.type } : {}),
+        };
+    }
+    throw new Error("Expected identifier ref");
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Tells whether the insight overlay is the TOPMOST open ui-kit overlay in the document.
+ *
+ * With AD running in-process, its nested UI (filter dropdowns, save dialogs, tooltips) portals
+ * into the same document as this overlay. Every ui-kit Overlay with closeOnEscape listens on
+ * window with no stack awareness, so a single Escape aimed at a nested AD dropdown would also
+ * cancel the whole editing session (the iframe transport used to shield this — AD key events
+ * never left the iframe document). That is why the insight overlay handles Escape itself, gated
+ * by this check.
+ *
+ * Overlay portals append to document.body in mount order, so the last .gd-overlay-content node is
+ * the topmost overlay; the insight overlay may only close itself when that node is its own.
+ * Nested overlays unmount asynchronously (React re-render), so during the very Escape press that
+ * closes a nested overlay this still sees its node and correctly skips — Escape peels one layer
+ * per press.
+ */
+export declare function isInsightOverlayTopmost(doc?: Document): boolean;
+//# sourceMappingURL=insightEditorEscapeGuard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"insightEditorEscapeGuard.d.ts","sourceRoot":"","sources":["../../../src/presentation/insightEditor/insightEditorEscapeGuard.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,GAAE,QAAmB,GAAG,OAAO,CAIzE"}

package/esm/presentation/insightEditor/insightEditorEscapeGuard.js

@@ -0,0 +1,24 @@
+// (C) 2026 GoodData Corporation
+const OVERLAY_CONTENT_SELECTOR = ".gd-overlay-content";
+const INSIGHT_OVERLAY_CONTENT_SELECTOR = ".s-edit-insight-overlay-content";
+/**
+ * Tells whether the insight overlay is the TOPMOST open ui-kit overlay in the document.
+ *
+ * With AD running in-process, its nested UI (filter dropdowns, save dialogs, tooltips) portals
+ * into the same document as this overlay. Every ui-kit Overlay with closeOnEscape listens on
+ * window with no stack awareness, so a single Escape aimed at a nested AD dropdown would also
+ * cancel the whole editing session (the iframe transport used to shield this — AD key events
+ * never left the iframe document). That is why the insight overlay handles Escape itself, gated
+ * by this check.
+ *
+ * Overlay portals append to document.body in mount order, so the last .gd-overlay-content node is
+ * the topmost overlay; the insight overlay may only close itself when that node is its own.
+ * Nested overlays unmount asynchronously (React re-render), so during the very Escape press that
+ * closes a nested overlay this still sees its node and correctly skips — Escape peels one layer
+ * per press.
+ */
+export function isInsightOverlayTopmost(doc = document) {
+    const contents = doc.querySelectorAll(OVERLAY_CONTENT_SELECTOR);
+    const topmost = contents[contents.length - 1];
+    return !!topmost?.querySelector(INSIGHT_OVERLAY_CONTENT_SELECTOR);
+}

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

@@ -0,0 +1,34 @@
+import { type ObjRef } from "@gooddata/sdk-model";
+import { type InsightEditorTarget } from "../../model/types/insightEditorTypes.js";
+type HiddenAction = "open" | "clear" | "export" | "save" | "saveAs" | "openInAnalyticalDesigner";
+export interface IInsightEditorRouteInput {
+    target: InsightEditorTarget;
+    /**
+     * The insight of the widget target. Undefined for the other targets, or when the widget has no
+     * insight.
+     */
+    widgetInsightRef: ObjRef | undefined;
+    isWidgetInsightLocked: boolean;
+    dashboardId: string | undefined;
+    isEditMode: boolean;
+    isEmbedded: boolean;
+    canManageWorkspace: boolean;
+    canCreateVisualization: boolean;
+}
+/**
+ * The part of the Analytical Designer props that selects the flow: edit, explore or create.
+ */
+export interface IInsightEditorRoute {
+    insight: ObjRef | undefined;
+    config: {
+        isEmbedded: boolean;
+        hiddenActions: HiddenAction[];
+        displayedActions?: Array<"cancel">;
+        sourceDashboard?: string;
+        sourceInsight?: ObjRef;
+        allowDashboardLinks?: boolean;
+    };
+}
+export declare function getInsightEditorRoute(input: IInsightEditorRouteInput): IInsightEditorRoute;
+export {};
+//# sourceMappingURL=insightEditorRoute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"insightEditorRoute.d.ts","sourceRoot":"","sources":["../../../src/presentation/insightEditor/insightEditorRoute.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAEnF,KAAK,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,0BAA0B,CAAC;AAEjG,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE,mBAAmB,CAAC;IAC5B;;;OAGG;IACH,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,qBAAqB,EAAE,OAAO,CAAC;IAC/B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,sBAAsB,EAAE,OAAO,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,MAAM,EAAE;QACJ,UAAU,EAAE,OAAO,CAAC;QACpB,aAAa,EAAE,YAAY,EAAE,CAAC;QAC9B,gBAAgB,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;QACnC,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;KACjC,CAAC;CACL;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,wBAAwB,GAAG,mBAAmB,CAiD1F"}