@gooddata/sdk-ui-dashboard 11.58.0-alpha.4 → 11.58.0-alpha.6

package/esm/model/commandHandlers/dashboard/initializeDashboardHandler/index.js

@@ -30,8 +30,8 @@ import { uiActions } from "../../../store/ui/index.js";
 import { unavailableObjectsActions } from "../../../store/unavailableObjects/index.js";
 import { selectUnavailableObjects } from "../../../store/unavailableObjects/unavailableObjectsSelectors.js";
 import { userActions } from "../../../store/user/index.js";
-import { collectDashboardFilterContextItems, loadFilterParameterDependencies, } from "../../parameters/loadFilterParameterDependencies.js";
-import { loadInsightParameterDependencies } from "../../parameters/loadInsightParameterDependencies.js";
+import { collectDashboardParameterRoots } from "../../parameters/dashboardParameterRoots.js";
+import { loadParameterDependencies } from "../../parameters/loadParameterDependencies.js";
 import { changeDashboardTimezoneOverrideHandler } from "../../timezone/changeDashboardTimezoneOverrideHandler.js";
 import { applyDefaultFilterView } from "../common/filterViews.js";
 import { actionsToInitializeExistingDashboard, actionsToInitializeNewDashboard, } from "../common/stateInitializers.js";
