@gooddata/sdk-ui-dashboard 11.58.0-alpha.1 → 11.58.0-alpha.3

package/esm/model/commandHandlers/parameters/filterParameterDependenciesWorker.d.ts

@@ -0,0 +1,45 @@
+import { type SagaIterator } from "redux-saga";
+import { type DashboardContext } from "../../types/commonTypes.js";
+/**
+ * Keeps the dashboard-filter → parameter dependency map complete as the filter contexts change.
+ *
+ * @remarks
+ * Counterpart of {@link newInsightParameterDependenciesWorker} for dashboard filters. After any write
+ * to the tabs slice it collects the objects the current filters of every tab read and loads the ones
+ * the map does not know yet, so a widget picks up a parameter it now depends on through a filter added
+ * or changed after initialization (edit mode, an applied filter view, a new tab). Removing a filter
+ * needs nothing: the map is keyed by the object a filter reads, not by the filter, and a widget only
+ * consults the entries of the filters it currently has. A failed load leaves the map as it is, so the
+ * dependencies known so far stay in effect; the failed roots are not retried until the map is
+ * initialized again (a dashboard reload), so a filter on an object the graph rejects does not trigger a
+ * request on every later write.
+ */
+export declare function newFilterParameterDependenciesWorker(): (ctx: DashboardContext) => SagaIterator<void>;
+/**
+ * The roots one store has already requested but that are not in the map: those in flight and those whose
+ * request failed. Neither is requested again until {@link IFilterParameterRootTracker.reset}, which also
+ * starts a new generation so that a request still in flight from before the reset is discarded on
+ * completion instead of writing into the freshly initialized map.
+ *
+ * @internal
+ */
+export interface IFilterParameterRootTracker {
+    pending: Set<string>;
+    failed: Set<string>;
+    generation: number;
+    reset(): void;
+}
+/**
+ * @internal
+ */
+export declare function newFilterParameterRootTracker(): IFilterParameterRootTracker;
+/**
+ * Loads the dependencies of the filter roots the map does not know yet. A root is requested at most once
+ * between two initializations of the map: one in flight is skipped by the handlers that run meanwhile,
+ * and one the graph rejected (a deleted or forbidden object, typically) is remembered by the tracker
+ * rather than retried on every later write to the tabs slice. Only real results reach the map.
+ *
+ * @internal
+ */
+export declare function registerFilterParameterDependencies(ctx: DashboardContext, tracker: IFilterParameterRootTracker): SagaIterator<void>;
+//# sourceMappingURL=filterParameterDependenciesWorker.d.ts.map

package/esm/model/commandHandlers/parameters/filterParameterDependenciesWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterParameterDependenciesWorker.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/parameters/filterParameterDependenciesWorker.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAa/C,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AASnE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oCAAoC,UACQ,gBAAgB,KAAG,YAAY,CAAC,IAAI,CAAC,CAShG;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,2BAA2B;IACxC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACrB,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,IAAI,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,6BAA6B,IAAI,2BAA2B,CAa3E;AAED;;;;;;;GAOG;AACH,wBAAiB,mCAAmC,CAChD,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,2BAA2B,GACrC,YAAY,CAAC,IAAI,CAAC,CAuCpB"}

package/esm/model/commandHandlers/parameters/filterParameterDependenciesWorker.js

