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

package/esm/store/router/router_actions.js

@@ -0,0 +1,34 @@
+// (C) 2007-2026 GoodData Corporation
+import { createAction } from "@reduxjs/toolkit";
+import { ActionTypeKeys } from "../../constants/actions.js";
+// in the global ActionTypeKeys enum (the time-travel whitelist matches on
+// that enum). Prepare callbacks preserve the original positional call
+// signatures AND payload shapes, so call sites and payload consumers are untouched.
+export const locationChanged = createAction(ActionTypeKeys.LOCATION_CHANGED, (hash) => ({
+    payload: { hash },
+}));
+export const locationRedirectLock = createAction(ActionTypeKeys.LOCATION_REDIRECT_LOCK, (locked) => ({ payload: { locked } }));
+export const setRouteProjectId = createAction(ActionTypeKeys.SET_ROUTE_PROJECT_ID, (projectId) => ({
+    payload: { projectId },
+}));
+export var RouterEventActionTypeKeys;
+(function (RouterEventActionTypeKeys) {
+    RouterEventActionTypeKeys["STORE_ROUTE_CHANGED"] = "STORE_ROUTE_CHANGED";
+})(RouterEventActionTypeKeys || (RouterEventActionTypeKeys = {}));
+/**
+ * The navigation landed: `route` and `previousRoute` in ONE semantic event, each
+ * consumed by its own leaf (route_leaf_reducers.ts). LOCATION_CHANGED is a pure trigger: the router
+ * saga computes the pair (the previous route is the pre-navigation `route` value it reads before
+ * dispatching this), so no reducer needs a cross-key read — the ACTION carries the previous route.
+ */
+export const routeChanged = createAction(RouterEventActionTypeKeys.STORE_ROUTE_CHANGED, (route, previousRoute) => ({
+    payload: { route, previousRoute },
+}));
+// Saga coordination signals (SAGA/* strings) — dispatched by router_sagas, watched by other
+// sagas; no reducer handles them.
+export const routeParamsChanged = createAction(ActionTypeKeys.SAGA_ROUTE_PARAMS_CHANGED);
+export const reportIdChanged = createAction(ActionTypeKeys.SAGA_REPORT_ID_CHANGED, (reportId) => ({
+    payload: { reportId },
+}));
+export const sourceInsightChanged = createAction(ActionTypeKeys.SAGA_SOURCE_INSIGHT_CHANGED, (sourceInsightId) => ({ payload: { sourceInsightId } }));
+export const openInAnalyticalDesignerAction = createAction(ActionTypeKeys.UI_OPEN_IN_ANALYTICAL_DESIGNER);

package/esm/store/router/router_helpers.d.ts

@@ -0,0 +1,22 @@
+import { type IRouteState } from "./router_state.js";
+/**
+ * The next `route` value for a navigation. The workspace identifier is owned by the host (set once
+ * via SET_ROUTE_PROJECT_ID at mount), not by the hash — the current route's projectId is carried
+ * over instead of being wiped by the workspace-less hash.
+ */
+export declare function buildNextRoute(hash: string, currentRoute: IRouteState | undefined): IRouteState;
+/**
+ * Materializes the params branch even when the route value does not exist yet. Deliberately writes
+ * ONLY projectId: reportId stays absent until the first LOCATION_CHANGED, which
+ * {@link shouldResetOnNavigation} relies on for the first-navigation reset.
+ */
+export declare function withRouteProjectId(route: IRouteState | undefined, projectId: string): IRouteState;
+/**
+ * A navigation that clears the open report back to the default one resets the WHOLE application.
+ * Pure over the route/previousRoute pair the router saga just built. The first navigation with no
+ * previous route and the default report id deliberately COUNTS — previousReportId is absent, so it
+ * differs. (The workspace cannot change by navigation: the host owns it and a workspace switch
+ * remounts the application.)
+ */
+export declare function shouldResetOnNavigation(route: IRouteState, previousRoute: IRouteState | undefined): boolean;
+//# sourceMappingURL=router_helpers.d.ts.map

package/esm/store/router/router_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router_helpers.d.ts","sourceRoot":"","sources":["../../../src/store/router/router_helpers.ts"],"names":[],"mappings":"AAOA,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAYxE;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,GAAG,SAAS,GAAG,WAAW,CAS/F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,CAEjG;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAM3G"}

package/esm/store/router/router_helpers.js

