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

package/esm/sdk-ui-dashboard.d.ts

@@ -1316,25 +1316,18 @@ export declare const catalogActions: {
     updateAttributeHierarchy: ActionCreatorWithPayload<ICatalogAttributeHierarchy, "catalog/updateAttributeHierarchy">;
     deleteAttributeHierarchy: ActionCreatorWithPayload<ICatalogAttributeHierarchy, "catalog/deleteAttributeHierarchy">;
     setCatalogParameters: ActionCreatorWithPayload<ICatalogParametersState, "catalog/setCatalogParameters">;
-    setCatalogInsightParameters: ActionCreatorWithPayload<ICatalogInsightParametersState, "catalog/setCatalogInsightParameters">;
-    mergeCatalogInsightParameters: ActionCreatorWithPayload<Record<string, IdentifierRef[]>, "catalog/mergeCatalogInsightParameters">;
-    setCatalogFilterParameters: ActionCreatorWithPayload<ICatalogFilterParametersState, "catalog/setCatalogFilterParameters">;
-    mergeCatalogFilterParameters: ActionCreatorWithPayload<Record<string, IdentifierRef[]>, "catalog/mergeCatalogFilterParameters">;
+    setCatalogParameterDependencies: ActionCreatorWithPayload<ICatalogParameterDependenciesState, "catalog/setCatalogParameterDependencies">;
+    mergeCatalogParameterDependencies: ActionCreatorWithPayload<Record<string, IdentifierRef[]>, "catalog/mergeCatalogParameterDependencies">;
+    markParameterDependenciesPending: ActionCreatorWithPayload<IdentifierRef[], "catalog/markParameterDependenciesPending">;
+    markParameterDependenciesFailed: ActionCreatorWithPayload<IdentifierRef[], "catalog/markParameterDependenciesFailed">;
 };
 
 /**
- * Status of the dashboard-wide dashboard-filter → parameter dependency map.
+ * Status of the dashboard-wide root → parameter dependency map.
  *
  * @alpha
  */
-export declare type CatalogFilterParametersStatus = "uninitialized" | "loading" | "loaded" | "failed";
-
-/**
- * Status of the dashboard-wide insight → parameter dependency map.
- *
- * @alpha
- */
-export declare type CatalogInsightParametersStatus = "uninitialized" | "loading" | "loaded" | "failed";
+export declare type CatalogParameterDependenciesStatus = "uninitialized" | "loaded";
 
 /**
  * Status of catalog parameters loading.
@@ -1369,9 +1362,7 @@ export declare type CatalogState = {
     /** @alpha */
     parameters: ICatalogParametersState;
     /** @alpha */
-    insightParameters: ICatalogInsightParametersState;
-    /** @alpha */
-    filterParameters: ICatalogFilterParametersState;
+    parameterDependencies: ICatalogParameterDependenciesState;
 };
 
 /**
@@ -8468,29 +8459,21 @@ export declare interface ICancelRenamingDashboardTabPayload {
 }
 
 /**
- * Maps each object a dashboard filter reads (keyed by `serializeObjRef(ref)`: the computed attribute
- * of an attribute filter, the metric or a computed-attribute dimension of a measure value filter) to
- * the parameter refs it depends on, as reported by the workspace references service. Complements
- * {@link ICatalogInsightParametersState} for the parameters a widget reaches only through dashboard
- * filters, which are not part of its insight.
- *
- * @alpha
- */
-export declare interface ICatalogFilterParametersState {
-    status: CatalogFilterParametersStatus;
-    byRef: Record<string, IdentifierRef[]>;
-}
-
-/**
- * Maps each dashboard insight (keyed by `serializeObjRef(insightRef)`) to the parameter refs it
- * depends on through its metrics and computed attributes, as reported by the workspace references
- * service. Drives runtime parameter applicability for widget execution.
+ * Maps each dependency root (an insight, a text reference, or an object a dashboard filter reads; keyed by
+ * `serializeObjRef` of the ref exactly as the caller supplied it) to the parameter refs it depends
+ * on through its metrics and computed attributes, as reported by the workspace references service.
+ * Drives runtime parameter applicability for execution and for display.
  *
  * @alpha
  */