@@ -0,0 +1,99 @@
+// (C) 2026 GoodData Corporation
+import { call, put, select, takeEvery } from "redux-saga/effects";
+import { serializeObjRef } from "@gooddata/sdk-model";
+import { selectCatalogFilterParameters, selectCatalogFilterParametersStatus, } from "../../store/catalog/catalogSelectors.js";
+import { catalogActions } from "../../store/catalog/index.js";
+import { selectFiltersByTab } from "../../store/tabs/filterContext/filterContextSelectors.js";
+import { tabsActions } from "../../store/tabs/index.js";
+import { collectFilterParameterRoots } from "../../store/tabs/parameters/parametersHelpers.js";
+import { unbatched } from "./insightParameterDependenciesWorker.js";
+import { loadReachableParameterMap } from "./loadInsightParameterDependencies.js";
+// every filter context write is a `tabs/*` action (the filter contexts live in the tabs slice)
+const TABS_ACTION_PREFIX = `${tabsActions.setTabs.type.split("/")[0]}/`;
+/**
+ * Keeps the dashboard-filter → parameter dependency map complete as the filter contexts change.
+ *
+ * @remarks
+ * Counterpart of {@link newInsightParameterDependenciesWorker} for dashboard filters. After any write
+ * to the tabs slice it collects the objects the current filters of every tab read and loads the ones
+ * the map does not know yet, so a widget picks up a parameter it now depends on through a filter added
+ * or changed after initialization (edit mode, an applied filter view, a new tab). Removing a filter
+ * needs nothing: the map is keyed by the object a filter reads, not by the filter, and a widget only
+ * consults the entries of the filters it currently has. A failed load leaves the map as it is, so the
+ * dependencies known so far stay in effect; the failed roots are not retried until the map is
+ * initialized again (a dashboard reload), so a filter on an object the graph rejects does not trigger a
+ * request on every later write.
+ */
+export function newFilterParameterDependenciesWorker() {
+    return function* filterParameterDependenciesWorker(ctx) {
+        const tracker = newFilterParameterRootTracker();
+        yield takeEvery(catalogActions.setCatalogFilterParameters.match, function onMapReset() {
+            tracker.reset();
+        });
+        yield takeEvery(writesTabs, function* onTabsWritten() {
+            yield call(registerFilterParameterDependencies, ctx, tracker);
+        });
+    };
+}
+/**
+ * @internal
+ */
+export function newFilterParameterRootTracker() {
+    const pending = new Set();
+    const failed = new Set();
+    return {
+        pending,
+        failed,
+        generation: 0,
+        reset() {
+            pending.clear();
+            failed.clear();
+            this.generation += 1;
+        },
+    };
+}
+/**
+ * Loads the dependencies of the filter roots the map does not know yet. A root is requested at most once
+ * between two initializations of the map: one in flight is skipped by the handlers that run meanwhile,
+ * and one the graph rejected (a deleted or forbidden object, typically) is remembered by the tracker
+ * rather than retried on every later write to the tabs slice. Only real results reach the map.
+ *
+ * @internal
+ */
+export function* registerFilterParameterDependencies(ctx, tracker) {
+    const status = yield select(selectCatalogFilterParametersStatus);
+    if (status !== "loaded") {
+        return;
+    }
+    const filtersByTab = yield select(selectFiltersByTab);
+    const known = yield select(selectCatalogFilterParameters);
+    const unknownRoots = collectFilterParameterRoots(Object.values(filtersByTab).flat()).filter((root) => {
+        const key = serializeObjRef(root);
+        return !(key in known) && !tracker.pending.has(key) && !tracker.failed.has(key);
+    });
+    if (unknownRoots.length === 0) {
+        return;
+    }
+    const keys = unknownRoots.map(serializeObjRef);
+    const generation = tracker.generation;
+    keys.forEach((key) => tracker.pending.add(key));
+    try {
+        const byRef = yield call(loadReachableParameterMap, ctx, unknownRoots);
+        if (tracker.generation === generation) {
+            yield put(catalogActions.mergeCatalogFilterParameters(byRef));
+        }
+    }
+    catch {
+        if (tracker.generation === generation) {
+            keys.forEach((key) => tracker.failed.add(key));
+        }
+    }
+    finally {
+        if (tracker.generation === generation) {
+            keys.forEach((key) => tracker.pending.delete(key));
+        }
+    }
+}
+function writesTabs(action) {
+    return unbatched(action).some((item) => item.type.startsWith(TABS_ACTION_PREFIX));
+}

package/esm/model/commandHandlers/parameters/insightParameterDependenciesWorker.d.ts

@@ -0,0 +1,11 @@
+import { type Action } from "@reduxjs/toolkit";
+import { type SagaIterator } from "redux-saga";
+import { type DashboardContext } from "../../types/commonTypes.js";
+export declare function newInsightParameterDependenciesWorker(): (ctx: DashboardContext) => SagaIterator<void>;
+/**
+ * The plain actions an action stands for: itself, or the (recursively unbatched) members of a batch.
+ *
+ * @internal
+ */
+export declare function unbatched(action: Action): Action[];
+//# sourceMappingURL=insightParameterDependenciesWorker.d.ts.map

package/esm/model/commandHandlers/parameters/insightParameterDependenciesWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insightParameterDependenciesWorker.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/parameters/insightParameterDependenciesWorker.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAW/C,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAKnE,wBAAgB,qCAAqC,UACQ,gBAAgB,KAAG,YAAY,CAAC,IAAI,CAAC,CAKjG;AA4DD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAElD"}

package/esm/model/commandHandlers/parameters/insightParameterDependenciesWorker.js

