@gooddata/sdk-ui-analytical-designer 0.0.0-stage → 11.65.0-alpha.7

package/esm/store/recommendations/recommendations_sagas.js

@@ -0,0 +1,51 @@
+// (C) 2019-2026 GoodData Corporation
+import { call, put, select, takeEvery } from "redux-saga/effects";
+import { openFilterDropdown } from "../filter_bar/filter_bar_actions.js";
+import { applyComparison, applyComparisonWithPeriod, applyContributionInPercents, applyFiltering, applyMetricWithPeriod, applyTrending, dismissRecommendations, storeApplyComparison, storeApplyComparisonWithPeriod, storeApplyContributionInPercents, storeApplyMetricWithPeriod, storeApplyTrending, storeDismissRecommendations, } from "./recommendations_actions.js";
+import { getDismissedRecommendations } from "./recommendations_selector.js";
+function* handleApplyComparisonWithPeriod(action) {
+    const { granularity } = action.payload;
+    yield put(storeApplyComparisonWithPeriod(granularity));
+}
+function* handleApplyContributionInPercent() {
+    yield put(storeApplyContributionInPercents());
+}
+function* handleApplyMetricWithPeriod() {
+    yield put(storeApplyMetricWithPeriod());
+}
+function* handleApplyTrending(action) {
+    const { granularity } = action.payload;
+    yield put(storeApplyTrending(granularity));
+}
+function* handleApplyComparison(action) {
+    const { attributeRef } = action.payload;
+    yield put(storeApplyComparison(attributeRef));
+}
+function* handleApplyFiltering() {
+    yield put(openFilterDropdown());
+}
+export function* handleDismissRecommendations(action) {
+    const { visClass } = action.payload;
+    yield put(storeDismissRecommendations(visClass));
+    // Persistence side effect: it lives here rather than in the reducer, which must stay
+    // side-effect free. The put above has already been reduced, so the selector sees the updated
+    // list.
+    const dismissed = yield select(getDismissedRecommendations);
+    try {
+        yield call([localStorage, "setItem"], "dismissedRecommendations", JSON.stringify(dismissed));
+    }
+    catch (error) {
+        // best-effort persistence (storage may be blocked or full): the dismissal is already
+        // applied in redux state, so a persistence failure must not kill the watcher
+        console.warn("Failed to persist dismissed recommendations", error);
+    }
+}
+export function* watchRecommendations() {
+    yield takeEvery(applyComparisonWithPeriod.match, handleApplyComparisonWithPeriod);
+    yield takeEvery(applyContributionInPercents.match, handleApplyContributionInPercent);
+    yield takeEvery(applyMetricWithPeriod.match, handleApplyMetricWithPeriod);
+    yield takeEvery(applyTrending.match, handleApplyTrending);
+    yield takeEvery(applyComparison.match, handleApplyComparison);
+    yield takeEvery(applyFiltering.match, handleApplyFiltering);
+    yield takeEvery(dismissRecommendations.match, handleDismissRecommendations);
+}

package/esm/store/recommendations/recommendations_selector.d.ts

@@ -0,0 +1,3 @@
+import { type IAppState } from "../types.js";
+export declare const getDismissedRecommendations: (state: IAppState) => import("./recommendations_state.js").IDismissedRecommendationsState;
+//# sourceMappingURL=recommendations_selector.d.ts.map

package/esm/store/recommendations/recommendations_selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommendations_selector.d.ts","sourceRoot":"","sources":["../../../src/store/recommendations/recommendations_selector.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,eAAO,MAAM,2BAA2B,UAAW,SAAS,wEAA4C,CAAC"}

package/esm/store/recommendations/recommendations_selector.js

@@ -0,0 +1,2 @@
+// (C) 2026 GoodData Corporation
+export const getDismissedRecommendations = (state) => state.appState.dismissedRecommendations;

package/esm/store/recommendations/recommendations_slice.d.ts

@@ -0,0 +1,4 @@
+import { type Reducer } from "redux";
+import { type IDismissedRecommendationsState } from "./recommendations_state.js";
+export declare const recommendationsSliceReducer: Reducer<IDismissedRecommendationsState>;
+//# sourceMappingURL=recommendations_slice.d.ts.map

package/esm/store/recommendations/recommendations_slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommendations_slice.d.ts","sourceRoot":"","sources":["../../../src/store/recommendations/recommendations_slice.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,OAAO,CAAC;AAGrC,OAAO,EACH,KAAK,8BAA8B,EAEtC,MAAM,4BAA4B,CAAC;AAiBpC,eAAO,MAAM,2BAA2B,EAAE,OAAO,CAAC,8BAA8B,CAChD,CAAC"}

package/esm/store/recommendations/recommendations_slice.js