@@ -0,0 +1,46 @@
+// (C) 2026 GoodData Corporation
+import { defaults } from "lodash-es";
+import { DEFAULT_REPORT_ID } from "../../constants/route_params.js";
+import { parseHash } from "../../utils/hash_parser.js";
+/**
+ * The router domain's pure value-level rules, over `IRouteState` values. The boundary that
+ * reads/writes the store is `sagas/router_sagas.ts` (the LOCATION_CHANGED flow) plus the two leaf
+ * reducers (route_leaf_reducers.ts).
+ */
+const defaultParams = {
+    reportId: DEFAULT_REPORT_ID,
+};
+/**
+ * The next `route` value for a navigation. The workspace identifier is owned by the host (set once
+ * via SET_ROUTE_PROJECT_ID at mount), not by the hash — the current route's projectId is carried
+ * over instead of being wiped by the workspace-less hash.
+ */
+export function buildNextRoute(hash, currentRoute) {
+    const parsedParams = parseHash(hash);
+    const params = {
+        ...defaults(parsedParams, defaultParams),
+        projectId: currentRoute?.params.projectId,
+    };
+    return { params };
+}
+/**
+ * Materializes the params branch even when the route value does not exist yet. Deliberately writes
+ * ONLY projectId: reportId stays absent until the first LOCATION_CHANGED, which
+ * {@link shouldResetOnNavigation} relies on for the first-navigation reset.
+ */
+export function withRouteProjectId(route, projectId) {
+    return { ...route, params: { ...route?.params, projectId } };
+}
+/**
+ * A navigation that clears the open report back to the default one resets the WHOLE application.
+ * Pure over the route/previousRoute pair the router saga just built. The first navigation with no
+ * previous route and the default report id deliberately COUNTS — previousReportId is absent, so it
+ * differs. (The workspace cannot change by navigation: the host owns it and a workspace switch
+ * remounts the application.)
+ */
+export function shouldResetOnNavigation(route, previousRoute) {
+    const datasetParamChanged = route.params.query?.dataset !== previousRoute?.params.query?.dataset;
+    const reportId = route.params.reportId;
+    const previousReportId = previousRoute?.params.reportId;
+    return !datasetParamChanged && reportId !== previousReportId && reportId === DEFAULT_REPORT_ID;
+}

package/esm/store/router/router_selectors.d.ts