@@ -0,0 +1,71 @@
+// (C) 2026 GoodData Corporation
+import { call, put, select, takeEvery } from "redux-saga/effects";
+import { insightRef, serializeObjRef } from "@gooddata/sdk-model";
+import { selectCatalogInsightParameters, selectCatalogInsightParametersStatus, } from "../../store/catalog/catalogSelectors.js";
+import { catalogActions } from "../../store/catalog/index.js";
+import { insightsActions } from "../../store/insights/index.js";
+import { loadInsightParameterDependencies } from "./loadInsightParameterDependencies.js";
+export function newInsightParameterDependenciesWorker() {
+    return function* insightParameterDependenciesWorker(ctx) {
+        yield takeEvery(writesInsights, function* onInsightsWritten(action) {
+            yield call(registerInsightParameterDependencies, ctx, action);
+        });
+    };
+}
+function* registerInsightParameterDependencies(ctx, action) {
+    const status = yield select(selectCatalogInsightParametersStatus);
+    if (status !== "loaded") {
+        return;
+    }
+    const known = yield select(selectCatalogInsightParameters);
+    const insights = [
+        ...writtenInsights(action),
+        ...replacedInsights(action).filter((insight) => !(serializeObjRef(insightRef(insight)) in known)),
+    ];
+    if (insights.length === 0) {
+        return;
+    }
+    const dependencies = yield call(loadInsightParameterDependencies, ctx, insights, true);
+    if (dependencies.status === "loaded") {
+        yield put(catalogActions.mergeCatalogInsightParameters(dependencies.byInsight));
+    }
+}
+function writesInsights(action) {
+    return writtenInsights(action).length > 0 || replacedInsights(action).length > 0;
+}
+function writtenInsights(action) {
+    return unbatched(action).flatMap(writtenInsightsOf);
+}
+function writtenInsightsOf(action) {
+    if (insightsActions.addInsights.match(action)) {
+        return entityPayloadInsights(action.payload);
+    }
+    if (insightsActions.upsertInsight.match(action)) {
+        return [action.payload];
+    }
+    return [];
+}
+function replacedInsights(action) {
+    return unbatched(action).flatMap(replacedInsightsOf);
+}
+function replacedInsightsOf(action) {
+    return insightsActions.setInsights.match(action) ? entityPayloadInsights(action.payload) : [];
+}
+function entityPayloadInsights(payload) {
+    return Array.isArray(payload) ? [...payload] : Object.values(payload);
+}
+/**
+ * The plain actions an action stands for: itself, or the (recursively unbatched) members of a batch.
+ *
+ * @internal
+ */
+export function unbatched(action) {
+    return isBatchAction(action) ? action.payload.flatMap(unbatched) : [action];
+}
+function isBatchAction(action) {
+    return ("meta" in action &&
+        typeof action.meta === "object" &&
+        action.meta !== null &&
+        "batch" in action.meta &&
+        action.meta.batch === true);
+}

package/esm/model/commandHandlers/parameters/loadFilterParameterDependencies.d.ts

@@ -0,0 +1,22 @@
+import { type FilterContextItem, type IDashboard } from "@gooddata/sdk-model";
+import { type ICatalogFilterParametersState } from "../../store/catalog/catalogState.js";
+import { type DashboardContext } from "../../types/commonTypes.js";
+/**
+ * Loads the dashboard-wide dashboard-filter → parameter dependency map from the workspace references
+ * service.
+ *
+ * @remarks
+ * A dashboard filter is not part of any insight, so the insight-rooted map cannot see the parameters a
+ * widget depends on through it. The roots are the objects the filters read (see
+ * {@link collectFilterParameterRoots}); they go to the service in the same single `direction: "down"`
+ * request shape as the insight roots, and the map is keyed by `serializeObjRef(root)`. Disabled
+ * parameters return `uninitialized`; backend errors return `failed`.
+ */
+export declare function loadFilterParameterDependencies(ctx: DashboardContext, filters: ReadonlyArray<FilterContextItem>, enableParameters: boolean): Promise<ICatalogFilterParametersState>;
+/**
+ * Every dashboard filter of the dashboard being initialized: the filters of each tab plus those of the root
+ * filter context. The root context is the single tab of a dashboard without tabs, and the tab state keeps
+ * it as a default tab even when tabs exist, so it is always included; roots are deduped downstream.
+ */
+export declare function collectDashboardFilterContextItems(dashboard: IDashboard): FilterContextItem[];
+//# sourceMappingURL=loadFilterParameterDependencies.d.ts.map