@@ -0,0 +1,18 @@
+// (C) 2026 GoodData Corporation
+import { createSlice } from "@reduxjs/toolkit";
+import { uniq } from "lodash-es";
+import { storeDismissRecommendations } from "./recommendations_actions.js";
+import { dismissedRecommendationsInitialState, } from "./recommendations_state.js";
+const recommendationsSlice = createSlice({
+    name: "recommendations",
+    initialState: dismissedRecommendationsInitialState,
+    // (those get RTK's `${name}/${key}` type strings).
+    reducers: {},
+    extraReducers: (builder) => {
+        // Returned rather than mutated: dedup replaces the whole array. The localStorage
+        // the persistence lives in recommendations_sagas.ts —
+        // reducers stay side-effect free.
+        builder.addCase(storeDismissRecommendations, (state, action) => uniq([...state, action.payload.visClass]));
+    },
+});
+export const recommendationsSliceReducer = recommendationsSlice.reducer;

package/esm/store/recommendations/recommendations_state.d.ts

@@ -0,0 +1,3 @@
+export type IDismissedRecommendationsState = string[];
+export declare const dismissedRecommendationsInitialState: IDismissedRecommendationsState;
+//# sourceMappingURL=recommendations_state.d.ts.map

package/esm/store/recommendations/recommendations_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommendations_state.d.ts","sourceRoot":"","sources":["../../../src/store/recommendations/recommendations_state.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,8BAA8B,GAAG,MAAM,EAAE,CAAC;AAetD,eAAO,MAAM,oCAAoC,EAAE,8BACjB,CAAC"}

package/esm/store/recommendations/recommendations_state.js