@@ -195,11 +195,11 @@ function* loadExistingDashboard(ctx, cmd, dashboardRef) {
     // Note: activeTabLocalIdentifier is app state only, NOT persisted to/read from dashboard MD
     const resolvedActiveTabId = resolveActiveTabId(dashboardWithFilterView.tabs, cmd.payload.initialTabId, undefined);
     const dashboard = dashboardWithFilterView;
-    const [{ tabsAttributeFilterConfigs, tabsDateFilterConfig, tabsDateFilterConfigSource }, workspaceParameters, insightParameterDependencies, filterParameterDependencies,] = yield all([
+    const enableParameters = config.settings?.enableParameters ?? false;
+    const [{ tabsAttributeFilterConfigs, tabsDateFilterConfig, tabsDateFilterConfigSource }, workspaceParameters, parameterDependencies,] = yield all([
         call(getTabsFilterConfigs, dashboard, config, ctx, cmd),
         call(loadWorkspaceParametersWithStatus, ctx, config.settings),
-        call(loadInsightParameterDependencies, ctx, insights, config.settings?.enableParameters ?? false),
-        call(loadFilterParameterDependencies, ctx, collectDashboardFilterContextItems(dashboard), config.settings?.enableParameters ?? false),
+        call(loadParameterDependencies, ctx, enableParameters ? collectDashboardParameterRoots(dashboard, insights) : []),
     ]);
     const workspaceParametersList = Array.isArray(workspaceParameters) ? workspaceParameters : [];
     const initActions = yield call(actionsToInitializeExistingDashboard, ctx, dashboard, insights, config.settings, config.settings.enableImmediateAttributeFilterDisplayAsLabelMigration ?? false, undefined, undefined, tabsAttributeFilterConfigs, tabsDateFilterConfig, tabsDateFilterConfigSource, createDisplayFormMap([], []), cmd.payload.persistedDashboard, resolvedActiveTabId, workspaceParametersList);
@@ -214,8 +214,13 @@ function* loadExistingDashboard(ctx, cmd, dashboardRef) {
         permissionsActions.setPermissions(permissions),
         catalogActions.setCatalogItems(catalogPayload),
         catalogActions.setCatalogParameters(makeCatalogParametersPayload(workspaceParameters)),
-        catalogActions.setCatalogInsightParameters(insightParameterDependencies),
-        catalogActions.setCatalogFilterParameters(filterParameterDependencies),
+        catalogActions.setCatalogParameterDependencies({
+            status: enableParameters ? "loaded" : "uninitialized",
+            byRoot: {},
+            requestedRoots: {},
+        }),
+        catalogActions.mergeCatalogParameterDependencies(parameterDependencies.byRoot),
+        catalogActions.markParameterDependenciesFailed(parameterDependencies.failedRoots),
         ...initActions,
         // NOTE: Tab configs (dateFilterConfig, dateFilterConfigs, attributeFilterConfigs, filterContext)
         // are now initialized as part of the tabs state in initActions via setTabs action
@@ -259,10 +264,8 @@ function* initializeNewDashboard(ctx, cmd) {
     const { initActions, dashboard, insights } = yield call(actionsToInitializeNewDashboard, ctx, config.settings, dateFilterConfig, loadedCatalog
         ? createDisplayFormMapFromCatalog(loadedCatalog.catalog, loadedCatalog.computedAttributes)
         : createDisplayFormMap([], []), cmd.payload.initialTabId, workspaceParametersList);
-    const insightParameterDependencies = yield call(loadInsightParameterDependencies, ctx, insights, config.settings?.enableParameters ?? false);
-    // a new dashboard starts with the default (date-only) filter context, so there is nothing to
-    // resolve yet; this only records the status so the widgets do not wait for a load that never comes
-    const filterParameterDependencies = yield call(loadFilterParameterDependencies, ctx, [], config.settings?.enableParameters ?? false);
+    const enableParameters = config.settings?.enableParameters ?? false;
+    const parameterDependencies = yield call(loadParameterDependencies, ctx, enableParameters ? collectDashboardParameterRoots(dashboard, insights) : []);
     const batch = batchActions([
         backendCapabilitiesActions.setBackendCapabilities(backend.capabilities),
         configActions.setConfig(config),
@@ -279,8 +282,13 @@ function* initializeNewDashboard(ctx, cmd) {
             dateHierarchyTemplates: dateHierarchyTemplates,
         }),
         catalogActions.setCatalogParameters(makeCatalogParametersPayload(workspaceParameters)),
-        catalogActions.setCatalogInsightParameters(insightParameterDependencies),
-        catalogActions.setCatalogFilterParameters(filterParameterDependencies),
+        catalogActions.setCatalogParameterDependencies({
+            status: enableParameters ? "loaded" : "uninitialized",
+            byRoot: {},
+            requestedRoots: {},
+        }),
+        catalogActions.mergeCatalogParameterDependencies(parameterDependencies.byRoot),
+        catalogActions.markParameterDependenciesFailed(parameterDependencies.failedRoots),
         listedDashboardsActions.setListedDashboards(listedDashboards),
         accessibleDashboardsActions.setAccessibleDashboards(listedDashboards),
         executionResultsActions.clearAllExecutionResults(),

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

@@ -0,0 +1,20 @@
+import { type IDashboard, type IInsight, type IdentifierRef } from "@gooddata/sdk-model";
+/**
+ * Every dependency root the dashboard needs parameters for: its insights, text references, and
+ * dashboard filters across all tabs. Collected at initialization so one references call covers the
+ * whole dashboard.
+ *
+ * A widget whose insight did not load keeps its own description, which is what it renders.
+ *
+ * @internal
+ */
+export declare function collectDashboardParameterRoots(dashboard: IDashboard | undefined, insights: IInsight[]): IdentifierRef[];
+/**
+ * The dependency roots of a text: the metrics and computed attributes it references, which the
+ * text executes and whose parameters therefore apply to it. Labels resolve through their own
+ * display form and parameters are never executed, so neither is a root.
+ *
+ * @internal
+ */
+export declare function collectTextReferenceRoots(content: string): IdentifierRef[];
+//# sourceMappingURL=dashboardParameterRoots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dashboardParameterRoots.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/parameters/dashboardParameterRoots.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,KAAK,UAAU,EAEf,KAAK,QAAQ,EACb,KAAK,aAAa,EAKrB,MAAM,qBAAqB,CAAC;AAS7B;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAC1C,SAAS,EAAE,UAAU,GAAG,SAAS,EACjC,QAAQ,EAAE,QAAQ,EAAE,GACrB,aAAa,EAAE,CA+BjB;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,EAAE,CAM1E"}

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

@@ -0,0 +1,61 @@
+// (C) 2026 GoodData Corporation
+import { uniqBy } from "lodash-es";
+import { walkLayout } from "@gooddata/sdk-backend-spi";
+import { isIdentifierRef, isInsightWidget, isRichTextWidget, serializeObjRef, } from "@gooddata/sdk-model";
+import { collectReferences } from "@gooddata/sdk-ui-kit";
+import { insightWidgetDescription } from "../../../_staging/insight/insightWidgetDescription.js";
+import { newInsightMap } from "../../../_staging/metadata/objRefMap.js";
+import { collectFilterParameterRoots } from "../../store/tabs/parameters/parametersHelpers.js";
+import { insightRoots } from "./loadParameterDependencies.js";
+/**
+ * Every dependency root the dashboard needs parameters for: its insights, text references, and
+ * dashboard filters across all tabs. Collected at initialization so one references call covers the
+ * whole dashboard.
+ *
+ * A widget whose insight did not load keeps its own description, which is what it renders.
+ *
+ * @internal
+ */
+export function collectDashboardParameterRoots(dashboard, insights) {
+    const insightMap = newInsightMap(insights);
+    const roots = insightRoots(insights);
+    function textRoots(content) {
+        return content ? collectTextReferenceRoots(content) : [];
+    }
+    function widgetText(widget) {
+        if (isRichTextWidget(widget)) {
+            return widget.content;
+        }
+        return isInsightWidget(widget)
+            ? insightWidgetDescription(widget, insightMap.get(widget.insight))
+            : undefined;
+    }
+    for (const layout of [dashboard?.layout, ...(dashboard?.tabs ?? []).map((tab) => tab.layout)]) {
+        if (layout) {
+            walkLayout(layout, {
+                sectionCallback: (section) => roots.push(...textRoots(section.header?.description)),
+                widgetCallback: (widget) => roots.push(...textRoots(widgetText(widget))),
+            });
+        }
+    }
+    const filters = [
+        ...(dashboard?.tabs ?? []).flatMap((tab) => tab.filterContext?.filters ?? []),
+        ...(dashboard?.filterContext?.filters ?? []),
+    ];
+    roots.push(...collectFilterParameterRoots(filters));
+    return uniqBy(roots, serializeObjRef);
+}
+/**
+ * The dependency roots of a text: the metrics and computed attributes it references, which the
+ * text executes and whose parameters therefore apply to it. Labels resolve through their own
+ * display form and parameters are never executed, so neither is a root.
+ *
+ * @internal
+ */
+export function collectTextReferenceRoots(content) {
+    const roots = Object.values(collectReferences(content))
+        .filter(({ type }) => type === "measure" || type === "computedAttribute")
+        .map(({ ref }) => ref)
+        .filter(isIdentifierRef);
+    return uniqBy(roots, serializeObjRef);
+}

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

@@ -0,0 +1,27 @@
+import { type IInsight, type IdentifierRef } from "@gooddata/sdk-model";
+import { type DashboardContext } from "../../types/commonTypes.js";
+interface IParameterDependenciesLoadResult {
+    byRoot: Record<string, IdentifierRef[]>;
+    failedRoots: IdentifierRef[];
+}
+/**
+ * Loads the root -> parameter dependencies of `roots` from the workspace references service.
+ *
+ * @remarks
+ * Walks the dependency graph in `direction: "down"` from each root, then collects the parameter
+ * nodes reachable from it through metrics and computed attributes. Each root is keyed by
+ * `serializeObjRef` of the ref exactly as it was supplied, so a caller looks its own refs up again.
+ * A batch the backend rejects for one unknown root is retried root by root, so the remaining roots
+ * stay available and only the rejected ones fail. Any other failure is endpoint-wide and fails every
+ * root at once.
+ */
+export declare function loadParameterDependencies(ctx: DashboardContext, roots: IdentifierRef[]): Promise<IParameterDependenciesLoadResult>;
+/**
+ * The dependency roots of insights: their own refs, less the ones spelled by uri - the graph is
+ * walked by identifier.
+ *
+ * @internal
+ */
+export declare function insightRoots(insights: IInsight[]): IdentifierRef[];
+export {};
+//# sourceMappingURL=loadParameterDependencies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loadParameterDependencies.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/parameters/loadParameterDependencies.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,KAAK,QAAQ,EACb,KAAK,aAAa,EAIrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,UAAU,gCAAgC;IACtC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;IACxC,WAAW,EAAE,aAAa,EAAE,CAAC;CAChC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,yBAAyB,CAC3C,GAAG,EAAE,gBAAgB,EACrB,KAAK,EAAE,aAAa,EAAE,GACvB,OAAO,CAAC,gCAAgC,CAAC,CAwB3C;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,aAAa,EAAE,CAElE"}

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

@@ -0,0 +1,114 @@
+// (C) 2026 GoodData Corporation
+import { isUnexpectedResponseError } from "@gooddata/sdk-backend-spi";
+import { insightRef, isIdentifierRef, serializeObjRef, } from "@gooddata/sdk-model";
+/**
+ * Loads the root -> parameter dependencies of `roots` from the workspace references service.
+ *
+ * @remarks
+ * Walks the dependency graph in `direction: "down"` from each root, then collects the parameter
+ * nodes reachable from it through metrics and computed attributes. Each root is keyed by
+ * `serializeObjRef` of the ref exactly as it was supplied, so a caller looks its own refs up again.
+ * A batch the backend rejects for one unknown root is retried root by root, so the remaining roots
+ * stay available and only the rejected ones fail. Any other failure is endpoint-wide and fails every
+ * root at once.
+ */
+export async function loadParameterDependencies(ctx, roots) {
+    if (roots.length === 0) {
+        return { byRoot: {}, failedRoots: [] };
+    }
+    try {
+        return { byRoot: await loadReachableParameterMap(ctx, roots), failedRoots: [] };
+    }
+    catch (error) {
+        if (roots.length === 1 || !rejectsWholeBatch(error)) {
+            return { byRoot: {}, failedRoots: roots };
+        }
+        const results = await Promise.allSettled(roots.map((root) => loadReachableParameterMap(ctx, [root])));
+        const byRoot = {};
+        const failedRoots = [];
+        for (let i = 0; i < roots.length; i++) {
+            const result = results[i];
+            if (result.status === "fulfilled") {
+                Object.assign(byRoot, result.value);
+            }
+            else {
+                failedRoots.push(roots[i]);
+            }
+        }
+        return { byRoot, failedRoots };
+    }
+}
+/**
+ * The dependency roots of insights: their own refs, less the ones spelled by uri - the graph is
+ * walked by identifier.
+ *
+ * @internal
+ */
+export function insightRoots(insights) {
+    return insights.map(insightRef).filter(isIdentifierRef);
+}
+/**
+ * The graph endpoint answers a batch holding one root it does not know with `400`, so the other
+ * roots are lost with it and only a per-root retry tells them apart. Every other failure - the
+ * endpoint down, the session gone - fails a retry the same way, for every root.
+ */
+function rejectsWholeBatch(error) {
+    return isUnexpectedResponseError(error) && error.httpStatus === 400;
+}
+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;
+}
+/**
+ * Only insight roots arrive untyped, and the graph needs the type to start the walk. The map key
+ * keeps the ref as it was supplied, so the coercion never reaches it.
+ */
+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/commandHandlers/parameters/parameterDependenciesWorker.d.ts

@@ -0,0 +1,6 @@
+import { type SagaIterator } from "redux-saga";
+import { type IdentifierRef } from "@gooddata/sdk-model";
+import { type DashboardContext } from "../../types/commonTypes.js";
+export declare const requestParameterDependencies: import("@reduxjs/toolkit").ActionCreatorWithPayload<IdentifierRef[], string>;
+export declare function newParameterDependenciesWorker(): (ctx: DashboardContext) => SagaIterator<void>;
+//# sourceMappingURL=parameterDependenciesWorker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parameterDependenciesWorker.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/parameters/parameterDependenciesWorker.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAiB,KAAK,aAAa,EAAmB,MAAM,qBAAqB,CAAC;AAYzF,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAOnE,eAAO,MAAM,4BAA4B,8EAAiE,CAAC;AAM3G,wBAAgB,8BAA8B,UACQ,gBAAgB,KAAG,YAAY,CAAC,IAAI,CAAC,CAM1F"}

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

@@ -0,0 +1,107 @@
+// (C) 2026 GoodData Corporation
+import { createAction } from "@reduxjs/toolkit";
+import { uniqBy } from "lodash-es";
+import { batchActions } from "redux-batched-actions";
+import { call, put, select, takeEvery } from "redux-saga/effects";
+import { serializeObjRef } from "@gooddata/sdk-model";
+import { selectCatalogParameterDependencies, selectCatalogParameterDependenciesStatus, selectCatalogRequestedParameterRoots, } from "../../store/catalog/catalogSelectors.js";
+import { catalogActions } from "../../store/catalog/index.js";
+import { insightsActions } from "../../store/insights/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 { insightRoots, loadParameterDependencies } from "./loadParameterDependencies.js";
+const TABS_ACTION_PREFIX = `${tabsActions.setTabs.type.split("/")[0]}/`;
+export const requestParameterDependencies = createAction("parameterDependencies/request");
+export function newParameterDependenciesWorker() {
+    return function* parameterDependenciesWorker(ctx) {
+        const generation = { current: 0 };
+        yield takeEvery(writesParameterDependencyInputs, function* onInputsWritten(action) {
+            yield call(updateParameterDependencies, ctx, generation, action);
+        });
+    };
+}
+function* updateParameterDependencies(ctx, generation, action) {
+    const actions = unbatched(action);
+    if (actions.some(catalogActions.setCatalogParameterDependencies.match)) {
+        generation.current += 1;
+    }
+    const explicitlyRequestedRoots = actions.flatMap(requestedRootsOf);
+    const status = yield select(selectCatalogParameterDependenciesStatus);
+    if (status !== "loaded") {
+        if (explicitlyRequestedRoots.length > 0) {
+            yield put(catalogActions.markParameterDependenciesFailed(explicitlyRequestedRoots));
+        }
+        return;
+    }
+    const known = yield select(selectCatalogParameterDependencies);
+    const requested = yield select(selectCatalogRequestedParameterRoots);
+    const refreshRoots = insightRoots(actions.flatMap(writtenInsightsOf));
+    const requestedRoots = [
+        ...insightRoots(actions.flatMap(replacedInsightsOf)),
+        ...explicitlyRequestedRoots,
+    ];
+    if (actions.some(writesTabs)) {
+        const filtersByTab = yield select(selectFiltersByTab);
+        requestedRoots.push(...collectFilterParameterRoots(Object.values(filtersByTab).flat()));
+    }
+    const unknownRoots = requestedRoots.filter((root) => {
+        const key = serializeObjRef(root);
+        return !(key in known) && !(key in requested);
+    });
+    const roots = uniqBy([...refreshRoots, ...unknownRoots], serializeObjRef);
+    yield call(loadAndMergeParameterDependencies, ctx, generation, roots);
+}
+function* loadAndMergeParameterDependencies(ctx, generation, roots) {
+    if (roots.length === 0) {
+        return;
+    }
+    const requestGeneration = generation.current;
+    yield put(catalogActions.markParameterDependenciesPending(roots));
+    const loaded = yield call(loadParameterDependencies, ctx, roots);
+    if (generation.current !== requestGeneration) {
+        return;
+    }
+    yield put(batchActions([
+        catalogActions.mergeCatalogParameterDependencies(loaded.byRoot),
+        catalogActions.markParameterDependenciesFailed(loaded.failedRoots),
+    ]));
+}
+function writesParameterDependencyInputs(action) {
+    return unbatched(action).some((item) => catalogActions.setCatalogParameterDependencies.match(item) ||
+        requestParameterDependencies.match(item) ||
+        writtenInsightsOf(item).length > 0 ||
+        replacedInsightsOf(item).length > 0 ||
+        writesTabs(item));
+}
+function requestedRootsOf(action) {
+    return requestParameterDependencies.match(action) ? action.payload : [];
+}
+function writtenInsightsOf(action) {
+    if (insightsActions.addInsights.match(action)) {
+        return entityPayloadInsights(action.payload);
+    }
+    if (insightsActions.upsertInsight.match(action)) {
+        return [action.payload];
+    }
+    return [];
+}
+function replacedInsightsOf(action) {
+    return insightsActions.setInsights.match(action) ? entityPayloadInsights(action.payload) : [];
+}
+function entityPayloadInsights(payload) {
+    return Array.isArray(payload) ? [...payload] : Object.values(payload);
+}
+function writesTabs(action) {
+    return action.type.startsWith(TABS_ACTION_PREFIX);
+}
+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/react/useInitializeDashboardStore.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"useInitializeDashboardStore.d.ts","sourceRoot":"","sources":["../../../src/model/react/useInitializeDashboardStore.ts"],"names":[],"mappings":"AAuBA,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,IA2G3B,CAAC"}

package/esm/model/react/useInitializeDashboardStore.js

@@ -6,8 +6,7 @@ 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 { newParameterDependenciesWorker } from "../commandHandlers/parameters/parameterDependenciesWorker.js";
 import { newRenderingWorker } from "../commandHandlers/render/renderingWorker.js";
 import { InitialLoadCorrelationId, initializeDashboardWithPersistedDashboard, } from "../commands/dashboard.js";
 import { dashboardDeinitialized } from "../events/dashboard.js";
@@ -113,8 +112,7 @@ export const useInitializeDashboardStore = (props) => {
                     isExport: config?.isExport,
                 }),
                 newDashboardSummaryWorkflowWorker(),
-                newInsightParameterDependenciesWorker(),
-                newFilterParameterDependenciesWorker(),
+                newParameterDependenciesWorker(),
             ];
             // Create new store and fire load dashboard command.
             const newDashboardStore = createDashboardStore({

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

@@ -0,0 +1,34 @@
+import { type IExecutionConfig, type IInsight, type ObjRef } from "@gooddata/sdk-model";
+/**
+ * @internal
+ */
+export interface ITextParameters {
+    execConfig: IExecutionConfig;
+    parameterDisplayValues: ReadonlyMap<string, string> | undefined;
+    loading: boolean;
+}
+/**
+ * What a text needs from the parameters of the dashboard.
+ *
+ * `execConfig` is the execution config for the references the text resolves: the dashboard-level
+ * settings plus the parameters the referenced metrics and computed attributes depend on, so a number
+ * in a text reads the same as the chart beside it.
+ *
+ * `parameterDisplayValues` is the text every parameter shows in a `{parameter/<id>}` reference, by
+ * parameter identifier. It is `undefined` where the dashboard resolves no parameters at all, or where
+ * the workspace parameters did not load, so the host passes nothing on and the token stays as it was
+ * typed. A failed load must not show every parameter as unknown.
+ *
+ * `loading` is true while a root the text references, or a root of a dashboard filter that applies to
+ * the text, is neither in the map nor marked failed. The host defers the execution until then, so a
+ * reference is never executed without the parameters it depends on and then executed again with them.
+ *
+ * @param content - the text whose references are executed
+ * @param ref - the widget hosting the text; `undefined` for a host outside any widget, which takes
+ *   the active tab
+ * @param insight - the insight the host shows, whose authored values take part in the resolution and
+ *   whose own filters the text executes under, so its dependencies apply too
+ * @internal
+ */
+export declare function useTextParameters(content: string, ref?: ObjRef, insight?: IInsight): ITextParameters;
+//# sourceMappingURL=useTextParameters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTextParameters.d.ts","sourceRoot":"","sources":["../../../src/model/react/useTextParameters.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAmB,MAAM,qBAAqB,CAAC;AAkBzG;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,sBAAsB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAChE,OAAO,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,eAAe,CA6DpG"}

package/esm/model/react/useTextParameters.js

@@ -0,0 +1,68 @@
+// (C) 2026 GoodData Corporation
+import { useEffect, useMemo } from "react";
+import { serializeObjRef } from "@gooddata/sdk-model";
+import { collectTextReferenceRoots } from "../commandHandlers/parameters/dashboardParameterRoots.js";
+import { insightRoots } from "../commandHandlers/parameters/loadParameterDependencies.js";
+import { requestParameterDependencies } from "../commandHandlers/parameters/parameterDependenciesWorker.js";
+import { selectCatalogParametersIsLoaded, selectCatalogRequestedParameterRoots, } from "../store/catalog/catalogSelectors.js";
+import { resolveEffectiveParameterValuesForRoots, resolveParameterDisplayValues, } from "../store/tabs/parameters/parametersHelpers.js";
+import { selectWidgetParameterContext } from "../store/tabs/parameters/parametersSelectors.js";
+import { useDashboardDispatch, useDashboardSelector } from "./DashboardStoreProvider.js";
+import { useDashboardExecConfig } from "./useWidgetExecConfig.js";
+/**
+ * What a text needs from the parameters of the dashboard.
+ *
+ * `execConfig` is the execution config for the references the text resolves: the dashboard-level
+ * settings plus the parameters the referenced metrics and computed attributes depend on, so a number
+ * in a text reads the same as the chart beside it.
+ *
+ * `parameterDisplayValues` is the text every parameter shows in a `{parameter/<id>}` reference, by
+ * parameter identifier. It is `undefined` where the dashboard resolves no parameters at all, or where
+ * the workspace parameters did not load, so the host passes nothing on and the token stays as it was
+ * typed. A failed load must not show every parameter as unknown.
+ *
+ * `loading` is true while a root the text references, or a root of a dashboard filter that applies to
+ * the text, is neither in the map nor marked failed. The host defers the execution until then, so a
+ * reference is never executed without the parameters it depends on and then executed again with them.
+ *
+ * @param content - the text whose references are executed
+ * @param ref - the widget hosting the text; `undefined` for a host outside any widget, which takes
+ *   the active tab
+ * @param insight - the insight the host shows, whose authored values take part in the resolution and
+ *   whose own filters the text executes under, so its dependencies apply too
+ * @internal
+ */
+export function useTextParameters(content, ref, insight) {
+    const dashboardExecConfig = useDashboardExecConfig();
+    const parameterContext = useDashboardSelector(selectWidgetParameterContext(ref));
+    const requestedRoots = useDashboardSelector(selectCatalogRequestedParameterRoots);
+    const isCatalogLoaded = useDashboardSelector(selectCatalogParametersIsLoaded);
+    const dispatch = useDashboardDispatch();
+    // the host executes the text under the insight's own filters, so the text depends on whatever
+    // the insight depends on, the same root the chart resolves
+    const roots = useMemo(() => insight
+        ? [...collectTextReferenceRoots(content), ...insightRoots([insight])]
+        : collectTextReferenceRoots(content), [content, insight]);
+    const missingRoots = useMemo(() => parameterContext
+        ? [...roots, ...parameterContext.filterRoots].filter((root) => !(serializeObjRef(root) in parameterContext.dependenciesByRoot))
+        : [], [roots, parameterContext]);
+    // a text edited here, shown for an insight the dashboard did not load with, or under a filter
+    // added later has roots the initial references call never saw; the worker loads them
+    useEffect(() => {
+        const rootsToRequest = missingRoots.filter((root) => !(serializeObjRef(root) in requestedRoots));
+        if (rootsToRequest.length > 0) {
+            dispatch(requestParameterDependencies(rootsToRequest));
+        }
+    }, [missingRoots, requestedRoots, dispatch]);
+    const parameterValues = useMemo(() => resolveEffectiveParameterValuesForRoots(parameterContext, roots, insight), [parameterContext, roots, insight]);
+    const execConfig = useMemo(() => ({
+        ...dashboardExecConfig,
+        // omit when empty so it does not bust the execution's defFingerprint
+        ...(parameterValues.length > 0 ? { parameterValues } : {}),
+    }), [dashboardExecConfig, parameterValues]);
+    const parameterDisplayValues = useMemo(() => parameterContext && isCatalogLoaded
+        ? resolveParameterDisplayValues(parameterContext, insight)
+        : undefined, [parameterContext, isCatalogLoaded, insight]);
+    const loading = useMemo(() => missingRoots.some((root) => requestedRoots[serializeObjRef(root)] !== "failed"), [missingRoots, requestedRoots]);
+    return useMemo(() => ({ execConfig, parameterDisplayValues, loading }), [execConfig, parameterDisplayValues, loading]);
+}

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,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"}
+{"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,EAAc,MAAM,qBAAqB,CAAC;AASpG;;;;;;;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

@@ -1,7 +1,8 @@
 // (C) 2026 GoodData Corporation
 import { useMemo } from "react";
+import { insightRef } from "@gooddata/sdk-model";
 import { selectEffectiveDashboardTimezone } from "../store/meta/metaSelectors.js";
-import { resolveEffectiveParameterValuesForInsight } from "../store/tabs/parameters/parametersHelpers.js";
+import { resolveEffectiveParameterValuesForRoots } from "../store/tabs/parameters/parametersHelpers.js";
 import { selectWidgetParameterContext } from "../store/tabs/parameters/parametersSelectors.js";
 import { selectExecutionTimestamp } from "../store/ui/uiSelectors.js";
 import { useDashboardSelector } from "./DashboardStoreProvider.js";
@@ -34,7 +35,7 @@ export function useDashboardExecConfig() {
 export function useWidgetExecConfig(ref, insight) {
     const dashboardExecConfig = useDashboardExecConfig();
     const parameterContext = useDashboardSelector(selectWidgetParameterContext(ref));
-    const parameterValues = useMemo(() => resolveEffectiveParameterValuesForInsight(parameterContext, insight), [parameterContext, insight]);
+    const parameterValues = useMemo(() => resolveEffectiveParameterValuesForRoots(parameterContext, [insightRef(insight)], insight), [parameterContext, insight]);
     return useMemo(() => ({
         ...dashboardExecConfig,
         // omit when empty so it does not bust the execution's defFingerprint

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, type IdentifierRef } from "@gooddata/sdk-model";
-import { type CatalogState, type ICatalogFilterParametersState, type ICatalogInsightParametersState, type ICatalogParametersState } from "./catalogState.js";
+import { type CatalogState, type ICatalogParameterDependenciesState, type ICatalogParametersState } from "./catalogState.js";
 type CatalogReducer<A extends Action> = CaseReducer<CatalogState, A>;
 /**
  * @public
@@ -46,20 +46,20 @@ export declare const catalogReducers: {
         payload: ICatalogParametersState;
         type: string;
     }>;
-    setCatalogInsightParameters: CatalogReducer<{
-        payload: ICatalogInsightParametersState;
+    setCatalogParameterDependencies: CatalogReducer<{
+        payload: ICatalogParameterDependenciesState;
         type: string;
     }>;
-    mergeCatalogInsightParameters: CatalogReducer<{
+    mergeCatalogParameterDependencies: CatalogReducer<{
         payload: Record<string, IdentifierRef[]>;
         type: string;
     }>;
-    setCatalogFilterParameters: CatalogReducer<{
-        payload: ICatalogFilterParametersState;
+    markParameterDependenciesPending: CatalogReducer<{
+        payload: IdentifierRef[];
         type: string;
     }>;
-    mergeCatalogFilterParameters: CatalogReducer<{
-        payload: Record<string, IdentifierRef[]>;
+    markParameterDependenciesFailed: CatalogReducer<{
+        payload: 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,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"}
+{"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,EAErB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,kCAAkC,EACvC,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;AAiFF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAW3B,CAAC"}