package/esm/model/commandHandlers/parameters/loadFilterParameterDependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadFilterParameterDependencies.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/parameters/loadFilterParameterDependencies.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE9E,OAAO,EAAE,KAAK,6BAA6B,EAAE,MAAM,qCAAqC,CAAC;AAEzF,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAInE;;;;;;;;;;GAUG;AACH,wBAAsB,+BAA+B,CACjD,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,aAAa,CAAC,iBAAiB,CAAC,EACzC,gBAAgB,EAAE,OAAO,GAC1B,OAAO,CAAC,6BAA6B,CAAC,CAgBxC;AAED;;;;GAIG;AACH,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,UAAU,GAAG,iBAAiB,EAAE,CAG7F"}

package/esm/model/commandHandlers/parameters/loadFilterParameterDependencies.js

@@ -0,0 +1,39 @@
+// (C) 2026 GoodData Corporation
+import { collectFilterParameterRoots } from "../../store/tabs/parameters/parametersHelpers.js";
+import { loadReachableParameterMap } from "./loadInsightParameterDependencies.js";
+/**
+ * Loads the dashboard-wide dashboard-filter → parameter dependency map from the workspace references
+ * service.
+ *
+ * @remarks
+ * A dashboard filter is not part of any insight, so the insight-rooted map cannot see the parameters a
+ * widget depends on through it. The roots are the objects the filters read (see
+ * {@link collectFilterParameterRoots}); they go to the service in the same single `direction: "down"`
+ * request shape as the insight roots, and the map is keyed by `serializeObjRef(root)`. Disabled
+ * parameters return `uninitialized`; backend errors return `failed`.
+ */
+export async function loadFilterParameterDependencies(ctx, filters, enableParameters) {
+    if (!enableParameters) {
+        return { status: "uninitialized", byRef: {} };
+    }
+    const roots = collectFilterParameterRoots(filters);
+    if (roots.length === 0) {
+        return { status: "loaded", byRef: {} };
+    }
+    try {
+        const byRef = await loadReachableParameterMap(ctx, roots);
+        return { status: "loaded", byRef };
+    }
+    catch {
+        return { status: "failed", byRef: {} };
+    }
+}
+/**
+ * Every dashboard filter of the dashboard being initialized: the filters of each tab plus those of the root
+ * filter context. The root context is the single tab of a dashboard without tabs, and the tab state keeps
+ * it as a default tab even when tabs exist, so it is always included; roots are deduped downstream.
+ */
+export function collectDashboardFilterContextItems(dashboard) {
+    const tabFilters = (dashboard.tabs ?? []).flatMap((tab) => tab.filterContext?.filters ?? []);
+    return [...tabFilters, ...(dashboard.filterContext?.filters ?? [])];
+}

package/esm/model/commandHandlers/parameters/loadInsightParameterDependencies.d.ts

@@ -0,0 +1,21 @@
+import { type IInsight, type IdentifierRef } from "@gooddata/sdk-model";
+import { type ICatalogInsightParametersState } from "../../store/catalog/catalogState.js";
+import { type DashboardContext } from "../../types/commonTypes.js";
+/**
+ * Loads the dashboard-wide insight -> parameter dependency map from the workspace references service.
+ *
+ * @remarks
+ * Walks the dependency graph in `direction: "down"` from each insight, then collects the parameter
+ * nodes reachable from it through metrics and computed attributes. Disabled parameters return
+ * `uninitialized`; backend errors return `failed`.
+ */
+export declare function loadInsightParameterDependencies(ctx: DashboardContext, insights: IInsight[], enableParameters: boolean): Promise<ICatalogInsightParametersState>;
+/**
+ * Asks the workspace references service for the dependency graph below `roots` (one request for all of
+ * them) and maps each root (keyed by `serializeObjRef`) to the parameter refs reachable from it. Throws
+ * when the service does; the caller decides how that degrades.
+ *
+ * @internal
+ */
+export declare function loadReachableParameterMap(ctx: DashboardContext, roots: IdentifierRef[]): Promise<Record<string, IdentifierRef[]>>;
+//# sourceMappingURL=loadInsightParameterDependencies.d.ts.map

package/esm/model/commandHandlers/parameters/loadInsightParameterDependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadInsightParameterDependencies.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/parameters/loadInsightParameterDependencies.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,KAAK,QAAQ,EACb,KAAK,aAAa,EAIrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AAC1F,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE;;;;;;;GAOG;AACH,wBAAsB,gCAAgC,CAClD,GAAG,EAAE,gBAAgB,EACrB,QAAQ,EAAE,QAAQ,EAAE,EACpB,gBAAgB,EAAE,OAAO,GAC1B,OAAO,CAAC,8BAA8B,CAAC,CAgBzC;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC3C,GAAG,EAAE,gBAAgB,EACrB,KAAK,EAAE,aAAa,EAAE,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC,CAO1C"}