-export declare interface ICatalogInsightParametersState {
-    status: CatalogInsightParametersStatus;
-    byInsight: Record<string, IdentifierRef[]>;
+export declare interface ICatalogParameterDependenciesState {
+    status: CatalogParameterDependenciesStatus;
+    byRoot: Record<string, IdentifierRef[]>;
+    /**
+     * Request status keyed by `serializeObjRef`. Successful loads clear the entry. Failed roots
+     * are skipped until initialization or an insight update requests them again.
+     */
+    requestedRoots: Record<string, "pending" | "failed">;
 }
 
 /**
@@ -27583,46 +27566,30 @@ export declare const selectCatalogDateDatasets: DashboardSelector<ICatalogDateDa
 export declare const selectCatalogFacts: DashboardSelector<ICatalogFact[]>;
 
 /**
- * Returns the dashboard-wide map from the serialized ref of an object a dashboard filter reads (a computed
- * attribute, a metric) to the parameter refs it depends on. Populated during dashboard initialization from
- * the workspace references service and extended when the filter context gains filters on other objects.
- *
  * @alpha
  */
-export declare const selectCatalogFilterParameters: DashboardSelector<Record<string, IdentifierRef[]>>;
+export declare const selectCatalogIsLoaded: DashboardSelector<boolean>;
 
 /**
- * Returns the load status of the dashboard-wide dashboard-filter → parameter dependency map.
- *
- * @alpha
+ * @public
  */
-export declare const selectCatalogFilterParametersStatus: DashboardSelector<CatalogFilterParametersStatus>;
+export declare const selectCatalogMeasures: DashboardSelector<ICatalogMeasure[]>;
 
 /**
- * Returns the dashboard-wide map from serialized insight ref to the parameter refs the insight depends on.
+ * Returns the dashboard-wide map from serialized root ref to the parameter refs that root depends on.
  * The map is populated during dashboard initialization from the workspace references service and extended
- * when insights are added later.
+ * when insights, text references, or dashboard filters add roots later.
  *
  * @alpha
  */
-export declare const selectCatalogInsightParameters: DashboardSelector<Record<string, IdentifierRef[]>>;
+export declare const selectCatalogParameterDependencies: DashboardSelector<Record<string, IdentifierRef[]>>;
 
 /**
- * Returns the load status of the dashboard-wide insight → parameter dependency map.
+ * Returns the load status of the dashboard-wide root → parameter dependency map.
  *
  * @alpha
  */
-export declare const selectCatalogInsightParametersStatus: DashboardSelector<CatalogInsightParametersStatus>;
-
-/**
- * @alpha
- */
-export declare const selectCatalogIsLoaded: DashboardSelector<boolean>;
-
-/**
- * @public
- */
-export declare const selectCatalogMeasures: DashboardSelector<ICatalogMeasure[]>;
+export declare const selectCatalogParameterDependenciesStatus: DashboardSelector<CatalogParameterDependenciesStatus>;
 
 /**
  * Returns the workspace parameters loaded into the dashboard catalog.
@@ -27645,6 +27612,13 @@ export declare const selectCatalogParametersIsLoaded: DashboardSelector<boolean>
  */
 export declare const selectCatalogParametersStatus: DashboardSelector<CatalogParametersStatus>;
 
+/**
+ * Returns pending and failed dependency requests, keyed by serialized root ref.
+ *
+ * @alpha
+ */
+export declare const selectCatalogRequestedParameterRoots: DashboardSelector<Record<string, "pending" | "failed">>;
+
 /**
  * Returns the color palette for dashboard charts.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-ui-dashboard",
-  "version": "11.58.0-alpha.4",
+  "version": "11.58.0-alpha.6",
   "description": "GoodData SDK - Dashboard Component",
   "license": "LicenseRef-LICENSE",
   "author": "GoodData Corporation",
@@ -60,20 +60,20 @@
     "ts-invariant": "0.10.3",
     "tslib": "2.8.1",
     "uuid": "11.1.1",
-    "@gooddata/sdk-backend-base": "11.58.0-alpha.4",
-    "@gooddata/sdk-backend-spi": "11.58.0-alpha.4",
-    "@gooddata/sdk-model": "11.58.0-alpha.4",
-    "@gooddata/sdk-ui": "11.58.0-alpha.4",
-    "@gooddata/sdk-ui-charts": "11.58.0-alpha.4",
-    "@gooddata/sdk-ui-ext": "11.58.0-alpha.4",
-    "@gooddata/sdk-ui-filters": "11.58.0-alpha.4",
-    "@gooddata/sdk-ui-geo": "11.58.0-alpha.4",
-    "@gooddata/sdk-ui-kit": "11.58.0-alpha.4",
-    "@gooddata/sdk-ui-pivot": "11.58.0-alpha.4",
-    "@gooddata/sdk-ui-semantic-search": "11.58.0-alpha.4",
-    "@gooddata/sdk-ui-theme-provider": "11.58.0-alpha.4",
-    "@gooddata/sdk-ui-vis-commons": "11.58.0-alpha.4",
-    "@gooddata/util": "11.58.0-alpha.4"
+    "@gooddata/sdk-ui": "11.58.0-alpha.6",
+    "@gooddata/sdk-backend-base": "11.58.0-alpha.6",
+    "@gooddata/sdk-model": "11.58.0-alpha.6",
+    "@gooddata/sdk-backend-spi": "11.58.0-alpha.6",
+    "@gooddata/sdk-ui-charts": "11.58.0-alpha.6",
+    "@gooddata/sdk-ui-ext": "11.58.0-alpha.6",
+    "@gooddata/sdk-ui-filters": "11.58.0-alpha.6",
+    "@gooddata/sdk-ui-kit": "11.58.0-alpha.6",
+    "@gooddata/sdk-ui-geo": "11.58.0-alpha.6",
+    "@gooddata/sdk-ui-theme-provider": "11.58.0-alpha.6",
+    "@gooddata/sdk-ui-pivot": "11.58.0-alpha.6",
+    "@gooddata/sdk-ui-vis-commons": "11.58.0-alpha.6",
+    "@gooddata/util": "11.58.0-alpha.6",
+    "@gooddata/sdk-ui-semantic-search": "11.58.0-alpha.6"
   },
   "devDependencies": {
     "@microsoft/api-documenter": "7.30.10",
@@ -115,12 +115,12 @@
     "typescript": "7.0.2",
     "vitest": "4.1.11",
     "vitest-dom": "0.1.1",
-    "@gooddata/eslint-config": "11.58.0-alpha.4",
-    "@gooddata/i18n-toolkit": "11.58.0-alpha.4",
-    "@gooddata/oxlint-config": "11.58.0-alpha.4",
-    "@gooddata/reference-workspace": "11.58.0-alpha.4",
-    "@gooddata/sdk-backend-mockingbird": "11.58.0-alpha.4",
-    "@gooddata/stylelint-config": "11.58.0-alpha.4"
+    "@gooddata/i18n-toolkit": "11.58.0-alpha.6",
+    "@gooddata/oxlint-config": "11.58.0-alpha.6",
+    "@gooddata/eslint-config": "11.58.0-alpha.6",
+    "@gooddata/stylelint-config": "11.58.0-alpha.6",
+    "@gooddata/reference-workspace": "11.58.0-alpha.6",
+    "@gooddata/sdk-backend-mockingbird": "11.58.0-alpha.6"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",

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

@@ -1,45 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,99 +0,0 @@
-// (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

@@ -1,11 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,71 +0,0 @@
-// (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

@@ -1,22 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,39 +0,0 @@
-// (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

@@ -1,21 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,86 +0,0 @@
-// (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;
-}