@@ -0,0 +1,15 @@
+// (C) 2026 GoodData Corporation
+// Seeded from localStorage at module load, and hardened against a missing localStorage binding,
+// corrupt JSON, or a non-array value (which would break the slice's spread). The matching
+// persistence WRITE lives in recommendations_sagas.ts.
+function readDismissedRecommendations() {
+    try {
+        const stored = globalThis.localStorage?.getItem("dismissedRecommendations");
+        const parsed = stored ? JSON.parse(stored) : [];
+        return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+export const dismissedRecommendationsInitialState = readDismissedRecommendations();

package/esm/store/reference_point/extended_reference_point_helpers.d.ts

@@ -0,0 +1,51 @@
+import { type IOpenAsReportUiConfig } from "@gooddata/sdk-ui";
+import { type IVisualizationProperties } from "@gooddata/sdk-ui-ext/internal";
+import { type IRawBuckets } from "../../typings/buckets.js";
+import { type IExtendedReferencePointState } from "./extended_reference_point_state.js";
+/**
+ * Narrow pure operations over `data.extendedReferencePoint`.
+ *
+ * The subtree holds what the pluggable-visualization round trip answered. Almost nothing edits it
+ * from the AD side — the exception is the sort-item validation below, which every buckets mutation
+ * runs, and which was a `(state) => State` transformer on `services/buckets_service.ts`.
+ *
+ * It lives with the ERP rather than with the buckets because the ERP is what it ANSWERS: the buckets
+ * only supply the validity set. `buckets` is taken whole rather than as a pre-computed identifier list
+ * so the caller cannot pass the wrong set — the derived read it needs is one call away and shared with
+ * every other consumer (the 4.10 one-implementation rule).
+ */
+/**
+ * Drops the sort items that no longer name a bucket item.
+ *
+ * A sort item survives when ANY of the identifiers it references is still in the buckets. That is
+ * deliberately permissive: an attribute-area sort references a measure and an attribute, and the sort
+ * stays meaningful while either of them is there.
+ *
+ * Absence handling is reproduced exactly, and it is the subtle part. The extended reference point
+ * stays ABSENT until a plug viz reports one, and this transformer is nevertheless called on such
+ * states (the removal chain and the bucket-filters reducer both run it unconditionally):
+ *
+ * - the READ defaults to `[]` only for an ABSENT key: a `sortItems` key present and set to
+ *   `undefined` is answered as `undefined` and the `.filter` below then throws. That is deliberate —
+ *   converting it into a silent empty list would mask a malformed round-trip payload;
+ * - the WRITE creates the missing intermediates, so an undefined extended reference point becomes
+ *   `{ properties: { sortItems: [] } }` and no caller has to materialize the container first.
+ */
+export declare function validateVisualizationProperties(extendedReferencePoint: IExtendedReferencePointState | undefined, buckets: IRawBuckets): IExtendedReferencePointState;
+/**
+ * `VIS_PROPERTIES_INITIALIZED`'s extended-reference-point half — a plain leaf case: this subtree is
+ * the only foreign one the trigger writes, and it reads nothing but its own value and the payload.
+ *
+ * The stored `properties` are always dropped first, then re-written when the sanitized push kept
+ * anything — the properties RULE is the properties domain's ({@link sanitizeInitializedProperties}).
+ * An absent extended reference point is materialized only when there is something to store, and a
+ * push that changes nothing answers the ORIGINAL reference.
+ */
+export declare function initializeVisualizationProperties(extendedReferencePoint: IExtendedReferencePointState | undefined, supportedProperties: IVisualizationProperties): IExtendedReferencePointState | undefined;
+/**
+ * `OPEN_AS_REPORT_TOGGLED` — a leaf case: two primitive writes into the uiConfig, nothing else.
+ * The missing intermediates are MATERIALIZED (the ERP may be absent before the first plug-viz
+ * answer), and a repeated toggle with the same answer returns the same state.
+ */
+export declare function toggleOpenAsReport(extendedReferencePoint: IExtendedReferencePointState | undefined, { supported, warningMessage }: IOpenAsReportUiConfig): IExtendedReferencePointState;
+//# sourceMappingURL=extended_reference_point_helpers.d.ts.map

package/esm/store/reference_point/extended_reference_point_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extended_reference_point_helpers.d.ts","sourceRoot":"","sources":["../../../src/store/reference_point/extended_reference_point_helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAE9E,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAK5D,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,qCAAqC,CAAC;AAExF;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,+BAA+B,CAC3C,sBAAsB,EAAE,4BAA4B,GAAG,SAAS,EAChE,OAAO,EAAE,WAAW,GACrB,4BAA4B,CAgB9B;AAED;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,CAC7C,sBAAsB,EAAE,4BAA4B,GAAG,SAAS,EAChE,mBAAmB,EAAE,wBAAwB,GAC9C,4BAA4B,GAAG,SAAS,CAe1C;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAC9B,sBAAsB,EAAE,4BAA4B,GAAG,SAAS,EAChE,EAAE,SAAS,EAAE,cAAc,EAAE,EAAE,qBAAqB,GACrD,4BAA4B,CAiB9B"}

package/esm/store/reference_point/extended_reference_point_helpers.js

@@ -0,0 +1,90 @@
+// (C) 2026 GoodData Corporation
+import { getSortItemIdentifiers } from "../../utils/visualization_properties.js";
+import { getBucketItemLocalIdentifiersInBuckets } from "../buckets/buckets_read_helpers.js";
+import { sanitizeInitializedProperties } from "../properties/properties_helpers.js";
+/**
+ * Narrow pure operations over `data.extendedReferencePoint`.
+ *
+ * The subtree holds what the pluggable-visualization round trip answered. Almost nothing edits it
+ * from the AD side — the exception is the sort-item validation below, which every buckets mutation
+ * runs, and which was a `(state) => State` transformer on `services/buckets_service.ts`.
+ *
+ * It lives with the ERP rather than with the buckets because the ERP is what it ANSWERS: the buckets
+ * only supply the validity set. `buckets` is taken whole rather than as a pre-computed identifier list
+ * so the caller cannot pass the wrong set — the derived read it needs is one call away and shared with
+ * every other consumer (the 4.10 one-implementation rule).
+ */
+/**
+ * Drops the sort items that no longer name a bucket item.
+ *
+ * A sort item survives when ANY of the identifiers it references is still in the buckets. That is
+ * deliberately permissive: an attribute-area sort references a measure and an attribute, and the sort
+ * stays meaningful while either of them is there.
+ *
+ * Absence handling is reproduced exactly, and it is the subtle part. The extended reference point
+ * stays ABSENT until a plug viz reports one, and this transformer is nevertheless called on such
+ * states (the removal chain and the bucket-filters reducer both run it unconditionally):
+ *
+ * - the READ defaults to `[]` only for an ABSENT key: a `sortItems` key present and set to
+ *   `undefined` is answered as `undefined` and the `.filter` below then throws. That is deliberate —
+ *   converting it into a silent empty list would mask a malformed round-trip payload;
+ * - the WRITE creates the missing intermediates, so an undefined extended reference point becomes
+ *   `{ properties: { sortItems: [] } }` and no caller has to materialize the container first.
+ */
+export function validateVisualizationProperties(extendedReferencePoint, buckets) {
+    const sortItems = extendedReferencePoint?.properties?.sortItems ?? [];
+    const validLocalIdentifiers = getBucketItemLocalIdentifiersInBuckets(buckets);
+    const newSortItems = sortItems.filter((sortItem) => {
+        const identifiers = getSortItemIdentifiers(sortItem);
+        return validLocalIdentifiers.some((localIdentifier) => identifiers.includes(localIdentifier));
+    });
+    // The filter always allocates, so this always writes; both containers are MATERIALIZED when
+    // absent, which is what lets an undefined extended reference point become
+    // `{ properties: { sortItems: [] } }` without any caller seeding it first.
+    return {
+        ...extendedReferencePoint,
+        properties: { ...extendedReferencePoint?.properties, sortItems: newSortItems },
+    };
+}
+/**
+ * `VIS_PROPERTIES_INITIALIZED`'s extended-reference-point half — a plain leaf case: this subtree is
+ * the only foreign one the trigger writes, and it reads nothing but its own value and the payload.
+ *
+ * The stored `properties` are always dropped first, then re-written when the sanitized push kept
+ * anything — the properties RULE is the properties domain's ({@link sanitizeInitializedProperties}).
+ * An absent extended reference point is materialized only when there is something to store, and a
+ * push that changes nothing answers the ORIGINAL reference.
+ */
+export function initializeVisualizationProperties(extendedReferencePoint, supportedProperties) {
+    const validProperties = sanitizeInitializedProperties(supportedProperties);
+    let next = extendedReferencePoint;
+    // TRUTHY, not existence, which is what the readers below rely on
+    if (next?.properties) {
+        const { properties: _dropped, ...withoutProperties } = next;
+        next = withoutProperties;
+    }
+    if (validProperties && next?.properties !== validProperties) {
+        next = { ...next, properties: validProperties };
+    }
+    return next;
+}
+/**
+ * `OPEN_AS_REPORT_TOGGLED` — a leaf case: two primitive writes into the uiConfig, nothing else.
+ * The missing intermediates are MATERIALIZED (the ERP may be absent before the first plug-viz
+ * answer), and a repeated toggle with the same answer returns the same state.
+ */
+export function toggleOpenAsReport(extendedReferencePoint, { supported, warningMessage }) {
+    const openAsReport = extendedReferencePoint?.uiConfig?.openAsReport;
+    if (extendedReferencePoint &&
+        openAsReport?.supported === supported &&
+        openAsReport?.warningMessage === warningMessage) {
+        return extendedReferencePoint;
+    }
+    return {
+        ...extendedReferencePoint,
+        uiConfig: {
+            ...extendedReferencePoint?.uiConfig,
+            openAsReport: { ...openAsReport, supported, warningMessage },
+        },
+    };
+}

package/esm/store/reference_point/extended_reference_point_selectors.d.ts

@@ -0,0 +1,45 @@
+import { type ChartType, type OverTimeComparisonType } from "@gooddata/sdk-ui";
+import { type IStoredVisualizationProperties, type IVisualizationPropertiesControls } from "../../typings/properties.js";
+import { type IFilter } from "../filter_bar/filter_bar_types.js";
+import { type IAppState } from "../types.js";
+import { type IExtendedRefPointBuckets, type IExtendedRefPointBucketsUiConfig, type IExtendedRefPointCustomError, type IExtendedRefPointUiConfig } from "./extended_reference_point_state.js";
+/**
+ * `undefined` when no pluggable visualization has answered yet, and that is LOAD-BEARING: two
+ * consumers fall back to the regular buckets with `bucketsExtended || buckets`
+ * (`getDecoratedBucketsExtended`, `getUsedDateDatasetsExtendedFromBuckets`), and `[]` is truthy —
+ * defaulting here would hide the regular buckets instead. Hence no default, and an OPTIONAL
+ * return type so the compiler says so.
+ */
+export declare const getExtendedReferencePointBuckets: (state: IAppState) => IExtendedRefPointBuckets | undefined;
+/** The FILTER BAR's filters — the ERP's own `filters` bucket is replaced on write (see the state module). */
+export declare const getExtendedReferencePointFilters: (state: IAppState) => ReadonlyArray<IFilter> | undefined;
+export declare const getExtendedReferencePointProperties: (state: IAppState) => IStoredVisualizationProperties | undefined;
+export declare const getExtendedReferencePointPropertiesControls: (state: IAppState) => IVisualizationPropertiesControls | undefined;
+export declare const isExtendedReferencePointStackToPercent: (state: IAppState) => boolean;
+export declare const getExtendedReferencePointSecondaryXAxisMeasures: (state: IAppState, notSetValue: string[]) => string[];
+export declare const getExtendedReferencePointSecondaryYAxisMeasures: (state: IAppState, notSetValue: string[]) => string[];
+export declare const getUiConfigBuckets: (state: IAppState) => IExtendedRefPointBucketsUiConfig | undefined;
+/** A single bucket's uiConfig flag, e.g. `allowShowOnSecondaryAxis` for MEASURES. */
+export declare const getUiConfigBucketFlag: <T>(state: IAppState, bucketLocalIdentifier: string, flag: string, notSetValue?: T) => T;
+export declare const getUiConfigAxis: (state: IAppState, notSetValue: string) => string;
+export declare const getUiConfigCustomError: (state: IAppState) => IExtendedRefPointCustomError;
+export declare const getUiConfigEmptyCanvasDragTypes: (state: IAppState) => string[] | undefined;
+export declare const isUiConfigExportConfigSupported: (state: IAppState) => boolean;
+export declare const isUiConfigNoMetricSupported: (state: IAppState) => boolean;
+export declare const getUiConfigSupportedChartTypes: (state: IAppState, notSetValue: ChartType[]) => ChartType[];
+export declare const getUiConfigSupportedOverTimeComparisonTypes: (state: IAppState, notSetValue: OverTimeComparisonType[]) => OverTimeComparisonType[];
+export declare const isUiConfigChartFillSupported: (state: IAppState) => boolean;
+export declare const getUiConfigLocationIcon: (state: IAppState) => IExtendedRefPointUiConfig["supportedLocationIcon"];
+export declare const isUiConfigLocationIconSupported: (state: IAppState) => boolean;
+export declare const isUiConfigOptionalStackingSupported: (state: IAppState) => boolean;
+export declare const isUiConfigOptionalStackingDisabled: (state: IAppState) => boolean;
+export declare const getUiConfigOptionalStackingStackMeasures: (state: IAppState, notSetValue?: boolean) => boolean;
+export declare const getUiConfigOptionalStackingStackMeasuresToPercent: (state: IAppState, notSetValue?: boolean) => boolean;
+/** Defaults to TRUE — a visualization that never reported the flag can stack in percent. */
+export declare const canUiConfigStackInPercent: (state: IAppState) => boolean;
+export declare const getUiConfigOptionalStackingStackToPercentVisible: (state: IAppState) => boolean | undefined;
+export declare const getUiConfigRecommendation: (state: IAppState, recommendation: string) => boolean;
+export declare const isFilteringRecommendationSupported: (state: IAppState) => boolean;
+export declare const isOpenAsReportSupported: (state: IAppState) => boolean;
+export declare const getOpenAsReportWarningMessage: (state: IAppState) => string;
+//# sourceMappingURL=extended_reference_point_selectors.d.ts.map

package/esm/store/reference_point/extended_reference_point_selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extended_reference_point_selectors.d.ts","sourceRoot":"","sources":["../../../src/store/reference_point/extended_reference_point_selectors.ts"],"names":[],"mappings":"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"}

package/esm/store/reference_point/extended_reference_point_selectors.js

@@ -0,0 +1,65 @@
+// (C) 2026 GoodData Corporation
+/**
+ * The extended reference point's read layer.
+ *
+ * ONE place that knows where the plug-viz round trip's answers live. Every accessor is
+ * OPTIONAL-CHAINED PROPERTY ACCESS off the typed root, so every hop is checked against the domain's
+ * own state type and a renamed `uiConfig` key is a compile error rather than a silent `undefined`.
+ *
+ * `data.extendedReferencePoint` is `null` until a pluggable visualization answers, and every field
+ * below it is optional — hence the `?.` on every chain. It is not defensive coding: the state type
+ * says the value may not be there, and each accessor's return type says the same to its callers.
+ *
+ * The `notSetValue` defaults are part of the contract: several of them (`canStackInPercent` = true,
+ * `axis` = primary) are NOT the falsy default, so they have to live here rather than at each caller.
+ * `??` still passes a stored `false`/`0` through.
+ */
+const erp = (state) => state.data.extendedReferencePoint;
+const controls = (state) => erp(state)?.properties?.controls;
+const uiConfig = (state) => erp(state)?.uiConfig;
+const optionalStacking = (state) => uiConfig(state)?.optionalStacking;
+// ------------------------------------------------------------------ buckets / filters / props
+/**
+ * `undefined` when no pluggable visualization has answered yet, and that is LOAD-BEARING: two
+ * consumers fall back to the regular buckets with `bucketsExtended || buckets`
+ * (`getDecoratedBucketsExtended`, `getUsedDateDatasetsExtendedFromBuckets`), and `[]` is truthy —
+ * defaulting here would hide the regular buckets instead. Hence no default, and an OPTIONAL
+ * return type so the compiler says so.
+ */
+export const getExtendedReferencePointBuckets = (state) => erp(state)?.buckets;
+/** The FILTER BAR's filters — the ERP's own `filters` bucket is replaced on write (see the state module). */
+export const getExtendedReferencePointFilters = (state) => erp(state)?.filters;
+export const getExtendedReferencePointProperties = (state) => erp(state)?.properties;
+export const getExtendedReferencePointPropertiesControls = (state) => controls(state);
+export const isExtendedReferencePointStackToPercent = (state) => controls(state)?.["stackMeasuresToPercent"] ?? false;
+export const getExtendedReferencePointSecondaryXAxisMeasures = (state, notSetValue) => controls(state)?.["secondary_xaxis"]?.measures ?? notSetValue;
+export const getExtendedReferencePointSecondaryYAxisMeasures = (state, notSetValue) => controls(state)?.["secondary_yaxis"]?.measures ?? notSetValue;
+// -------------------------------------------------------------------------------- uiConfig
+export const getUiConfigBuckets = (state) => uiConfig(state)?.buckets;
+/** A single bucket's uiConfig flag, e.g. `allowShowOnSecondaryAxis` for MEASURES. */
+export const getUiConfigBucketFlag = (state, bucketLocalIdentifier, flag, notSetValue) => uiConfig(state)?.buckets?.[bucketLocalIdentifier]?.[flag] ?? notSetValue;
+export const getUiConfigAxis = (state, notSetValue) => uiConfig(state)?.axis ?? notSetValue;
+export const getUiConfigCustomError = (state) => uiConfig(state)?.customError;
+export const getUiConfigEmptyCanvasDragTypes = (state) => uiConfig(state)?.supportedEmptyCanvasDragTypes;
+export const isUiConfigExportConfigSupported = (state) => uiConfig(state)?.exportConfig?.supported ?? false;
+export const isUiConfigNoMetricSupported = (state) => uiConfig(state)?.noMetricAccepted?.supported ?? false;
+export const getUiConfigSupportedChartTypes = (state, notSetValue) => uiConfig(state)?.supportedChartTypes ?? notSetValue;
+export const getUiConfigSupportedOverTimeComparisonTypes = (state, notSetValue) => uiConfig(state)?.supportedOverTimeComparisonTypes ?? notSetValue;
+export const isUiConfigChartFillSupported = (state) => uiConfig(state)?.supportsChartFill ?? false;
+export const getUiConfigLocationIcon = (state) => uiConfig(state)?.supportedLocationIcon;
+export const isUiConfigLocationIconSupported = (state) => uiConfig(state)?.supportedLocationIcon?.supported ?? false;
+// -------------------------------------------------------------------- uiConfig.optionalStacking
+export const isUiConfigOptionalStackingSupported = (state) => optionalStacking(state)?.supported ?? false;
+export const isUiConfigOptionalStackingDisabled = (state) => optionalStacking(state)?.disabled ?? false;
+export const getUiConfigOptionalStackingStackMeasures = (state, notSetValue) => optionalStacking(state)?.stackMeasures ?? notSetValue;
+export const getUiConfigOptionalStackingStackMeasuresToPercent = (state, notSetValue) => optionalStacking(state)?.stackMeasuresToPercent ?? notSetValue;
+/** Defaults to TRUE — a visualization that never reported the flag can stack in percent. */
+export const canUiConfigStackInPercent = (state) => optionalStacking(state)?.canStackInPercent ?? true;
+export const getUiConfigOptionalStackingStackToPercentVisible = (state) => optionalStacking(state)?.stackToPercentVisible;
+// ------------------------------------------------------------------- uiConfig.recommendations
+export const getUiConfigRecommendation = (state, recommendation) => (uiConfig(state)?.recommendations?.[recommendation] ??
+    false);
+export const isFilteringRecommendationSupported = (state) => uiConfig(state)?.recommendations?.["supportsFilteringRecommendation"] ?? false;
+// --------------------------------------------------------------------- uiConfig.openAsReport
+export const isOpenAsReportSupported = (state) => uiConfig(state)?.openAsReport?.supported ?? false;
+export const getOpenAsReportWarningMessage = (state) => uiConfig(state)?.openAsReport?.warningMessage;

package/esm/store/reference_point/extended_reference_point_state.d.ts

@@ -0,0 +1,87 @@
+import { type ObjRef } from "@gooddata/sdk-model";
+import { type IAvailableSortsGroup, type IBucketItem, type IExtendedReferencePoint } from "@gooddata/sdk-ui-ext/internal";
+import { type GeoLabelType } from "../../constants/geo.js";
+import { type IStoredVisualizationProperties } from "../../typings/properties.js";
+import { type IFilter } from "../filter_bar/filter_bar_types.js";
+/**
+ * `data.extendedReferencePoint` holds what the pluggable-visualization round trip answered, with
+ * TWO AD-side edits applied before it is stored:
+ *
+ * - `filters` is REPLACED by the filter bar's own filters (`convertFromExtendedRefPointFilters`),
+ *   so it is NOT the SDK's `IFilters` bucket — hence the `Omit` below rather than a plain extend;
+ * - `buckets` goes through the geo display-form normalization, which reads and writes keys the
+ *   SDK's `IBucketItem` does not declare (`displayForm`, the geo ref pair).
+ *
+ * Everything else is the SDK contract, so the types are DERIVED from it (`uiConfig` is not
+ * exported from the internal barrel; indexed access is how the app already reached it — see
+ * selectors/ui_config_selector.ts). The value stays `null` in the store until a pluggable
+ * visualization reports one back, and reads as `undefined` through the input selector: several
+ * readers distinguish "exists" from "does not", so every accessor tolerates the absence and the
+ * container is NOT self-initialized.
+ */
+type SdkUiConfig = NonNullable<IExtendedReferencePoint["uiConfig"]>;
+type SdkBucketUiConfig = SdkUiConfig["buckets"][string];
+/**
+ * The uiConfig types are declared as INTERFACES that extend the SDK's, not as aliases to them.
+ * `IUiConfig`/`IBucketsUiConfig`/`IBucketUiConfig` are not on sdk-ui-ext's internal barrel, so an
+ * ALIAS to one of them cannot be NAMED by a consumer whose type is inferred — the compiler reaches
+ * for the deep `node_modules/@gooddata/sdk-ui-ext/esm/...` path and rejects it as non-portable
+ * (TS2742). Extending gives every consumer a nameable declaration in this module.
+ */
+export interface IExtendedRefPointBucketUiConfig extends SdkBucketUiConfig {
+    /** re-declared verbatim: the item types the bucket takes, read by the drag-and-drop rules */
+    accepts?: string[];
+}
+export interface IExtendedRefPointBucketsUiConfig {
+    [localIdentifier: string]: IExtendedRefPointBucketUiConfig;
+}
+export interface IExtendedRefPointUiConfig extends Omit<SdkUiConfig, "buckets" | "supportedLocationIcon"> {
+    buckets: IExtendedRefPointBucketsUiConfig;
+    /**
+     * `type` is the geo label kind AD resolves the location icon from
+     * (services/reference_point_service.ts#getActiveGeoLabelType); the SDK declares only
+     * `supported`.
+     */
+    supportedLocationIcon?: {
+        supported?: boolean;
+        type?: GeoLabelType;
+    };
+}
+/** Nameable for the same TS2742 reason as the uiConfig interfaces above. */
+export interface IExtendedRefPointCustomError extends NonNullable<SdkUiConfig["customError"]> {
+    /** re-declared verbatim: the error heading the empty canvas renders */
+    heading: string;
+}
+/**
+ * A display form as the round trip carries it. `IDisplayForm` is not on the internal barrel, so
+ * the type is derived from the bucket item that holds it; `isPrimary` is AD's own addition, read
+ * by the geo display-form normalization.
+ */
+export type IExtendedRefPointDisplayForm = NonNullable<IBucketItem["displayForms"]>[number] & {
+    isPrimary?: boolean;
+};
+/**
+ * An ERP bucket item. `displayForm` is the resolved display form the round trip echoes back next
+ * to `dfRef`; the geo normalization deletes it for geo buckets and rewrites it for text ones.
+ */
+export interface IExtendedRefPointBucketItem extends Omit<IBucketItem, "displayForms"> {
+    displayForm?: ObjRef;
+    displayForms?: IExtendedRefPointDisplayForm[];
+}
+export interface IExtendedRefPointBucket {
+    localIdentifier?: string;
+    items?: IExtendedRefPointBucketItem[];
+    totals?: Array<Record<string, unknown>>;
+    chartType?: string;
+}
+export type IExtendedRefPointBuckets = IExtendedRefPointBucket[];
+export interface IExtendedReferencePointState {
+    buckets?: IExtendedRefPointBuckets;
+    /** the FILTER BAR's filters, not the SDK's `IFilters` bucket (see the module comment) */
+    filters?: ReadonlyArray<IFilter>;
+    properties?: IStoredVisualizationProperties;
+    uiConfig?: IExtendedRefPointUiConfig;
+    availableSorts?: IAvailableSortsGroup[];
+}
+export {};
+//# sourceMappingURL=extended_reference_point_state.d.ts.map

package/esm/store/reference_point/extended_reference_point_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extended_reference_point_state.d.ts","sourceRoot":"","sources":["../../../src/store/reference_point/extended_reference_point_state.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EACH,KAAK,oBAAoB,EACzB,KAAK,WAAW,EAChB,KAAK,uBAAuB,EAC/B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,KAAK,8BAA8B,EAAE,MAAM,6BAA6B,CAAC;AAClF,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAEjE;;;;;;;;;;;;;;;GAeG;AAEH,KAAK,WAAW,GAAG,WAAW,CAAC,uBAAuB,CAAC,UAAU,CAAC,CAAC,CAAC;AACpE,KAAK,iBAAiB,GAAG,WAAW,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD;;;;;;GAMG;AACH,MAAM,WAAW,+BAAgC,SAAQ,iBAAiB;IACtE,6FAA6F;IAC7F,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,gCAAgC;IAC7C,CAAC,eAAe,EAAE,MAAM,GAAG,+BAA+B,CAAC;CAC9D;AAED,MAAM,WAAW,yBAA0B,SAAQ,IAAI,CAAC,WAAW,EAAE,SAAS,GAAG,uBAAuB,CAAC;IACrG,OAAO,EAAE,gCAAgC,CAAC;IAC1C;;;;OAIG;IACH,qBAAqB,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,YAAY,CAAA;KAAE,CAAC;CACxE;AAED,4EAA4E;AAC5E,MAAM,WAAW,4BAA6B,SAAQ,WAAW,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IACzF,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,MAAM,4BAA4B,GAAG,WAAW,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG;IAC1F,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,2BAA4B,SAAQ,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC;IAClF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,4BAA4B,EAAE,CAAC;CACjD;AAED,MAAM,WAAW,uBAAuB;IACpC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,2BAA2B,EAAE,CAAC;IACtC,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,wBAAwB,GAAG,uBAAuB,EAAE,CAAC;AAEjE,MAAM,WAAW,4BAA4B;IACzC,OAAO,CAAC,EAAE,wBAAwB,CAAC;IACnC,yFAAyF;IACzF,OAAO,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,8BAA8B,CAAC;IAC5C,QAAQ,CAAC,EAAE,yBAAyB,CAAC;IACrC,cAAc,CAAC,EAAE,oBAAoB,EAAE,CAAC;CAC3C"}

package/esm/store/reference_point/extended_reference_point_state.js

@@ -0,0 +1,2 @@
+// (C) 2026 GoodData Corporation
+export {};

package/esm/store/reference_point/reference_point_selectors.d.ts

@@ -0,0 +1,20 @@
+import { type IRawBuckets } from "../../typings/buckets.js";
+import { type IAppState } from "../types.js";
+import { type IExtendedReferencePointState } from "./extended_reference_point_state.js";
+import { type IRefPointFiltersBucket, type IReferencePointState } from "./reference_point_state.js";
+/**
+ * The reference-point cluster's read layer.
+ *
+ * `referencePoint` always exists — the combined root owns the key with the domain's slice. The
+ * EXTENDED reference point deliberately does NOT: the readers distinguish "absent" from "empty", so
+ * it reads as `undefined` until a pluggable visualization reports one (the store holds `null` at
+ * rest; this boundary converts — see extended_reference_point_state.ts), and every reader must
+ * tolerate that.
+ */
+export declare const getReferencePoint: (state: IAppState) => IReferencePointState;
+export declare const getExtendedReferencePoint: (state: IAppState) => IExtendedReferencePointState | undefined;
+/** `referencePoint.buckets` holds the live buckets BY REFERENCE. */
+export declare const getReferencePointBuckets: (state: IAppState) => IRawBuckets;
+/** The filters bucket rebuilt from the filter bar on every buckets mutation. */
+export declare const getReferencePointFilters: (state: IAppState) => IRefPointFiltersBucket | undefined;
+//# sourceMappingURL=reference_point_selectors.d.ts.map

package/esm/store/reference_point/reference_point_selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference_point_selectors.d.ts","sourceRoot":"","sources":["../../../src/store/reference_point/reference_point_selectors.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,qCAAqC,CAAC;AACxF,OAAO,EAAE,KAAK,sBAAsB,EAAE,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEpG;;;;;;;;GAQG;AAEH,eAAO,MAAM,iBAAiB,UAAW,SAAS,KAAG,oBAAiD,CAAC;AAEvG,eAAO,MAAM,yBAAyB,UAAW,SAAS,KAAG,4BAA4B,GAAG,SAC1C,CAAC;AAEnD,oEAAoE;AACpE,eAAO,MAAM,wBAAwB,UAAW,SAAS,KAAG,WAAgD,CAAC;AAE7G,gFAAgF;AAChF,eAAO,MAAM,wBAAwB,UAAW,SAAS,KAAG,sBAAsB,GAAG,SAChD,CAAC"}

package/esm/store/reference_point/reference_point_selectors.js

@@ -0,0 +1,16 @@
+// (C) 2026 GoodData Corporation
+/**
+ * The reference-point cluster's read layer.
+ *
+ * `referencePoint` always exists — the combined root owns the key with the domain's slice. The
+ * EXTENDED reference point deliberately does NOT: the readers distinguish "absent" from "empty", so
+ * it reads as `undefined` until a pluggable visualization reports one (the store holds `null` at
+ * rest; this boundary converts — see extended_reference_point_state.ts), and every reader must
+ * tolerate that.
+ */
+export const getReferencePoint = (state) => state.data.referencePoint;
+export const getExtendedReferencePoint = (state) => state.data.extendedReferencePoint ?? undefined;
+/** `referencePoint.buckets` holds the live buckets BY REFERENCE. */
+export const getReferencePointBuckets = (state) => state.data.referencePoint.buckets;
+/** The filters bucket rebuilt from the filter bar on every buckets mutation. */
+export const getReferencePointFilters = (state) => state.data.referencePoint.filters;

package/esm/store/reference_point/reference_point_slice.d.ts

@@ -0,0 +1,4 @@
+import { type IReferencePointState } from "./reference_point_state.js";
+export declare const referencePointSlice: import("@reduxjs/toolkit").Slice<IReferencePointState, {}, "referencePoint", "referencePoint", import("@reduxjs/toolkit").SliceSelectors<IReferencePointState>>;
+export declare const referencePointSliceReducer: import("redux").Reducer<IReferencePointState>;
+//# sourceMappingURL=reference_point_slice.d.ts.map

package/esm/store/reference_point/reference_point_slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference_point_slice.d.ts","sourceRoot":"","sources":["../../../src/store/reference_point/reference_point_slice.ts"],"names":[],"mappings":"AA6CA,OAAO,EAAE,KAAK,oBAAoB,EAA8B,MAAM,4BAA4B,CAAC;AAuBnG,eAAO,MAAM,mBAAmB,iKAyK9B,CAAC;AAEH,eAAO,MAAM,0BAA0B,+CAA8B,CAAC"}