package/esm/model/commandHandlers/parameters/loadInsightParameterDependencies.js

@@ -0,0 +1,86 @@
+// (C) 2026 GoodData Corporation
+import { insightRef, isIdentifierRef, serializeObjRef, } from "@gooddata/sdk-model";
+/**
+ * Loads the dashboard-wide insight -> parameter dependency map from the workspace references service.
+ *
+ * @remarks
+ * Walks the dependency graph in `direction: "down"` from each insight, then collects the parameter
+ * nodes reachable from it through metrics and computed attributes. Disabled parameters return
+ * `uninitialized`; backend errors return `failed`.
+ */
+export async function loadInsightParameterDependencies(ctx, insights, enableParameters) {
+    if (!enableParameters) {
+        return { status: "uninitialized", byInsight: {} };
+    }
+    const roots = insights.map(insightRef).filter(isIdentifierRef);
+    if (roots.length === 0) {
+        return { status: "loaded", byInsight: {} };
+    }
+    try {
+        const byInsight = await loadReachableParameterMap(ctx, roots);
+        return { status: "loaded", byInsight };
+    }
+    catch {
+        return { status: "failed", byInsight: {} };
+    }
+}
+/**
+ * Asks the workspace references service for the dependency graph below `roots` (one request for all of
+ * them) and maps each root (keyed by `serializeObjRef`) to the parameter refs reachable from it. Throws
+ * when the service does; the caller decides how that degrades.
+ *
+ * @internal
+ */
+export async function loadReachableParameterMap(ctx, roots) {
+    const result = await ctx.backend
+        .workspace(ctx.workspace)
+        .references()
+        .getReferences(roots, { direction: "down" });
+    return buildReachableParameterMap(roots, result.edges);
+}
+function buildReachableParameterMap(roots, edges) {
+    const adjacency = buildAdjacency(edges);
+    const result = {};
+    for (const root of roots) {
+        result[serializeObjRef(root)] = reachableParameterRefs(graphInsightRef(root), adjacency);
+    }
+    return result;
+}
+function graphInsightRef(root) {
+    return root.type ? root : { ...root, type: "insight" };
+}
+function buildAdjacency(edges) {
+    const adjacency = new Map();
+    for (const edge of edges) {
+        const fromKey = serializeObjRef(edge.from);
+        const neighbors = adjacency.get(fromKey);
+        if (neighbors) {
+            neighbors.push(edge.to);
+        }
+        else {
+            adjacency.set(fromKey, [edge.to]);
+        }
+    }
+    return adjacency;
+}
+function reachableParameterRefs(start, adjacency) {
+    const parameters = [];
+    const visited = new Set([serializeObjRef(start)]);
+    const queue = [start];
+    for (let i = 0; i < queue.length; i++) {
+        for (const neighbor of adjacency.get(serializeObjRef(queue[i])) ?? []) {
+            const key = serializeObjRef(neighbor);
+            if (visited.has(key)) {
+                continue;
+            }
+            visited.add(key);
+            if (neighbor.type === "parameter") {
+                parameters.push(neighbor);
+            }
+            else {
+                queue.push(neighbor);
+            }
+        }
+    }
+    return parameters;
+}

