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

package/esm/store/reference_point/reference_point_slice.js

@@ -0,0 +1,119 @@
+// (C) 2026 GoodData Corporation
+import { createSlice } from "@reduxjs/toolkit";
+import { openReportFailed, openReportFinished, openReportStarted } from "../../actions/open_actions.js";
+import { INITIAL_MODEL } from "../../models/bucket_item.js";
+import { isInsightContentResetEvent } from "../app_context/application_reset_events.js";
+import { arithmeticMeasureAdded, arithmeticMeasureOperandSelected, arithmeticMeasureOperatorSelected, } from "../arithmetic_measures/arithmetic_measures_operation_events.js";
+import { attributeFilterUpdated, dateFilterDateDatasetChanged, dateFilterUpdated, filterItemsUpdatedFromCommand, measureDateFilterApplied, measureDateFilterDateDatasetSelected, measureFilterAdded, measureFilterRemoved, measureFilterUpdated, measureValueFilterUpdated, rankingFilterUpdated, } from "../bucket_filters/bucket_filters_operation_events.js";
+import { bucketItemAdded, bucketItemEdited, bucketItemReordered, bucketItemReplaced, bucketItemsRemoved, bucketItemsSwapped, bucketsDateDatasetChanged, derivedBucketItemsPlaced, dualAxisToggled, extendedReferencePointApplied, filterRemovalApplied, } from "../buckets/buckets_operation_events.js";
+import { visualizationPropertiesChanged } from "../properties/properties_operation_events.js";
+import { recommendationApplied } from "../recommendations/recommendations_operation_events.js";
+import { metricOverTimeShortcutApplied, metricShortcutApplied, } from "../shortcuts/shortcuts_operation_events.js";
+import { referencePointInitialState } from "./reference_point_state.js";
+/**
+ * `data.referencePoint`.
+ *
+ * Each buckets operation calls the pure `syncReferencePoint` helper and names the result in its own
+ * event; the cases below just take it. So the reference point is written by its own reducer for every
+ * gesture in the buckets family, in the SAME dispatch as the buckets — a saga-dispatched sync would
+ * let components render fresh buckets against a stale reference point.
+ *
+ * `isVisualizationMdObjectValid` is deliberately NOT here: it is an OUTPUT of the operation and it
+ * has its own leaf.
+ *
+ * NO external writer remains: OPEN_REPORT_FINISHED carries the open-report operation's fused result
+ * and the case below takes the reference point out of it, and the application resets are matcher
+ * cases at the bottom — the open-failure flag COMPOSES with the reset in its own case.
+ */
+/** The open-failure reset value — hoisted so repeated failures share one reference. */
+const reportNotFoundResetState = {
+    ...referencePointInitialState,
+    reportNotFound: true,
+};
+export const referencePointSlice = createSlice({
+    name: "referencePoint",
+    initialState: referencePointInitialState,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder
+            /**
+             * Opening a report drops everything the previous insight put here and keeps ONLY an
+             * empty buckets model. `INITIAL_MODEL` is the same frozen identity the buckets slice
+             * self-initializes with.
+             */
+            .addCase(openReportStarted, () => ({ buckets: INITIAL_MODEL }))
+            /**
+             * A finished open REPLACES the reference point wholesale with the loaded insight's —
+             * buckets, converted filters, properties, `firstRender: true` and the cleared not-found
+             * flag, all in ONE value (open_report_operation.ts).
+             */
+            .addCase(openReportFinished, (_state, action) => action.payload.result.referencePoint)
+            // OPEN_REPORT_FAILED is one of the application resets and is handled by the reset
+            // matcher at the bottom — the not-found flag composes with the reset there
+            /**
+             * THE SYNC, once per buckets operation. `syncReferencePoint` is identity-guarded, so an
+             * operation that changed no buckets, no filters and no sort items answers the reference point
+             * it was given and this case returns the same state.
+             *
+             * `extendedReferencePointApplied` is the odd one out and its payload says so: that operation
+             * does not SYNC the reference point, it SEEDS it on the first plug-viz answer (consuming
+             * `firstRender`) and leaves it alone afterwards — so its payload's `referencePoint` is
+             * `undefined` when there is nothing to write, and the case has to keep the current state
+             * rather than write `undefined` over it.
+             */
+            .addCase(bucketItemAdded, (_state, action) => action.payload.referencePoint)
+            .addCase(bucketItemsRemoved, (_state, action) => action.payload.referencePoint)
+            .addCase(bucketItemReplaced, (_state, action) => action.payload.referencePoint)
+            .addCase(bucketItemsSwapped, (_state, action) => action.payload.referencePoint)
+            .addCase(bucketItemReordered, (_state, action) => action.payload.referencePoint)
+            .addCase(bucketItemEdited, (_state, action) => action.payload.referencePoint)
+            .addCase(dualAxisToggled, (_state, action) => action.payload.referencePoint)
+            .addCase(bucketsDateDatasetChanged, (_state, action) => action.payload.referencePoint)
+            .addCase(derivedBucketItemsPlaced, (_state, action) => action.payload.referencePoint)
+            .addCase(filterRemovalApplied, (_state, action) => action.payload.referencePoint)
+            .addCase(extendedReferencePointApplied, (state, action) => action.payload.referencePoint ?? state)
+            /**
+             * The properties family's one cascade. Its sync is CONDITIONAL like the ERP-applied
+             * one: it re-syncs only when the push's totals rider actually landed in the buckets, so a
+             * push without one carries the reference point it read — same reference, same state, no
+             * notification.
+             */
+            .addCase(visualizationPropertiesChanged, (state, action) => action.payload.referencePoint ?? state)
+            // the arithmetic-measure operations — each ends with the sync
+            .addCase(arithmeticMeasureAdded, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(arithmeticMeasureOperandSelected, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(arithmeticMeasureOperatorSelected, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(recommendationApplied, (state, action) => action.payload.referencePoint ?? state)
+            // the shortcut applies; the postpone touches no buckets and has no sync
+            .addCase(metricShortcutApplied, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(metricOverTimeShortcutApplied, (state, action) => action.payload.referencePoint ?? state)
+            // the bucket-filters operations — every one of them ends with the sync;
+            // the two no-op-capable ones carry the value they read, same reference, no notification
+            .addCase(attributeFilterUpdated, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(dateFilterUpdated, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(dateFilterDateDatasetChanged, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(filterItemsUpdatedFromCommand, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(measureValueFilterUpdated, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(rankingFilterUpdated, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(measureFilterAdded, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(measureFilterRemoved, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(measureFilterUpdated, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(measureDateFilterDateDatasetSelected, (state, action) => action.payload.referencePoint ?? state)
+            .addCase(measureDateFilterApplied, (state, action) => action.payload.referencePoint ?? state)
+            /**
+             * The application resets (store/app_context/application_reset_events.ts).
+             * OPEN_REPORT_FAILED is one of them, and its not-found flag COMPOSES with the reset
+             * here: reset to initial, then the `reportNotFound` write on top. A failure WITHOUT a
+             * reason is the report-not-found case, and the flag is what the pluggable visualization
+             * renders the "not found" state from. The composed value is a hoisted module constant,
+             * so a repeated failure returns the SAME reference.
+             */
+            .addMatcher(isInsightContentResetEvent, (_state, action) => {
+            if (openReportFailed.match(action) && action.payload.reason === undefined) {
+                return reportNotFoundResetState;
+            }
+            return referencePointInitialState;
+        });
+    },
+});
+export const referencePointSliceReducer = referencePointSlice.reducer;

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

@@ -0,0 +1,82 @@
+import { type ILowerBoundedFilter, type IUpperBoundedFilter, type ObjRef } from "@gooddata/sdk-model";
+import { type IRawBuckets } from "../../typings/buckets.js";
+import { type IStoredVisualizationProperties } from "../../typings/properties.js";
+import { type EmptyDateValuesFilterMode, type IAttributeElement, type IDateFilterConfig, type MeasureValueFilterCondition, type TextModeFilterData } from "../filter_bar/filter_bar_types.js";
+/**
+ * `data.referencePoint` — the pluggable-visualization INPUT. `buckets` holds the live buckets BY
+ * REFERENCE, `filters` is the filters bucket rebuilt from the filter bar on every buckets mutation,
+ * `properties` mirrors the visualization properties, and `firstRender` is the one-shot flag
+ * open-report sets and the first extended-reference-point answer consumes.
+ */
+/** One entry of the reference point's `filters` bucket — see services/reference_point_service.ts. */
+export interface IRefPointFilterItem {
+    localIdentifier: string;
+    /** the filter was created by AD (not by the user) and has not been modified since */
+    autoCreated: boolean;
+    /** the cache-item identifier of the filtered attribute / date dataset attribute */
+    attribute?: string;
+    dateDatasetRef?: ObjRef;
+    applyOnResult?: boolean;
+    strictLimitOfRows?: boolean;
+    filters: IRefPointFilterDetail[];
+}
+export type IRefPointFilterDetail = IRefPointDateFilterDetail | IRefPointAttributeFilterDetail | IRefPointMeasureValueFilterDetail | IRefPointRankingFilterDetail;
+export interface IRefPointDateFilterDetail {
+    attribute: string;
+    /** the date filter's configuration, or the `all_time` marker when there is none */
+    interval: IDateFilterConfig | {
+        name: string;
+    };
+    overTimeComparisonType?: string;
+    emptyDateValuesFilter?: EmptyDateValuesFilterMode;
+    boundedFilter?: IUpperBoundedFilter | ILowerBoundedFilter;
+}
+export interface IRefPointAttributeFilterDetail {
+    attribute: string;
+    displayFormRef?: ObjRef;
+    /** always empty — the elements travel in `selectedElements` */
+    allElements: ReadonlyArray<IAttributeElement>;
+    selectedElements: ReadonlyArray<IAttributeElement>;
+    isInverted: boolean;
+    totalElementsCount: number;
+    textModeFilter?: TextModeFilterData;
+}
+export interface IRefPointMeasureValueFilterDetail {
+    measureLocalIdentifier?: string;
+    measureRef?: ObjRef;
+    conditions?: MeasureValueFilterCondition[];
+    dimensionality?: ReadonlyArray<string | ObjRef>;
+}
+export interface IRefPointRankingFilterDetail {
+    measure?: string;
+    measureRef?: ObjRef;
+    attributes?: ReadonlyArray<string | ObjRef>;
+    operator?: string;
+    value?: number;
+}
+export interface IRefPointFiltersBucket {
+    localIdentifier: "filters";
+    items: IRefPointFilterItem[];
+}
+export interface IReferencePointState {
+    buckets: IRawBuckets;
+    filters?: IRefPointFiltersBucket;
+    properties?: IStoredVisualizationProperties;
+    dateDataSet?: {
+        uri: string | null;
+    };
+    reportNotFound?: boolean;
+    /**
+     * Set by open-report, DELETED by the first extended-reference-point answer — the one-shot
+     * "the plug viz has not answered yet" marker (store/buckets/buckets_apply_reducer.ts).
+     */
+    firstRender?: boolean;
+}
+/**
+ * The reference point's pristine seed. Frozen because its identity is shared across store instances,
+ * so an accidental in-place write would leak between them (the same treatment
+ * `models/bucket_item.ts#INITIAL_MODEL` gets). The `buckets` leaf holds the same `INITIAL_MODEL`
+ * identity the buckets slice self-initializes with, so both init paths agree.
+ */
+export declare const referencePointInitialState: IReferencePointState;
+//# sourceMappingURL=reference_point_state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reference_point_state.d.ts","sourceRoot":"","sources":["../../../src/store/reference_point/reference_point_state.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,mBAAmB,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGtG,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,KAAK,8BAA8B,EAAE,MAAM,6BAA6B,CAAC;AAClF,OAAO,EACH,KAAK,yBAAyB,EAC9B,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,2BAA2B,EAChC,KAAK,kBAAkB,EAC1B,MAAM,mCAAmC,CAAC;AAE3C;;;;;GAKG;AAEH,qGAAqG;AACrG,MAAM,WAAW,mBAAmB;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,qFAAqF;IACrF,WAAW,EAAE,OAAO,CAAC;IACrB,mFAAmF;IACnF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,OAAO,EAAE,qBAAqB,EAAE,CAAC;CACpC;AAED,MAAM,MAAM,qBAAqB,GAC3B,yBAAyB,GACzB,8BAA8B,GAC9B,iCAAiC,GACjC,4BAA4B,CAAC;AAEnC,MAAM,WAAW,yBAAyB;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,QAAQ,EAAE,iBAAiB,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,qBAAqB,CAAC,EAAE,yBAAyB,CAAC;IAClD,aAAa,CAAC,EAAE,mBAAmB,GAAG,mBAAmB,CAAC;CAC7D;AAED,MAAM,WAAW,8BAA8B;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+DAA+D;IAC/D,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAC9C,gBAAgB,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IACnD,UAAU,EAAE,OAAO,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,kBAAkB,CAAC;CACvC;AAED,MAAM,WAAW,iCAAiC;IAC9C,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,2BAA2B,EAAE,CAAC;IAC3C,cAAc,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;CACnD;AAED,MAAM,WAAW,4BAA4B;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACnC,eAAe,EAAE,SAAS,CAAC;IAC3B,KAAK,EAAE,mBAAmB,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB;IACjC,OAAO,EAAE,WAAW,CAAC;IACrB,OAAO,CAAC,EAAE,sBAAsB,CAAC;IACjC,UAAU,CAAC,EAAE,8BAA8B,CAAC;IAC5C,WAAW,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACrC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,EAAE,oBASvC,CAAC"}

package/esm/store/reference_point/reference_point_state.js

@@ -0,0 +1,18 @@
+// (C) 2026 GoodData Corporation
+import { INITIAL_MODEL as BUCKET_INITIAL_MODEL } from "../../models/bucket_item.js";
+/**
+ * The reference point's pristine seed. Frozen because its identity is shared across store instances,
+ * so an accidental in-place write would leak between them (the same treatment
+ * `models/bucket_item.ts#INITIAL_MODEL` gets). The `buckets` leaf holds the same `INITIAL_MODEL`
+ * identity the buckets slice self-initializes with, so both init paths agree.
+ */
+export const referencePointInitialState = Object.freeze({
+    buckets: BUCKET_INITIAL_MODEL,
+    filters: Object.freeze({
+        localIdentifier: "filters",
+        items: Object.freeze([]),
+    }),
+    dateDataSet: Object.freeze({ uri: null }),
+    reportNotFound: false,
+    properties: Object.freeze({}),
+});

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

@@ -0,0 +1,53 @@
+import { type ISortItem } from "@gooddata/sdk-model";
+import { type IRawBuckets } from "../../typings/buckets.js";
+import { type IBucketsMetaState } from "../buckets/buckets_meta_state.js";
+import { type IFilterBarState } from "../filter_bar/filter_bar_state.js";
+import { type IRefPointFiltersBucket, type IReferencePointState } from "./reference_point_state.js";
+/**
+ * The reference point's SYNC — the tail of every buckets mutation, as a narrow pure helper.
+ *
+ * `referencePoint.buckets` takes the live buckets BY REFERENCE, the filters bucket is the one rebuilt
+ * from the filter bar, and `properties.sortItems` mirrors the visualization properties. All three
+ * writes are BY REFERENCE on purpose, which buckets_cluster_characterization pins.
+ *
+ * **The md-object validity flag is NOT here.** It is `data.isVisualizationMdObjectValid`, a leaf of
+ * its own, and an OUTPUT of the operation that mutated the buckets — so each operation names it in
+ * its own event payload.
+ */
+/**
+ * Rebuilds the reference point's filters bucket out of the filter bar and the buckets meta. A LAZY
+ * resolver rather than a value, because an operation must convert the two as its helpers LEFT them
+ * and not as they were on entry — the removal chain rewrites both.
+ *
+ * Declared here rather than in the buckets cluster because it is a parameter of THIS sync.
+ */
+export type RefPointFiltersResolver = (filterBar: IFilterBarState, bucketsMeta: IBucketsMetaState) => IRefPointFiltersBucket;
+/**
+ * The two foreign facts the sync needs, for an operation that does NOT touch the filter bar or the
+ * buckets meta: both are converted once by the caller and arrive as VALUES. Every bucket-item edit is
+ * of this kind — the edit changes one item and nothing else, so there is nothing for a resolver to
+ * re-read.
+ */
+export interface IReferencePointSyncValues {
+    refPointFilters: IRefPointFiltersBucket;
+    sortItems: ISortItem[] | undefined;
+}
+/**
+ * The same two facts for an operation that DOES rewrite the filter bar or the buckets meta on its way
+ * through — the removal chain and everything built on it. There the conversion has to happen after the
+ * rewrite, which is why the filters arrive as a LAZY RESOLVER and not as a value.
+ */
+export interface IReferencePointSyncDeps {
+    refPointFilters: RefPointFiltersResolver;
+    sortItems: ISortItem[] | undefined;
+}
+/**
+ * The whole tail as ONE call: convert the filters, then sync. Every buckets operation ends with
+ * exactly this, over the values ITS helpers produced — never over a re-read of the root.
+ *
+ * The md-object validity flag is deliberately NOT here (see the module note): it is an output of the
+ * operation, named separately in each event payload.
+ */
+export declare function syncReferencePointForBuckets(referencePoint: IReferencePointState | undefined, buckets: IRawBuckets, filterBar: IFilterBarState, bucketsMeta: IBucketsMetaState, { refPointFilters, sortItems }: IReferencePointSyncDeps): IReferencePointState;
+export declare function syncReferencePoint(referencePoint: IReferencePointState | undefined, buckets: IRawBuckets, refPointFilters: IRefPointFiltersBucket, sortItems: ISortItem[] | undefined): IReferencePointState;
+//# sourceMappingURL=reference_point_sync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reference_point_sync.d.ts","sourceRoot":"","sources":["../../../src/store/reference_point/reference_point_sync.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE,OAAO,EAAE,KAAK,sBAAsB,EAAE,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEpG;;;;;;;;;;GAUG;AACH;;;;;;GAMG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAClC,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,iBAAiB,KAC7B,sBAAsB,CAAC;AAE5B;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACtC,eAAe,EAAE,sBAAsB,CAAC;IACxC,SAAS,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC;CACtC;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACpC,eAAe,EAAE,uBAAuB,CAAC;IACzC,SAAS,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC;CACtC;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CACxC,cAAc,EAAE,oBAAoB,GAAG,SAAS,EAChD,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,iBAAiB,EAC9B,EAAE,eAAe,EAAE,SAAS,EAAE,EAAE,uBAAuB,GACxD,oBAAoB,CAEtB;AAED,wBAAgB,kBAAkB,CAC9B,cAAc,EAAE,oBAAoB,GAAG,SAAS,EAChD,OAAO,EAAE,WAAW,EACpB,eAAe,EAAE,sBAAsB,EACvC,SAAS,EAAE,SAAS,EAAE,GAAG,SAAS,GACnC,oBAAoB,CActB"}

package/esm/store/reference_point/reference_point_sync.js

@@ -0,0 +1,34 @@
+// (C) 2026 GoodData Corporation
+/**
+ * The whole tail as ONE call: convert the filters, then sync. Every buckets operation ends with
+ * exactly this, over the values ITS helpers produced — never over a re-read of the root.
+ *
+ * The md-object validity flag is deliberately NOT here (see the module note): it is an output of the
+ * operation, named separately in each event payload.
+ */
+export function syncReferencePointForBuckets(referencePoint, buckets, filterBar, bucketsMeta, { refPointFilters, sortItems }) {
+    return syncReferencePoint(referencePoint, buckets, refPointFilters(filterBar, bucketsMeta), sortItems);
+}
+export function syncReferencePoint(referencePoint, buckets, refPointFilters, sortItems) {
+    const properties = withSortItems(referencePoint, sortItems);
+    // an ABSENT reference point can never satisfy this: `withSortItems` always answers an object,
+    // so the `properties` comparison is false before the other two are even reached
+    if (referencePoint?.buckets === buckets &&
+        referencePoint?.filters === refPointFilters &&
+        referencePoint?.properties === properties) {
+        return referencePoint;
+    }
+    return { ...referencePoint, buckets, filters: refPointFilters, properties };
+}
+/**
+ * `sortItems` is written even when it is undefined: the KEY has to exist, because that is what
+ * distinguishes "no sort" from "not answered yet" for the plug viz. Everything else in `properties`
+ * is preserved, and the object identity survives when the value is already the same.
+ */
+function withSortItems(referencePoint, sortItems) {
+    const properties = referencePoint?.properties;
+    if (properties !== undefined && "sortItems" in properties && properties.sortItems === sortItems) {
+        return properties;
+    }
+    return { ...properties, sortItems };
+}

package/esm/store/report/handle_missing_date_filters.d.ts

@@ -0,0 +1,35 @@
+import { type IInsight } from "@gooddata/sdk-model";
+import { type IDateDatasetsMeta } from "../../models/date_datasets_meta.js";
+import { type IMissingDateFilterItem } from "../../typings/report.js";
+/**
+ * Tells the granularity of a date attribute's label from its identifier alone. How labels are named is
+ * a backend rule, so the caller supplies it.
+ */
+export type LabelGranularityResolver = (labelIdentifier: string) => string | undefined;
+/**
+ * Thrown by the open-report sagas when the insight's filters reference items the workspace no
+ * longer has. The sagas' failure handler turns it into the "not found" open failure that names
+ * the missing items.
+ */
+export declare class MissingInsightItemsError extends Error {
+    readonly missingItems: ReadonlyArray<IMissingDateFilterItem>;
+    constructor(missingItems: ReadonlyArray<IMissingDateFilterItem>);
+}
+export declare function isMissingInsightItemsError(error: unknown): error is MissingInsightItemsError;
+/**
+ * Collects the items the insight's date-related filters reference but the workspace no longer has,
+ * because a granularity was disabled in the logical data model after the insight was saved:
+ *
+ * - an additional date filter (an attribute filter on a date attribute's label) whose attribute the
+ *   date dataset no longer has; its granularity is told from the label identifier by `resolveLabelGranularity`,
+ * - a relative date filter whose granularity the date dataset no longer has.
+ *
+ * Both the insight's own filters and every measure's filters are inspected. Regular attribute
+ * filters, absolute date filters and date datasets the meta does not list are never reported. Each
+ * item is reported once, in the order it is first met.
+ *
+ * Pure over the insight and the date datasets meta: the meta lists every date dataset with the
+ * attributes it currently has, which is exactly what those filters reference.
+ */
+export declare function findMissingDateFilterItems(insight: IInsight, dateDatasetsMeta: IDateDatasetsMeta | undefined, resolveLabelGranularity: LabelGranularityResolver): IMissingDateFilterItem[];
+//# sourceMappingURL=handle_missing_date_filters.d.ts.map

package/esm/store/report/handle_missing_date_filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle_missing_date_filters.d.ts","sourceRoot":"","sources":["../../../src/store/report/handle_missing_date_filters.ts"],"names":[],"mappings":"AAEA,OAAO,EAEH,KAAK,QAAQ,EAYhB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAE5E,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAEtE;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,eAAe,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AAEvF;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IAC/C,SAAgB,YAAY,EAAE,aAAa,CAAC,sBAAsB,CAAC,CAAC;IAEpE,YAAY,YAAY,EAAE,aAAa,CAAC,sBAAsB,CAAC,EAI9D;CACJ;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,wBAAwB,CAE5F;AAqGD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CACtC,OAAO,EAAE,QAAQ,EACjB,gBAAgB,EAAE,iBAAiB,GAAG,SAAS,EAC/C,uBAAuB,EAAE,wBAAwB,GAClD,sBAAsB,EAAE,CAiB1B"}

package/esm/store/report/handle_missing_date_filters.js

@@ -0,0 +1,118 @@
+// (C) 2026 GoodData Corporation
+import { areObjRefsEqual, filterObjRef, insightFilters, insightMeasures, isAllTimeDateFilter, isAttributeFilter, isIdentifierRef, isRelativeDateFilter, isSimpleMeasure, measureFilters, } from "@gooddata/sdk-model";
+/**
+ * Thrown by the open-report sagas when the insight's filters reference items the workspace no
+ * longer has. The sagas' failure handler turns it into the "not found" open failure that names
+ * the missing items.
+ */
+export class MissingInsightItemsError extends Error {
+    missingItems;
+    constructor(missingItems) {
+        super(`Insight references missing items: ${missingItems.map((item) => item.identifier).join(", ")}`);
+        this.name = "MissingInsightItemsError";
+        this.missingItems = missingItems;
+    }
+}
+export function isMissingInsightItemsError(error) {
+    return error instanceof MissingInsightItemsError;
+}
+const refIdentifier = (ref) => isIdentifierRef(ref) ? ref.identifier : undefined;
+/**
+ * A date attribute, its default label and every other label of it share the date dataset's
+ * identifier as a prefix (`estimated_delivery_date.minuteOfHour`), which is the one thing that
+ * survives the granularity being disabled. The longest matching dataset wins, so a dataset whose
+ * identifier is itself a prefix of another one cannot claim the other's labels.
+ */
+function findOwningDateDataset(displayFormIdentifier, dateDatasets) {
+    return dateDatasets
+        .filter((dataset) => displayFormIdentifier.startsWith(`${dataset.identifier}.`))
+        .sort((a, b) => b.identifier.length - a.identifier.length)[0];
+}
+/** The attribute ref of a date attribute equals its label ref, so one identifier compare covers both. */
+function dateDatasetHasDisplayForm(dataset, displayFormIdentifier) {
+    return (dataset.attributes ?? []).some((attribute) => refIdentifier(attribute.ref) === displayFormIdentifier ||
+        refIdentifier(attribute.dfRef) === displayFormIdentifier ||
+        attribute.dfIdentifier === displayFormIdentifier ||
+        (attribute.displayForms ?? []).some((displayForm) => displayForm.id === displayFormIdentifier ||
+            refIdentifier(displayForm.ref) === displayFormIdentifier));
+}
+/**
+ * An additional date filter: an attribute filter on a date attribute's label that no longer exists.
+ * Only identifier refs can be checked: the dataset identifier prefix of the label is the one thing
+ * that ties a label to its date dataset once the attribute is gone, and a uri ref has no such
+ * prefix, so it cannot be told apart from a regular attribute's label.
+ */
+function findMissingDateAttributeLabel(filter, dateDatasets, resolveLabelGranularity) {
+    const displayFormIdentifier = refIdentifier(filterObjRef(filter));
+    if (!displayFormIdentifier) {
+        return undefined;
+    }
+    const dataset = findOwningDateDataset(displayFormIdentifier, dateDatasets);
+    if (!dataset || dateDatasetHasDisplayForm(dataset, displayFormIdentifier)) {
+        return undefined;
+    }
+    const granularity = resolveLabelGranularity(displayFormIdentifier);
+    return {
+        datasetTitle: dataset.title,
+        identifier: displayFormIdentifier,
+        ...(granularity ? { granularity } : {}),
+    };
+}
+/**
+ * A relative date filter whose granularity the date dataset no longer has. A meta attribute's
+ * `dateType` IS the granularity the date filters are expressed in (`GDC.time.*`). All time is no
+ * attribute of the dataset, so it can never go missing; it is stored as a relative date filter
+ * when it carries empty values handling.
+ */
+function findMissingDateGranularity(filter, dateDatasets) {
+    if (!isRelativeDateFilter(filter) || isAllTimeDateFilter(filter)) {
+        return undefined;
+    }
+    const datasetRef = filterObjRef(filter);
+    if (!datasetRef) {
+        return undefined;
+    }
+    const dataset = dateDatasets.find((candidate) => areObjRefsEqual(candidate.ref, datasetRef));
+    const { granularity } = filter.relativeDateFilter;
+    if (!dataset || (dataset.attributes ?? []).some((attribute) => attribute.dateType === granularity)) {
+        return undefined;
+    }
+    return { datasetTitle: dataset.title, identifier: dataset.identifier, granularity };
+}
+function findMissingItem(filter, dateDatasets, resolveLabelGranularity) {
+    return isAttributeFilter(filter)
+        ? findMissingDateAttributeLabel(filter, dateDatasets, resolveLabelGranularity)
+        : findMissingDateGranularity(filter, dateDatasets);
+}
+/** Two references to the same missing granularity of the same dataset are one item. */
+const itemKey = (item) => `${item.datasetTitle}|${item.granularity ?? item.identifier}`;
+/**
+ * Collects the items the insight's date-related filters reference but the workspace no longer has,
+ * because a granularity was disabled in the logical data model after the insight was saved:
+ *
+ * - an additional date filter (an attribute filter on a date attribute's label) whose attribute the
+ *   date dataset no longer has; its granularity is told from the label identifier by `resolveLabelGranularity`,
+ * - a relative date filter whose granularity the date dataset no longer has.
+ *
+ * Both the insight's own filters and every measure's filters are inspected. Regular attribute
+ * filters, absolute date filters and date datasets the meta does not list are never reported. Each
+ * item is reported once, in the order it is first met.
+ *
+ * Pure over the insight and the date datasets meta: the meta lists every date dataset with the
+ * attributes it currently has, which is exactly what those filters reference.
+ */
+export function findMissingDateFilterItems(insight, dateDatasetsMeta, resolveLabelGranularity) {
+    const dateDatasets = dateDatasetsMeta?.items ?? [];
+    if (!dateDatasets.length) {
+        return [];
+    }
+    const measureLevelFilters = insightMeasures(insight)
+        .filter(isSimpleMeasure)
+        .flatMap((measure) => measureFilters(measure) ?? []);
+    const filters = [...insightFilters(insight), ...measureLevelFilters];
+    const missing = filters
+        .map((filter) => findMissingItem(filter, dateDatasets, resolveLabelGranularity))
+        .filter((item) => item !== undefined);
+    const unique = new Map(missing.map((item) => [itemKey(item), item]));
+    return [...unique.values()];
+}

package/esm/store/report/open_report_operation.d.ts

@@ -0,0 +1,71 @@
+import { type IInsight, type IFilter as ISdkFilter } from "@gooddata/sdk-model";
+import { type IRawBuckets } from "../../typings/buckets.js";
+import { type IDateDataset } from "../../typings/datasets.js";
+import { type ILoadedReportItems } from "../../typings/report.js";
+import { type IBucketsMetaState } from "../buckets/buckets_meta_state.js";
+import { type IBucketsState } from "../buckets/buckets_state.js";
+import { type IDateDatasetsState } from "../date_datasets/date_datasets_state.js";
+import { type IFilterBarState } from "../filter_bar/filter_bar_state.js";
+import { type IItemCacheState } from "../item_cache/item_cache_state.js";
+import { type IMeasureDateDatasetsState } from "../measure_date_datasets/measure_date_datasets_state.js";
+import { type IPropertiesState } from "../properties/properties_state.js";
+import { type IReferencePointState } from "../reference_point/reference_point_state.js";
+import { type IVisualizationClassState } from "../visualization_classes/visualization_classes_state.js";
+/**
+ * THE OPEN-REPORT OPERATION — the pure computation applied on OPEN_REPORT_FINISHED, over explicit
+ * domain values. `sagas/open_report_sagas.ts` is the boundary: it selects the input, resolves the two
+ * foreign lookups, calls this, and the OPEN_REPORT_FINISHED event carries the result — each owning
+ * slice consumes its own value, in ONE dispatch.
+ *
+ * The CONDITIONAL writes are expressed as identity: `dateDatasets` answers the INPUT value by
+ * reference when no date dataset is selected for the insight, so the slice's unconditional case is a
+ * no-op there.
+ */
+export interface IOpenReportOperationInput {
+    /** current `data.itemCache` — the loaded items SHALLOW-merge over it, as `Map.merge` did */
+    itemCache: IItemCacheState;
+    /** current `data.bucketsMeta` — the PRE-open value feeds the reference-point filter conversion */
+    bucketsMeta: IBucketsMetaState;
+    /** current `data.filterBar` — the loaded filter/parameter items land over it */
+    filterBar: IFilterBarState;
+    /** current `data.measuresDateDatasets` — the per-measure date-dataset selections land in it */
+    measuresDateDatasets: IMeasureDateDatasetsState | undefined;
+    /** current `data.dateDatasets` — answered BY REFERENCE when the insight selects no dataset */
+    dateDatasets: IDateDatasetsState;
+}
+export interface IOpenReportOperationParams {
+    insight: IInsight;
+    loadedItems: ILoadedReportItems;
+    /**
+     * The class already resolved at the boundary (`useDefaultClass` picks the workspace default,
+     * otherwise the insight's URL finds it) — resolved there because the default-class rule reads
+     * the enabled-classes selector, a cross-domain fact this operation has no business owning.
+     */
+    visualizationClass: IVisualizationClassState;
+}
+export interface IOpenReportOperationDeps {
+    /** `data.dateDatasetsMeta` lookup for the measure date filters' dataset identifiers */
+    dateDatasetUriByIdentifier: (identifier: string) => string | undefined;
+    /** fresh local identifier for a loaded metric date filter — the impurity stays at the boundary */
+    generateFilterLocalIdentifier: () => string;
+    /** the improved metric date filter: with it off, a metric keeps its first date filter only */
+    keepFurtherMetricDateFilters: boolean;
+}
+export interface IOpenReportResult {
+    buckets: IBucketsState;
+    bucketsMeta: IBucketsMetaState;
+    itemCache: IItemCacheState;
+    filterBar: IFilterBarState;
+    measuresDateDatasets: IMeasureDateDatasetsState;
+    dateDatasets: IDateDatasetsState;
+    visualizationClass: IVisualizationClassState;
+    visualizationProperties: IPropertiesState;
+    referencePoint: IReferencePointState;
+}
+/**
+ * The insight's selected date dataset: the date bucket item's attribute decides first, then the
+ * insight's own date filter, then a measure's date filter.
+ */
+export declare function getSelectedDateDataset(buckets: IRawBuckets, filters: ReadonlyArray<ISdkFilter>, availableDateDatasets: ReadonlyArray<IDateDataset>): IDateDataset | undefined;
+export declare function applyOpenReport(input: IOpenReportOperationInput, params: IOpenReportOperationParams, deps: IOpenReportOperationDeps): IOpenReportResult;
+//# sourceMappingURL=open_report_operation.d.ts.map

package/esm/store/report/open_report_operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open_report_operation.d.ts","sourceRoot":"","sources":["../../../src/store/report/open_report_operation.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,QAAQ,EACb,KAAK,OAAO,IAAI,UAAU,EAM7B,MAAM,qBAAqB,CAAC;AAQ7B,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACjF,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAE1E,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAMlF,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE,OAAO,EACH,KAAK,yBAAyB,EAEjC,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,6CAA6C,CAAC;AACxF,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,yDAAyD,CAAC;AAIxG;;;;;;;;;GASG;AAEH,MAAM,WAAW,yBAAyB;IACtC,4FAA4F;IAC5F,SAAS,EAAE,eAAe,CAAC;IAC3B,kGAAkG;IAClG,WAAW,EAAE,iBAAiB,CAAC;IAC/B,gFAAgF;IAChF,SAAS,EAAE,eAAe,CAAC;IAC3B,+FAA+F;IAC/F,oBAAoB,EAAE,yBAAyB,GAAG,SAAS,CAAC;IAC5D,8FAA8F;IAC9F,YAAY,EAAE,kBAAkB,CAAC;CACpC;AAED,MAAM,WAAW,0BAA0B;IACvC,OAAO,EAAE,QAAQ,CAAC;IAClB,WAAW,EAAE,kBAAkB,CAAC;IAChC;;;;OAIG;IACH,kBAAkB,EAAE,wBAAwB,CAAC;CAChD;AAED,MAAM,WAAW,wBAAwB;IACrC,uFAAuF;IACvF,0BAA0B,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACvE,kGAAkG;IAClG,6BAA6B,EAAE,MAAM,MAAM,CAAC;IAC5C,8FAA8F;IAC9F,4BAA4B,EAAE,OAAO,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAC9B,OAAO,EAAE,aAAa,CAAC;IACvB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,SAAS,EAAE,eAAe,CAAC;IAC3B,SAAS,EAAE,eAAe,CAAC;IAC3B,oBAAoB,EAAE,yBAAyB,CAAC;IAChD,YAAY,EAAE,kBAAkB,CAAC;IACjC,kBAAkB,EAAE,wBAAwB,CAAC;IAC7C,uBAAuB,EAAE,gBAAgB,CAAC;IAC1C,cAAc,EAAE,oBAAoB,CAAC;CACxC;AAkCD;;;GAGG;AACH,wBAAgB,sBAAsB,CAClC,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,aAAa,CAAC,UAAU,CAAC,EAClC,qBAAqB,EAAE,aAAa,CAAC,YAAY,CAAC,GACnD,YAAY,GAAG,SAAS,CAsC1B;AAiED,wBAAgB,eAAe,CAC3B,KAAK,EAAE,yBAAyB,EAChC,MAAM,EAAE,0BAA0B,EAClC,IAAI,EAAE,wBAAwB,GAC/B,iBAAiB,CA4FnB"}