@@ -0,0 +1,90 @@
+import { type IAppState } from "../types.js";
+import { type IRouteParams, type IRouteState } from "./router_state.js";
+/**
+ * The router domain's read layer.
+ *
+ * Three input selectors, one per tree position the domain owns; everything else is typed
+ * property access on top of them. The route values are `null` in the store until the first
+ * LOCATION_CHANGED / SET_ROUTE_PROJECT_ID writes them (see router_state.ts); the two input
+ * selectors convert to `undefined`, so every accessor tolerates the same absence shape it always
+ * has — that is the reason the leaves are optional chains rather than a `sliceSelector` with an
+ * initial state.
+ *
+ * The cross-domain route predicates (full-reload rules, KD embedding) stay in
+ * selectors/route_selector.ts: they compose appReady / isEmbedded and are not router-owned.
+ */
+export declare const getRouteState: (state: IAppState) => IRouteState | undefined;
+export declare const getPreviousRouteState: (state: IAppState) => IRouteState | undefined;
+/**
+ * The redirect lock the save flow holds while it rewrites the hash. The slice owns the key, so the
+ * `false` default only ever fires for a hand-built fixture that omits it.
+ */
+export declare const getLocationRedirectLock: (state: IAppState) => boolean;
+export declare const getRouteParams: ((state: IAppState) => IRouteParams | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IRouteState | undefined) => IRouteParams | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: IRouteState | undefined) => IRouteParams | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => IRouteParams | undefined;
+    dependencies: [typeof getRouteState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getPreviousRouteParams: ((state: IAppState) => IRouteParams | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IRouteState | undefined) => IRouteParams | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: IRouteState | undefined) => IRouteParams | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => IRouteParams | undefined;
+    dependencies: [typeof getPreviousRouteState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getRouteProjectId: (state: IAppState) => string | undefined;
+export declare const getRouteReportId: (state: IAppState) => string | undefined;
+export declare const getRouteForceReload: (state: IAppState) => boolean | undefined;
+export declare const getRouteExplainRequested: (state: IAppState) => boolean | undefined;
+export declare const getPreviousRouteProjectId: (state: IAppState) => string | undefined;
+export declare const getPreviousRouteReportId: (state: IAppState) => string | undefined;
+export declare const getRouteQueryDataset: (state: IAppState) => string | undefined;
+export declare const getRouteQueryInclude: (state: IAppState) => string | undefined;
+export declare const getRouteQueryExclude: (state: IAppState) => string | undefined;
+export declare const getRouteQueryHideControl: (state: IAppState) => string | undefined;
+export declare const getRouteQuerySourceDashboard: (state: IAppState) => string | undefined;
+export declare const getRouteQuerySourceInsight: (state: IAppState) => string | undefined;
+export declare const getRouteQueryHideAction: (state: IAppState) => string | undefined;
+export declare const getRouteQueryDisplayAction: (state: IAppState) => string | undefined;
+export declare const getRouteQueryAllowDashboardLinks: (state: IAppState) => string | undefined;
+export declare const getRouteQueryIsEmbeddedFromKD: (state: IAppState) => string | undefined;
+export declare const getRouteQueryShowEmbedButton: (state: IAppState) => string | undefined;
+export declare const getRouteQueryExplainType: (state: IAppState) => string | undefined;
+export declare const getRouteQueryAsOfDate: (state: IAppState) => string | undefined;
+export declare const getRouteQueryThousandSeparator: (state: IAppState) => string | undefined;
+export declare const getRouteQueryDecimalSeparator: (state: IAppState) => string | undefined;
+export declare const getPreviousRouteQueryDataset: (state: IAppState) => string | undefined;
+export declare const getPreviousRouteQueryInclude: (state: IAppState) => string | undefined;
+export declare const getPreviousRouteQueryExclude: (state: IAppState) => string | undefined;
+export declare const getPreviousRouteQuerySourceInsight: (state: IAppState) => string | undefined;
+//# sourceMappingURL=router_selectors.d.ts.map

package/esm/store/router/router_selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router_selectors.d.ts","sourceRoot":"","sources":["../../../src/store/router/router_selectors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAExE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,UAAW,SAAS,KAAG,WAAW,GAAG,SAAqC,CAAC;AACrG,eAAO,MAAM,qBAAqB,UAAW,SAAS,KAAG,WAAW,GAAG,SACnC,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,uBAAuB,UAAW,SAAS,KAAG,OAA8C,CAAC;AAE1G,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;CAG1B,CAAC;AACF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;CAGlC,CAAC;AA0BF,eAAO,MAAM,iBAAiB,UAAW,SAAS,KAAG,MAAM,GAAG,SAA6C,CAAC;AAC5G,eAAO,MAAM,gBAAgB,UAAW,SAAS,KAAG,MAAM,GAAG,SAA4C,CAAC;AAC1G,eAAO,MAAM,mBAAmB,UAAW,SAAS,KAAG,OAAO,GAAG,SAC3B,CAAC;AACvC,eAAO,MAAM,wBAAwB,UAAW,SAAS,KAAG,OAAO,GAAG,SAC3B,CAAC;AAG5C,eAAO,MAAM,yBAAyB,UAAW,SAAS,KAAG,MAAM,GAAG,SAC1B,CAAC;AAC7C,eAAO,MAAM,wBAAwB,UAAW,SAAS,KAAG,MAAM,GAAG,SAC1B,CAAC;AAG5C,eAAO,MAAM,oBAAoB,UAvBrB,SAAS,uBAuByC,CAAC;AAC/D,eAAO,MAAM,oBAAoB,UAxBrB,SAAS,uBAwBwD,CAAC;AAC9E,eAAO,MAAM,oBAAoB,UAzBrB,SAAS,uBAyBwD,CAAC;AAC9E,eAAO,MAAM,wBAAwB,UA1BzB,SAAS,uBA0BiD,CAAC;AACvE,eAAO,MAAM,4BAA4B,UA3B7B,SAAS,uBA2ByD,CAAC;AAC/E,eAAO,MAAM,0BAA0B,UA5B3B,SAAS,uBA4BqD,CAAC;AAC3E,eAAO,MAAM,uBAAuB,UA7BxB,SAAS,uBA6B+C,CAAC;AACrE,eAAO,MAAM,0BAA0B,UA9B3B,SAAS,uBA8BqD,CAAC;AAC3E,eAAO,MAAM,gCAAgC,UA/BjC,SAAS,uBA+BiE,CAAC;AACvF,eAAO,MAAM,6BAA6B,UAhC9B,SAAS,uBAgC2D,CAAC;AACjF,eAAO,MAAM,4BAA4B,UAjC7B,SAAS,uBAiCyD,CAAC;AAC/E,eAAO,MAAM,wBAAwB,UAlCzB,SAAS,uBAkCiD,CAAC;AACvE,eAAO,MAAM,qBAAqB,UAnCtB,SAAS,uBAmC2C,CAAC;AACjE,eAAO,MAAM,8BAA8B,UApC/B,SAAS,uBAoC6D,CAAC;AACnF,eAAO,MAAM,6BAA6B,UArC9B,SAAS,uBAqC2D,CAAC;AAGjF,eAAO,MAAM,4BAA4B,UAnC7B,SAAS,uBAmCyD,CAAC;AAC/E,eAAO,MAAM,4BAA4B,UApC7B,SAAS,uBAoCwE,CAAC;AAC9F,eAAO,MAAM,4BAA4B,UArC7B,SAAS,uBAqCwE,CAAC;AAC9F,eAAO,MAAM,kCAAkC,UAtCnC,SAAS,uBAsCqE,CAAC"}

package/esm/store/router/router_selectors.js

@@ -0,0 +1,62 @@
+// (C) 2026 GoodData Corporation
+import { createSelector } from "@reduxjs/toolkit";
+/**
+ * The router domain's read layer.
+ *
+ * Three input selectors, one per tree position the domain owns; everything else is typed
+ * property access on top of them. The route values are `null` in the store until the first
+ * LOCATION_CHANGED / SET_ROUTE_PROJECT_ID writes them (see router_state.ts); the two input
+ * selectors convert to `undefined`, so every accessor tolerates the same absence shape it always
+ * has — that is the reason the leaves are optional chains rather than a `sliceSelector` with an
+ * initial state.
+ *
+ * The cross-domain route predicates (full-reload rules, KD embedding) stay in
+ * selectors/route_selector.ts: they compose appReady / isEmbedded and are not router-owned.
+ */
+export const getRouteState = (state) => state.route ?? undefined;
+export const getPreviousRouteState = (state) => state.previousRoute ?? undefined;
+/**
+ * The redirect lock the save flow holds while it rewrites the hash. The slice owns the key, so the
+ * `false` default only ever fires for a hand-built fixture that omits it.
+ */
+export const getLocationRedirectLock = (state) => state.appState.locationRedirectLock;
+export const getRouteParams = createSelector(getRouteState, (route) => route?.params);
+export const getPreviousRouteParams = createSelector(getPreviousRouteState, (route) => route?.params);
+const getRouteQuery = createSelector(getRouteParams, (params) => params?.query);
+const getPreviousRouteQuery = createSelector(getPreviousRouteParams, (params) => params?.query);
+/**
+ * Query-param accessors are declared as one-liners off the query object rather than as
+ * `createSelector`s: each returns a primitive, so there is nothing to memoize, and a chain of
+ * memoized wrappers over a plain property read would only add cache slots.
+ */
+const routeQueryParam = (key) => (state) => getRouteQuery(state)?.[key];
+const previousRouteQueryParam = (key) => (state) => getPreviousRouteQuery(state)?.[key];
+// route.params leaves
+export const getRouteProjectId = (state) => getRouteParams(state)?.projectId;
+export const getRouteReportId = (state) => getRouteParams(state)?.reportId;
+export const getRouteForceReload = (state) => getRouteParams(state)?.forceReload;
+export const getRouteExplainRequested = (state) => getRouteParams(state)?.explainRequested;
+// previousRoute.params leaves
+export const getPreviousRouteProjectId = (state) => getPreviousRouteParams(state)?.projectId;
+export const getPreviousRouteReportId = (state) => getPreviousRouteParams(state)?.reportId;
+// route.params.query leaves
+export const getRouteQueryDataset = routeQueryParam("dataset");
+export const getRouteQueryInclude = routeQueryParam("includeObjectsWithTags");
+export const getRouteQueryExclude = routeQueryParam("excludeObjectsWithTags");
+export const getRouteQueryHideControl = routeQueryParam("hideControl");
+export const getRouteQuerySourceDashboard = routeQueryParam("sourceDashboard");
+export const getRouteQuerySourceInsight = routeQueryParam("sourceInsight");
+export const getRouteQueryHideAction = routeQueryParam("hideAction");
+export const getRouteQueryDisplayAction = routeQueryParam("displayAction");
+export const getRouteQueryAllowDashboardLinks = routeQueryParam("allowDashboardLinks");
+export const getRouteQueryIsEmbeddedFromKD = routeQueryParam("isEmbeddedFromKD");
+export const getRouteQueryShowEmbedButton = routeQueryParam("showEmbedButton");
+export const getRouteQueryExplainType = routeQueryParam("explainType");
+export const getRouteQueryAsOfDate = routeQueryParam("asOfDate");
+export const getRouteQueryThousandSeparator = routeQueryParam("thousandSeparator");
+export const getRouteQueryDecimalSeparator = routeQueryParam("decimalSeparator");
+// previousRoute.params.query leaves
+export const getPreviousRouteQueryDataset = previousRouteQueryParam("dataset");
+export const getPreviousRouteQueryInclude = previousRouteQueryParam("includeObjectsWithTags");
+export const getPreviousRouteQueryExclude = previousRouteQueryParam("excludeObjectsWithTags");
+export const getPreviousRouteQuerySourceInsight = previousRouteQueryParam("sourceInsight");

package/esm/store/router/router_state.d.ts

@@ -0,0 +1,20 @@
+import { type IHashFragments } from "../../utils/hash_parser.js";
+/**
+ * Route params as stored at `route.params` / `previousRoute.params`: the parsed hash fragments
+ * with `reportId` guaranteed by the DEFAULT_REPORT_ID fallback (see router_helpers), plus the
+ * host-owned `projectId` (set once via SET_ROUTE_PROJECT_ID at mount, never parsed from the hash).
+ */
+export interface IRouteParams extends Omit<IHashFragments, "reportId"> {
+    projectId?: string;
+    reportId: string;
+}
+/**
+ * The router domain's state, at three positions: `route` and `previousRoute` at the root, plus the
+ * `appState.locationRedirectLock` boolean. Both route values are `null` in the store until the first
+ * LOCATION_CHANGED / SET_ROUTE_PROJECT_ID writes them, and read as `undefined` through the input
+ * selectors — "no navigation yet" is a real, distinguishable shape.
+ */
+export interface IRouteState {
+    params: IRouteParams;
+}
+//# sourceMappingURL=router_state.d.ts.map

package/esm/store/router/router_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router_state.d.ts","sourceRoot":"","sources":["../../../src/store/router/router_state.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEjE;;;;GAIG;AACH,MAAM,WAAW,YAAa,SAAQ,IAAI,CAAC,cAAc,EAAE,UAAU,CAAC;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IACxB,MAAM,EAAE,YAAY,CAAC;CACxB"}

package/esm/store/router/router_state.js

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

package/esm/store/shortcuts/postponed_action_reducer.d.ts

@@ -0,0 +1,16 @@
+import { type Action } from "redux";
+import { type IPostponedActionState } from "./postponed_action_state.js";
+/**
+ * `data.postponedAction` — the READY-MADE replay action a canvas metric drop parks while the chart
+ * switches to a column (store/shortcuts/postponed_action_state.ts).
+ *
+ * Hand-written rather than `createSlice`, for the same reason as the extended-reference-point leaf
+ * (buckets_operation_leaves.ts): the parked value IS an action the replay saga re-puts verbatim
+ * into `dispatch`, and immer's development-build deep freeze on a drafted return would turn any
+ * in-place write downstream of that dispatch into a hard throw.
+ *
+ * `undefined` means nothing is parked; both applies CLEAR it. The combined root mounts the leaf
+ * through `nullableLeaf`, which stores that as `null` and hands `undefined` back in.
+ */
+export declare function postponedActionLeafReducer(state: IPostponedActionState | undefined, action: Action): IPostponedActionState | undefined;
+//# sourceMappingURL=postponed_action_reducer.d.ts.map

package/esm/store/shortcuts/postponed_action_reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postponed_action_reducer.d.ts","sourceRoot":"","sources":["../../../src/store/shortcuts/postponed_action_reducer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,OAAO,CAAC;AAEpC,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAOzE;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACtC,KAAK,EAAE,qBAAqB,GAAG,SAAS,EACxC,MAAM,EAAE,MAAM,GACf,qBAAqB,GAAG,SAAS,CAYnC"}

package/esm/store/shortcuts/postponed_action_reducer.js

@@ -0,0 +1,26 @@
+// (C) 2026 GoodData Corporation
+import { metricOverTimeShortcutApplied, metricShortcutApplied, shortcutPostponed, } from "./shortcuts_operation_events.js";
+/**
+ * `data.postponedAction` — the READY-MADE replay action a canvas metric drop parks while the chart
+ * switches to a column (store/shortcuts/postponed_action_state.ts).
+ *
+ * Hand-written rather than `createSlice`, for the same reason as the extended-reference-point leaf
+ * (buckets_operation_leaves.ts): the parked value IS an action the replay saga re-puts verbatim
+ * into `dispatch`, and immer's development-build deep freeze on a drafted return would turn any
+ * in-place write downstream of that dispatch into a hard throw.
+ *
+ * `undefined` means nothing is parked; both applies CLEAR it. The combined root mounts the leaf
+ * through `nullableLeaf`, which stores that as `null` and hands `undefined` back in.
+ */
+export function postponedActionLeafReducer(state, action) {
+    if (shortcutPostponed.match(action)) {
+        return action.payload.postponedAction;
+    }
+    if (metricShortcutApplied.match(action)) {
+        return action.payload.postponedAction;
+    }
+    if (metricOverTimeShortcutApplied.match(action)) {
+        return action.payload.postponedAction;
+    }
+    return state;
+}

package/esm/store/shortcuts/postponed_action_sagas.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Replays the shortcut a metric drop PARKED (store/shortcuts/shortcuts_apply_reducer.ts): applying
+ * a metric shortcut on a non-column visualization first switches the chart type and waits for the
+ * pluggable visualization to answer with an extended reference point, then adds the item.
+ *
+ * The parked value IS the action, so this re-puts it VERBATIM — the replayed handler must see
+ * exactly what a real drag would hand it. The parked action is cleared by the handler that consumes
+ * it.
+ */
+export declare function dispatchPostponedAction(): Generator<import("redux-saga/effects").PutEffect<import("./postponed_action_state.js").IPostponedActionState> | import("redux-saga/effects").SelectEffect | import("redux-saga/effects").TakeEffect, void, import("./postponed_action_state.js").IPostponedActionState | undefined>;
+export declare function watchDispatchPostponedAction(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+//# sourceMappingURL=postponed_action_sagas.d.ts.map

package/esm/store/shortcuts/postponed_action_sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postponed_action_sagas.d.ts","sourceRoot":"","sources":["../../../src/store/shortcuts/postponed_action_sagas.ts"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH,wBAAiB,uBAAuB,wRAiBvC;AAED,wBAAiB,4BAA4B,6EAE5C"}

package/esm/store/shortcuts/postponed_action_sagas.js

@@ -0,0 +1,34 @@
+// (C) 2007-2026 GoodData Corporation
+import { put, select, take, takeEvery } from "redux-saga/effects";
+import { ActionTypeKeys } from "../../constants/actions.js";
+import { extendedReferencePointApplied } from "../buckets/buckets_operation_events.js";
+import { getPostponedAction } from "./postponed_action_selectors.js";
+/**
+ * Replays the shortcut a metric drop PARKED (store/shortcuts/shortcuts_apply_reducer.ts): applying
+ * a metric shortcut on a non-column visualization first switches the chart type and waits for the
+ * pluggable visualization to answer with an extended reference point, then adds the item.
+ *
+ * The parked value IS the action, so this re-puts it VERBATIM — the replayed handler must see
+ * exactly what a real drag would hand it. The parked action is cleared by the handler that consumes
+ * it.
+ */
+export function* dispatchPostponedAction() {
+    const postponedAction = yield select(getPostponedAction);
+    if (postponedAction) {
+        // THE REPLAY GOES ON TOP OF THE APPLIED REFERENCE POINT, and that has to be said
+        // out loud. `EXTENDED_REFERENCE_POINT_CHANGED` is an operation, so its answer is
+        // already in `data.buckets` by the time any saga saw the action; now it is an operation that
+        // commits `extendedReferencePointApplied` in a LATER dispatch, and that event OVERWRITES the
+        // buckets with the value the plug viz computed — which does not contain the item this replay is
+        // about to add. Putting the replay first therefore added the item and then threw it away (the
+        // single-metric and metric-over-time canvas shortcuts added nothing at all).
+        //
+        // Waiting for the commit makes the dependency local and independent of watcher registration
+        // order. `handleExtendedReferencePointChanged` has no bail-out branch, so the event always comes.
+        yield take(extendedReferencePointApplied.type);
+        yield put(postponedAction);
+    }
+}
+export function* watchDispatchPostponedAction() {
+    yield takeEvery(ActionTypeKeys.EXTENDED_REFERENCE_POINT_CHANGED, dispatchPostponedAction);
+}

package/esm/store/shortcuts/postponed_action_selectors.d.ts

@@ -0,0 +1,4 @@
+import { type IAppState } from "../types.js";
+import { type IPostponedActionState } from "./postponed_action_state.js";
+export declare const getPostponedAction: (state: IAppState) => IPostponedActionState | undefined;
+//# sourceMappingURL=postponed_action_selectors.d.ts.map

package/esm/store/shortcuts/postponed_action_selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postponed_action_selectors.d.ts","sourceRoot":"","sources":["../../../src/store/shortcuts/postponed_action_selectors.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAEzE,eAAO,MAAM,kBAAkB,UAAW,SAAS,KAAG,qBAAqB,GAAG,SACnC,CAAC"}

package/esm/store/shortcuts/postponed_action_selectors.js

@@ -0,0 +1,2 @@
+// (C) 2026 GoodData Corporation
+export const getPostponedAction = (state) => state.data.postponedAction ?? undefined;

package/esm/store/shortcuts/postponed_action_state.d.ts

@@ -0,0 +1,3 @@
+import { type applyMetricOverTimePostponedShortcut, type applyMetricPostponedShortcut } from "../../actions/shortcuts_actions.js";
+export type IPostponedActionState = ReturnType<typeof applyMetricPostponedShortcut> | ReturnType<typeof applyMetricOverTimePostponedShortcut>;
+//# sourceMappingURL=postponed_action_state.d.ts.map

package/esm/store/shortcuts/postponed_action_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postponed_action_state.d.ts","sourceRoot":"","sources":["../../../src/store/shortcuts/postponed_action_state.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,oCAAoC,EACzC,KAAK,4BAA4B,EACpC,MAAM,oCAAoC,CAAC;AAE5C,MAAM,MAAM,qBAAqB,GAC3B,UAAU,CAAC,OAAO,4BAA4B,CAAC,GAC/C,UAAU,CAAC,OAAO,oCAAoC,CAAC,CAAC"}

package/esm/store/shortcuts/postponed_action_state.js

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

package/esm/store/shortcuts/shortcut_date_datasets_selectors.d.ts

@@ -0,0 +1,66 @@
+import { type IAppState } from "../types.js";
+export declare const getShortcutDateDatasetsState: (state: IAppState) => import("./shortcut_date_datasets_state.js").IShortcutDateDatasetsState;
+export declare const haveDateDatasetsBeenLoaded: ((state: IAppState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("./shortcut_date_datasets_state.js").IShortcutDateDatasetsState) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: import("./shortcut_date_datasets_state.js").IShortcutDateDatasetsState) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [typeof getShortcutDateDatasetsState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getAvailableShortcutDateDatasets: ((state: IAppState) => import("../../typings/datasets.js").IDateDataset[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("./shortcut_date_datasets_state.js").IShortcutDateDatasetsState) => import("../../typings/datasets.js").IDateDataset[];
+    memoizedResultFunc: ((resultFuncArgs_0: import("./shortcut_date_datasets_state.js").IShortcutDateDatasetsState) => import("../../typings/datasets.js").IDateDataset[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../../typings/datasets.js").IDateDataset[];
+    dependencies: [typeof getShortcutDateDatasetsState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getShortcutDateDatasetsError: ((state: IAppState) => Error | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("./shortcut_date_datasets_state.js").IShortcutDateDatasetsState) => Error | null;
+    memoizedResultFunc: ((resultFuncArgs_0: import("./shortcut_date_datasets_state.js").IShortcutDateDatasetsState) => Error | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Error | null;
+    dependencies: [typeof getShortcutDateDatasetsState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+//# sourceMappingURL=shortcut_date_datasets_selectors.d.ts.map

package/esm/store/shortcuts/shortcut_date_datasets_selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcut_date_datasets_selectors.d.ts","sourceRoot":"","sources":["../../../src/store/shortcuts/shortcut_date_datasets_selectors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,eAAO,MAAM,4BAA4B,UAAW,SAAS,2EAA6C,CAAC;AAE3G,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;CAGtC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;CAG5C,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;CAGxC,CAAC"}

package/esm/store/shortcuts/shortcut_date_datasets_selectors.js

@@ -0,0 +1,6 @@
+// (C) 2026 GoodData Corporation
+import { createSelector } from "@reduxjs/toolkit";
+export const getShortcutDateDatasetsState = (state) => state.data.shortcut.shortcutDateDatasets;
+export const haveDateDatasetsBeenLoaded = createSelector(getShortcutDateDatasetsState, (state) => state.loaded);
+export const getAvailableShortcutDateDatasets = createSelector(getShortcutDateDatasetsState, (state) => state.available);
+export const getShortcutDateDatasetsError = createSelector(getShortcutDateDatasetsState, (state) => state.error);

package/esm/store/shortcuts/shortcut_date_datasets_slice.d.ts

@@ -0,0 +1,4 @@
+import { type Reducer } from "redux";
+import { type IShortcutDateDatasetsState } from "./shortcut_date_datasets_state.js";
+export declare const shortcutDateDatasetsSliceReducer: Reducer<IShortcutDateDatasetsState>;
+//# sourceMappingURL=shortcut_date_datasets_slice.d.ts.map

package/esm/store/shortcuts/shortcut_date_datasets_slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcut_date_datasets_slice.d.ts","sourceRoot":"","sources":["../../../src/store/shortcuts/shortcut_date_datasets_slice.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,OAAO,CAAC;AAQrC,OAAO,EACH,KAAK,0BAA0B,EAElC,MAAM,mCAAmC,CAAC;AAyB3C,eAAO,MAAM,gCAAgC,EAAE,OAAO,CAAC,0BAA0B,CAC5C,CAAC"}

package/esm/store/shortcuts/shortcut_date_datasets_slice.js

@@ -0,0 +1,27 @@
+// (C) 2007-2026 GoodData Corporation
+import { createSlice } from "@reduxjs/toolkit";
+import { loadShortcutDateDatasets, shortcutDateDatasetsError, shortcutDateDatasetsUpdated, } from "../../actions/shortcuts_actions.js";
+import { shortcutDateDatasetsInitialState, } from "./shortcut_date_datasets_state.js";
+const shortcutDateDatasetsSlice = createSlice({
+    name: "shortcutDateDatasets",
+    initialState: shortcutDateDatasetsInitialState,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder
+            .addCase(loadShortcutDateDatasets, (state) => {
+            state.loaded = false;
+        })
+            .addCase(shortcutDateDatasetsUpdated, (state, action) => {
+            // shallow merge: the payload's keys (available/unavailable/…)
+            // replace the current ones, everything else is kept
+            Object.assign(state, action.payload);
+            state.loaded = true;
+            state.error = null;
+        })
+            .addCase(shortcutDateDatasetsError, (state, action) => {
+            state.loaded = true;
+            state.error = action.payload;
+        });
+    },
+});
+export const shortcutDateDatasetsSliceReducer = shortcutDateDatasetsSlice.reducer;

package/esm/store/shortcuts/shortcut_date_datasets_state.d.ts

@@ -0,0 +1,19 @@
+import { type IDateDataset } from "../../typings/datasets.js";
+/**
+ * data.shortcut.shortcutDateDatasets slice state — the date datasets loaded for the
+ * metric-over-time shortcut while a measure drag is in flight. Plain values.
+ *
+ * The SIBLING data.shortcut.shortcutDroppedItem key and data.postponedAction deliberately
+ * stay OUTSIDE this slice: each is a hand-written leaf of its own
+ * (shortcut_dropped_item_reducer.ts, postponed_action_reducer.ts) — the dropped item is also
+ * written by time travel's undo fixup, and the parked action must not be frozen by immer.
+ */
+export interface IShortcutDateDatasetsState {
+    loaded: boolean;
+    available: IDateDataset[];
+    /** count of unavailable datasets, present once the first load finishes */
+    unavailable?: number;
+    error: Error | null;
+}
+export declare const shortcutDateDatasetsInitialState: IShortcutDateDatasetsState;
+//# sourceMappingURL=shortcut_date_datasets_state.d.ts.map

package/esm/store/shortcuts/shortcut_date_datasets_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcut_date_datasets_state.d.ts","sourceRoot":"","sources":["../../../src/store/shortcuts/shortcut_date_datasets_state.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D;;;;;;;;GAQG;AACH,MAAM,WAAW,0BAA0B;IACvC,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACvB;AAED,eAAO,MAAM,gCAAgC,EAAE,0BAI9C,CAAC"}

package/esm/store/shortcuts/shortcut_date_datasets_state.js

@@ -0,0 +1,6 @@
+// (C) 2026 GoodData Corporation
+export const shortcutDateDatasetsInitialState = {
+    loaded: false,
+    available: [],
+    error: null,
+};

package/esm/store/shortcuts/shortcut_dropped_item_reducer.d.ts

@@ -0,0 +1,25 @@
+import { type Action } from "redux";
+import { type ICatalogEntry } from "../../typings/state_objects.js";
+import { type IAppState } from "../types.js";
+import { type IShortcutDroppedItemState } from "./shortcut_dropped_item_state.js";
+/**
+ * `data.shortcut.shortcutDroppedItem` — the catalog item a canvas drop PARKED while the shortcut
+ * date datasets were still loading (sagas/shortcut_sagas.ts re-fires the shortcut once they
+ * arrive).
+ *
+ * `SHORTCUT_SET_DROPPED_ITEM` writes this leaf and nothing else, so it is a plain case on the
+ * trigger — no saga, no event. The shortcut operations' events join below (the apply clears the
+ * parked item), and the time-travel restore fixup writes the same leaf through
+ * {@link setDroppedItem}, which stays infrastructure.
+ *
+ * `null` when nothing is parked (see shortcut_dropped_item_state.ts).
+ */
+export declare function shortcutDroppedItemLeafReducer(state: IShortcutDroppedItemState | undefined, action: Action): IShortcutDroppedItemState | undefined;
+/**
+ * The ROOT-STATE write the time-travel wrapper needs: undo/redo clears the parked item on every
+ * restore (store/_infra/time_travel.ts#applyRestoreFixups), and a restore fixup cannot be a case
+ * reducer — it runs inside the higher-order wrapper, over the whole root. Kept next to the leaf so
+ * the two writers of this subtree share one module.
+ */
+export declare function setDroppedItem(state: IAppState, catalogItem: ICatalogEntry | null): IAppState;
+//# sourceMappingURL=shortcut_dropped_item_reducer.d.ts.map

package/esm/store/shortcuts/shortcut_dropped_item_reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcut_dropped_item_reducer.d.ts","sourceRoot":"","sources":["../../../src/store/shortcuts/shortcut_dropped_item_reducer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,OAAO,CAAC;AAGpC,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAOlF;;;;;;;;;;;GAWG;AACH,wBAAgB,8BAA8B,CAC1C,KAAK,EAAE,yBAAyB,GAAG,SAAS,EAC5C,MAAM,EAAE,MAAM,GACf,yBAAyB,GAAG,SAAS,CAiBvC;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,CAY7F"}