package/esm/model/react/useInitializeDashboardStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useInitializeDashboardStore.d.ts","sourceRoot":"","sources":["../../../src/model/react/useInitializeDashboardStore.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,KAAK,sBAAsB,EAAwB,MAAM,4BAA4B,CAAC;AAI/F,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,YAAY,CAAC;AA6D/D;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,UAC7B,4BAA4B,KACpC,sBAAsB,GAAG,IA0G3B,CAAC"}
+{"version":3,"file":"useInitializeDashboardStore.d.ts","sourceRoot":"","sources":["../../../src/model/react/useInitializeDashboardStore.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,KAAK,sBAAsB,EAAwB,MAAM,4BAA4B,CAAC;AAI/F,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,YAAY,CAAC;AA6D/D;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,UAC7B,4BAA4B,KACpC,sBAAsB,GAAG,IA4G3B,CAAC"}

package/esm/model/react/useInitializeDashboardStore.js

@@ -6,6 +6,8 @@ import { enrichMapboxToken, useMapboxToken } from "@gooddata/sdk-ui-geo";
 import { enrichAgGridToken, useAgGridToken } from "@gooddata/sdk-ui-pivot/next";
 import { shallowEqualObjects } from "@gooddata/util";
 import { newDashboardSummaryWorkflowWorker } from "../commandHandlers/dashboard/dashboardSummaryWorkflowWorker.js";
+import { newFilterParameterDependenciesWorker } from "../commandHandlers/parameters/filterParameterDependenciesWorker.js";
+import { newInsightParameterDependenciesWorker } from "../commandHandlers/parameters/insightParameterDependenciesWorker.js";
 import { newRenderingWorker } from "../commandHandlers/render/renderingWorker.js";
 import { InitialLoadCorrelationId, initializeDashboardWithPersistedDashboard, } from "../commands/dashboard.js";
 import { dashboardDeinitialized } from "../events/dashboard.js";
@@ -111,6 +113,8 @@ export const useInitializeDashboardStore = (props) => {
                     isExport: config?.isExport,
                 }),
                 newDashboardSummaryWorkflowWorker(),
+                newInsightParameterDependenciesWorker(),
+                newFilterParameterDependenciesWorker(),
             ];
             // Create new store and fire load dashboard command.
             const newDashboardStore = createDashboardStore({

package/esm/model/react/useIsWidgetRestricted.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIsWidgetRestricted.d.ts","sourceRoot":"","sources":["../../../src/model/react/useIsWidgetRestricted.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,uBAAuB,EAAmC,MAAM,yBAAyB,CAAC;AA6BxG;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAI9E;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,uBAAuB,EAAE,GAAG,OAAO,CAIpF"}
+{"version":3,"file":"useIsWidgetRestricted.d.ts","sourceRoot":"","sources":["../../../src/model/react/useIsWidgetRestricted.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,KAAK,uBAAuB,EAAmC,MAAM,yBAAyB,CAAC;AAuCxG;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAK9E;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,uBAAuB,EAAE,GAAG,OAAO,CAKpF"}

package/esm/model/react/useIsWidgetRestricted.js

@@ -1,24 +1,29 @@
 // (C) 2026 GoodData Corporation
-import { isInsightWidget, isVisualizationSwitcherWidget } from "@gooddata/sdk-model";
-import { selectRestrictedInsightsMap } from "../store/unavailableObjects/unavailableObjectsSelectors.js";
+import { areObjRefsEqual, isInsightWidget, isRichTextWidget, isVisualizationSwitcherWidget, } from "@gooddata/sdk-model";
+import { collectReferences } from "@gooddata/sdk-ui-kit";
+import { selectRestrictedInsightsMap, selectRestrictedRichTextReferences, } from "../store/unavailableObjects/unavailableObjectsSelectors.js";
 import { isExtendedDashboardLayoutWidget } from "../types/layoutTypes.js";
 import { useDashboardSelector } from "./DashboardStoreProvider.js";
 /**
  * A switcher counts as restricted as soon as one of its entries is: its size comes from a
  * visualization type the editor may not read, exactly as for a single restricted visualization. A
- * container counts once anything inside it does, because its own resize reaches every descendant.
+ * rich text widget counts once its text references an object that is withheld, and a container once
+ * anything inside it does, because its own resize reaches every descendant.
  */
-function isWidgetRestricted(widget, restrictedInsights) {
+function isWidgetRestricted(widget, restrictedInsights, restrictedReferences) {
     if (isInsightWidget(widget)) {
         return restrictedInsights.has(widget.insight);
     }
     if (isVisualizationSwitcherWidget(widget)) {
         return widget.visualizations.some((visualization) => restrictedInsights.has(visualization.insight));
     }
+    if (isRichTextWidget(widget)) {
+        return Object.values(collectReferences(widget.content)).some((reference) => restrictedReferences.some((restricted) => areObjRefsEqual(restricted, reference.ref)));
+    }
     if (isExtendedDashboardLayoutWidget(widget)) {
         // resizing a container writes its new width to every widget inside it, so a container holding
         // a restricted widget cannot be resized either
-        return widget.sections.some((section) => section.items.some((item) => item.widget && isWidgetRestricted(item.widget, restrictedInsights)));
+        return widget.sections.some((section) => section.items.some((item) => item.widget && isWidgetRestricted(item.widget, restrictedInsights, restrictedReferences)));
     }
     return false;
 }
@@ -30,7 +35,8 @@ function isWidgetRestricted(widget, restrictedInsights) {
  */
 export function useIsWidgetRestricted(widget) {
     const restrictedInsights = useDashboardSelector(selectRestrictedInsightsMap);
-    return isWidgetRestricted(widget, restrictedInsights);
+    const restrictedReferences = useDashboardSelector(selectRestrictedRichTextReferences);
+    return isWidgetRestricted(widget, restrictedInsights, restrictedReferences);
 }
 /**
  * Tells whether any of the widgets is restricted. Used where an action covers several widgets at once,
@@ -40,5 +46,6 @@ export function useIsWidgetRestricted(widget) {
  */
 export function useIsAnyWidgetRestricted(widgets) {
     const restrictedInsights = useDashboardSelector(selectRestrictedInsightsMap);
-    return widgets.some((widget) => isWidgetRestricted(widget, restrictedInsights));
+    const restrictedReferences = useDashboardSelector(selectRestrictedRichTextReferences);
+    return widgets.some((widget) => isWidgetRestricted(widget, restrictedInsights, restrictedReferences));
 }

package/esm/model/react/useWidgetExecConfig.d.ts

@@ -1,4 +1,4 @@
-import { type IExecutionConfig, type IInsightDefinition, type ObjRef } from "@gooddata/sdk-model";
+import { type IExecutionConfig, type IInsight, type ObjRef } from "@gooddata/sdk-model";
 /**
  * Dashboard-level execution config shared by every execution the dashboard spawns: the execution
  * timestamp and the effective dashboard timezone. Use this hook for executions that do not go
@@ -13,9 +13,9 @@ export declare function useDashboardExecConfig(): IExecutionConfig;
  * drill overlay execute consistently instead of each duplicating (and drifting) the logic.
  *
  * @param ref - source widget whose tab provides the parameter overrides
- * @param insight - the insight being executed (the drill target, not `ref`'s own insight); its metrics
- *   decide which parameters apply
+ * @param insight - the insight being executed (the drill target, not `ref`'s own insight); its
+ *   dependencies decide which parameters apply
  * @internal
  */
-export declare function useWidgetExecConfig(ref: ObjRef, insight: IInsightDefinition): IExecutionConfig;
+export declare function useWidgetExecConfig(ref: ObjRef, insight: IInsight): IExecutionConfig;
 //# sourceMappingURL=useWidgetExecConfig.d.ts.map

package/esm/model/react/useWidgetExecConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useWidgetExecConfig.d.ts","sourceRoot":"","sources":["../../../src/model/react/useWidgetExecConfig.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,kBAAkB,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AASlG;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAWzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,gBAAgB,CAe9F"}
+{"version":3,"file":"useWidgetExecConfig.d.ts","sourceRoot":"","sources":["../../../src/model/react/useWidgetExecConfig.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AASxF;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAWzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,gBAAgB,CAepF"}

package/esm/model/react/useWidgetExecConfig.js

@@ -27,8 +27,8 @@ export function useDashboardExecConfig() {
  * drill overlay execute consistently instead of each duplicating (and drifting) the logic.
  *
  * @param ref - source widget whose tab provides the parameter overrides
- * @param insight - the insight being executed (the drill target, not `ref`'s own insight); its metrics
- *   decide which parameters apply
+ * @param insight - the insight being executed (the drill target, not `ref`'s own insight); its
+ *   dependencies decide which parameters apply
  * @internal
  */
 export function useWidgetExecConfig(ref, insight) {

package/esm/model/store/catalog/catalogReducers.d.ts

@@ -1,6 +1,6 @@
 import { type Action, type CaseReducer } from "@reduxjs/toolkit";
-import { type ICatalogAttribute, type ICatalogAttributeHierarchy, type ICatalogComputedAttribute, type ICatalogDateDataset, type ICatalogFact, type ICatalogMeasure, type IDateHierarchyTemplate } from "@gooddata/sdk-model";
-import { type CatalogState, type ICatalogMeasureParametersState, type ICatalogParametersState } from "./catalogState.js";
+import { type ICatalogAttribute, type ICatalogAttributeHierarchy, type ICatalogComputedAttribute, type ICatalogDateDataset, type ICatalogFact, type ICatalogMeasure, type IDateHierarchyTemplate, type IdentifierRef } from "@gooddata/sdk-model";
+import { type CatalogState, type ICatalogFilterParametersState, type ICatalogInsightParametersState, type ICatalogParametersState } from "./catalogState.js";
 type CatalogReducer<A extends Action> = CaseReducer<CatalogState, A>;
 /**
  * @public
@@ -46,8 +46,20 @@ export declare const catalogReducers: {
         payload: ICatalogParametersState;
         type: string;
     }>;
-    setCatalogMeasureParameters: CatalogReducer<{
-        payload: ICatalogMeasureParametersState;
+    setCatalogInsightParameters: CatalogReducer<{
+        payload: ICatalogInsightParametersState;
+        type: string;
+    }>;
+    mergeCatalogInsightParameters: CatalogReducer<{
+        payload: Record<string, IdentifierRef[]>;
+        type: string;
+    }>;
+    setCatalogFilterParameters: CatalogReducer<{
+        payload: ICatalogFilterParametersState;
+        type: string;
+    }>;
+    mergeCatalogFilterParameters: CatalogReducer<{
+        payload: Record<string, IdentifierRef[]>;
         type: string;
     }>;
 };

package/esm/model/store/catalog/catalogReducers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalogReducers.d.ts","sourceRoot":"","sources":["../../../../src/model/store/catalog/catalogReducers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAsB,MAAM,kBAAkB,CAAC;AAErF,OAAO,EACH,KAAK,iBAAiB,EACtB,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC9B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,8BAA8B,EACnC,KAAK,uBAAuB,EAC/B,MAAM,mBAAmB,CAAC;AAE3B,KAAK,cAAc,CAAC,CAAC,SAAS,MAAM,IAAI,WAAW,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACjC,UAAU,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACjC,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;IAC7B,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACrC,oBAAoB,CAAC,EAAE,0BAA0B,EAAE,CAAC;IACpD,kBAAkB,CAAC,EAAE,yBAAyB,EAAE,CAAC;IACjD,sBAAsB,CAAC,EAAE,sBAAsB,EAAE,CAAC;CACrD,CAAC;AAsBF;;GAEG;AACH,MAAM,MAAM,iCAAiC,GAAG;IAC5C,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,KAAK,EAAE,YAAY,EAAE,CAAC;CACzB,CAAC;AAqDF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ3B,CAAC"}
+{"version":3,"file":"catalogReducers.d.ts","sourceRoot":"","sources":["../../../../src/model/store/catalog/catalogReducers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAsB,MAAM,kBAAkB,CAAC;AAErF,OAAO,EACH,KAAK,iBAAiB,EACtB,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,aAAa,EACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,6BAA6B,EAClC,KAAK,8BAA8B,EACnC,KAAK,uBAAuB,EAC/B,MAAM,mBAAmB,CAAC;AAE3B,KAAK,cAAc,CAAC,CAAC,SAAS,MAAM,IAAI,WAAW,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACjC,UAAU,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACjC,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;IAC7B,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACrC,oBAAoB,CAAC,EAAE,0BAA0B,EAAE,CAAC;IACpD,kBAAkB,CAAC,EAAE,yBAAyB,EAAE,CAAC;IACjD,sBAAsB,CAAC,EAAE,sBAAsB,EAAE,CAAC;CACrD,CAAC;AAsBF;;GAEG;AACH,MAAM,MAAM,iCAAiC,GAAG;IAC5C,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,KAAK,EAAE,YAAY,EAAE,CAAC;CACzB,CAAC;AA0EF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAW3B,CAAC"}

package/esm/model/store/catalog/catalogReducers.js

@@ -33,8 +33,17 @@ const deleteAttributeHierarchy = (state, action) => {
 const setCatalogParameters = (state, action) => {
     state.parameters = action.payload;
 };
-const setCatalogMeasureParameters = (state, action) => {
-    state.measureParameters = action.payload;
+const setCatalogInsightParameters = (state, action) => {
+    state.insightParameters = action.payload;
+};
+const mergeCatalogInsightParameters = (state, action) => {
+    Object.assign(state.insightParameters.byInsight, action.payload);
+};
+const setCatalogFilterParameters = (state, action) => {
+    state.filterParameters = action.payload;
+};
+const mergeCatalogFilterParameters = (state, action) => {
+    Object.assign(state.filterParameters.byRef, action.payload);
 };
 export const catalogReducers = {
     setCatalogItems,
@@ -43,5 +52,8 @@ export const catalogReducers = {
     updateAttributeHierarchy,
     deleteAttributeHierarchy,
     setCatalogParameters,
-    setCatalogMeasureParameters,
+    setCatalogInsightParameters,
+    mergeCatalogInsightParameters,
+    setCatalogFilterParameters,
+    mergeCatalogFilterParameters,
 };