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

package/esm/sagas/properties_sagas.d.ts

@@ -0,0 +1,5 @@
+import { type SagaIterator } from "redux-saga";
+import { type IVisualizationPropertiesChangedAction } from "../actions/properties_actions.js";
+export declare function onPropertiesChanged(action: IVisualizationPropertiesChangedAction): SagaIterator<void>;
+export declare function watchProperties(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+//# sourceMappingURL=properties_sagas.d.ts.map

package/esm/sagas/properties_sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties_sagas.d.ts","sourceRoot":"","sources":["../../src/sagas/properties_sagas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,OAAO,EACH,KAAK,qCAAqC,EAE7C,MAAM,kCAAkC,CAAC;AAW1C,wBAAiB,mBAAmB,CAAC,MAAM,EAAE,qCAAqC,GAAG,YAAY,CAAC,IAAI,CAAC,CAgCtG;AAED,wBAAiB,eAAe,6EAE/B"}

package/esm/sagas/properties_sagas.js

@@ -0,0 +1,47 @@
+// (C) 2020-2026 GoodData Corporation
+import { call, put, select, takeEvery } from "redux-saga/effects";
+import { logBucketTotals } from "../actions/buckets_actions.js";
+import { storeVisualizationProperties, } from "../actions/properties_actions.js";
+import { ActionTypeKeys } from "../constants/actions.js";
+import { logAggregationsTotal } from "../services/telemetry/tracking_events.js";
+import { getMergedProperties, getReplacedProperties } from "../store/properties/properties_helpers.js";
+import { getVisualizationProperties } from "../store/properties/properties_selectors.js";
+import { getExtendedReferencePointProperties } from "../store/reference_point/extended_reference_point_selectors.js";
+import { areSameVisualizationProperties } from "../utils/visualization_properties.js";
+// annotated so declaration emit does not have to name the store action's payload type, whose
+// IDefaultControlProperties default sdk-ui-ext does not re-export (TS2742 — see properties_actions)
+export function* onPropertiesChanged(action) {
+    const { properties } = action.payload;
+    const state = yield select();
+    if (properties) {
+        const currentMergedProperties = getVisualizationProperties(state);
+        const newMergedProperties = getMergedProperties(currentMergedProperties, properties);
+        // the `|| {}` stays because the extended reference point is ABSENT until a plug viz
+        // reports one
+        const currentVisualizationProperties = getExtendedReferencePointProperties(state) || {};
+        const newCurrentProperties = getReplacedProperties(currentVisualizationProperties, properties);
+        if (!areSameVisualizationProperties(currentVisualizationProperties, newCurrentProperties)) {
+            if (properties?.["totals"]) {
+                const { totals, bucketType = "attribute", sortItems } = properties;
+                // we log only when totals were manually configured, not when they come together
+                // with sort items which means they were influenced by changing sorts
+                if (!sortItems) {
+                    yield put(logBucketTotals(bucketType, totals));
+                    yield call(logAggregationsTotal, state, bucketType, totals);
+                }
+            }
+            // store action needs to be put even it is then "reverted" by undo
+            // to keep in sync the ag-grid inner widths with PivotTable props.
+            // THE TOO-LONG GUARD (warn + undo) MOVED with the trigger's write into
+            // store/properties/properties_operations_saga.ts: an undo put from HERE
+            // would now run before the operation's event and be silently overwritten by it.
+            yield put(storeVisualizationProperties(newCurrentProperties, newMergedProperties));
+        }
+    }
+    else {
+        yield put(storeVisualizationProperties(undefined, undefined));
+    }
+}
+export function* watchProperties() {
+    yield takeEvery(ActionTypeKeys.UI_VIS_PROPERTIES_CHANGED, onPropertiesChanged);
+}

package/esm/sagas/reset_sagas.d.ts

@@ -0,0 +1,29 @@
+import { type IAppState } from "../store/types.js";
+export declare function hasDefaultReportId(state: IAppState): boolean;
+export declare function resetReportIdInUri(state: IAppState): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<boolean> | import("redux-saga/effects").SelectEffect, void, never>;
+export declare function logReset(state: IAppState): Generator<import("redux-saga/effects").CallEffect<void>, void, unknown>;
+export declare function resetDateDatasets(): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").SelectEffect, void, string | undefined>;
+/**
+ * RESET_APPLICATION / CLEAR_INSIGHT_CONTENT are pure INTENT triggers — they write nothing. Each
+ * worker below translates its trigger into the semantic reset event the slices honor
+ * (store/app_context/application_reset_events.ts).
+ *
+ * ORDER INSIDE THE WORKER IS LOAD-BEARING: the event is put FIRST, so the `select()`s below read the
+ * POST-reset state — the telemetry formatters need the refreshed sessionId, for one. Keeping the put
+ * and the side effects in ONE worker is also what removes any dependence on watcher registration
+ * order.
+ */
+export declare function onResetApplication(): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<import("../typings/application_reset.js").IApplicationResetCarrier> | import("redux-saga/effects").PutEffect<{
+    payload: {
+        reset: import("../typings/application_reset.js").IApplicationResetCarrier;
+    };
+    type: import("../store/app_context/application_reset_events.js").ApplicationResetActionTypeKeys.STORE_APPLICATION_CLEARED;
+}> | import("redux-saga/effects").SelectEffect, void, import("../store/visualization_classes/visualization_classes_state.js").IVisualizationClassesState & import("../typings/application_reset.js").IApplicationResetCarrier & IAppState>;
+export declare function onClearInsight(): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<import("../typings/application_reset.js").IInsightContentResetCarrier> | import("redux-saga/effects").PutEffect<{
+    payload: {
+        reset: import("../typings/application_reset.js").IInsightContentResetCarrier;
+    };
+    type: import("../store/app_context/application_reset_events.js").ApplicationResetActionTypeKeys.STORE_INSIGHT_CONTENT_CLEARED;
+}> | import("redux-saga/effects").SelectEffect, void, import("../typings/application_reset.js").IInsightContentResetCarrier & IAppState>;
+export declare function watchReset(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+//# sourceMappingURL=reset_sagas.d.ts.map

package/esm/sagas/reset_sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reset_sagas.d.ts","sourceRoot":"","sources":["../../src/sagas/reset_sagas.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAMnD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,WAElD;AAED,wBAAiB,kBAAkB,CAAC,KAAK,EAAE,SAAS,wKAYnD;AAED,wBAAiB,QAAQ,CAAC,KAAK,EAAE,SAAS,2EAEzC;AAED,wBAAiB,iBAAiB,mIAIjC;AAED;;;;;;;;;GASG;AACH,wBAAiB,kBAAkB;;;;;2OAgBlC;AAED,wBAAiB,cAAc;;;;;yIAU9B;AAED,wBAAiB,UAAU,6EAG1B"}

package/esm/sagas/reset_sagas.js

@@ -0,0 +1,62 @@
+// (C) 2007-2026 GoodData Corporation
+import { call, put, select, takeEvery } from "redux-saga/effects";
+import { ActionTypeKeys } from "../constants/actions.js";
+import { DEFAULT_REPORT_ID } from "../constants/route_params.js";
+import { getProjectId } from "../selectors/bootstrap_selector.js";
+import { getDatasetIdentifier } from "../selectors/route_selector.js";
+import { logADClear, logADClearInsight } from "../services/telemetry/tracking_events.js";
+import { applicationCleared, buildApplicationResetCarrier, buildInsightContentResetCarrier, insightContentCleared, } from "../store/app_context/application_reset_events.js";
+import { getRouteReportId } from "../store/router/router_selectors.js";
+import { getVisualizationClassesState } from "../store/visualization_classes/visualization_classes_selectors.js";
+import { getRouteUri, setLocation } from "../utils/location.js";
+import { updateDateDataSets } from "./date_datasets/date_datasets_sagas.js";
+export function hasDefaultReportId(state) {
+    return getRouteReportId(state) === DEFAULT_REPORT_ID;
+}
+export function* resetReportIdInUri(state) {
+    const isDefaultReportId = yield call(hasDefaultReportId, state);
+    if (isDefaultReportId) {
+        return;
+    }
+    const uri = yield select(getRouteUri, { reportId: DEFAULT_REPORT_ID });
+    yield call(setLocation, uri);
+}
+export function* logReset(state) {
+    yield call(logADClear, { state });
+}
+export function* resetDateDatasets() {
+    const projectId = yield select(getProjectId);
+    const activeDatasetId = yield select(getDatasetIdentifier);
+    yield call(updateDateDataSets, projectId, activeDatasetId);
+}
+/**
+ * RESET_APPLICATION / CLEAR_INSIGHT_CONTENT are pure INTENT triggers — they write nothing. Each
+ * worker below translates its trigger into the semantic reset event the slices honor
+ * (store/app_context/application_reset_events.ts).
+ *
+ * ORDER INSIDE THE WORKER IS LOAD-BEARING: the event is put FIRST, so the `select()`s below read the
+ * POST-reset state — the telemetry formatters need the refreshed sessionId, for one. Keeping the put
+ * and the side effects in ONE worker is also what removes any dependence on watcher registration
+ * order.
+ */
+export function* onResetApplication() {
+    const visualizationClasses = yield select(getVisualizationClassesState);
+    const reset = yield call(buildApplicationResetCarrier, visualizationClasses);
+    yield put(applicationCleared({ reset }));
+    const state = yield select();
+    yield call(logReset, state);
+    yield call(resetReportIdInUri, state);
+    yield call(resetDateDatasets);
+    yield call(logADClearInsight, { state });
+}
+export function* onClearInsight() {
+    const reset = yield call(buildInsightContentResetCarrier);
+    yield put(insightContentCleared({ reset }));
+    const state = yield select();
+    yield call(logADClearInsight, { state });
+    yield call(resetDateDatasets);
+}
+export function* watchReset() {
+    yield takeEvery(ActionTypeKeys.RESET_APPLICATION, onResetApplication);
+    yield takeEvery(ActionTypeKeys.CLEAR_INSIGHT_CONTENT, onClearInsight);
+}

package/esm/sagas/router_sagas.d.ts

@@ -0,0 +1,48 @@
+import { type IChangeDatasetAction } from "../actions/data_actions.js";
+import { ActionTypeKeys } from "../constants/actions.js";
+import { type locationChanged as locationChangedCreator, reportIdChanged, sourceInsightChanged } from "../store/router/router_actions.js";
+import { type IAppState } from "../store/types.js";
+export declare function setDatasetRouteParam(action: IChangeDatasetAction): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<string> | import("redux-saga/effects").SelectEffect, void, string & IAppState>;
+export declare function invokeFullReload(state: IAppState): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<string> | import("redux-saga/effects").CallEffect<import("../typings/location.js").ICustomRouteParams> | import("redux-saga/effects").CallEffect<boolean>, void, never>;
+export declare function updateReport(action: ReturnType<typeof reportIdChanged>): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").SelectEffect, void, string | undefined>;
+export declare function updateDraftReport(action: ReturnType<typeof sourceInsightChanged>): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").SelectEffect, void, string | undefined>;
+export declare function locationChanged(action: ReturnType<typeof locationChangedCreator>): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<import("../store/router/router_state.js").IRouteState> | import("redux-saga/effects").CallEffect<string | undefined> | import("redux-saga/effects").CallEffect<"" | boolean | undefined> | import("redux-saga/effects").PutEffect<{
+    payload: undefined;
+    type: ActionTypeKeys.SAGA_ROUTE_PARAMS_CHANGED;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: undefined;
+    type: ActionTypeKeys.REQUEST_EXPLAIN;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: {
+        locked: boolean;
+    };
+    type: ActionTypeKeys.LOCATION_REDIRECT_LOCK;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: {
+        route: import("../store/router/router_state.js").IRouteState;
+        previousRoute: import("../store/router/router_state.js").IRouteState | undefined;
+    };
+    type: import("../store/router/router_actions.js").RouterEventActionTypeKeys;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: {
+        reportId: string;
+    };
+    type: ActionTypeKeys.SAGA_REPORT_ID_CHANGED;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: {
+        sourceInsightId: string;
+    };
+    type: ActionTypeKeys.SAGA_SOURCE_INSIGHT_CHANGED;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: {
+        reset: import("../typings/application_reset.js").IApplicationResetCarrier;
+    };
+    type: import("../store/app_context/application_reset_events.js").ApplicationResetActionTypeKeys.STORE_WHOLE_APPLICATION_RESET;
+}> | import("redux-saga/effects").PutEffect<{
+    payload: {
+        attributeHierarchiesChanged: boolean;
+    };
+    type: import("../store/catalog/catalog_store_actions.js").CatalogActionTypeKeys.STORE_SET_ATTRIBUTE_HIERARCHIES_CHANGED;
+}> | import("redux-saga/effects").SelectEffect, void, never>;
+export declare function watchRouter(): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+//# sourceMappingURL=router_sagas.d.ts.map

package/esm/sagas/router_sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router_sagas.d.ts","sourceRoot":"","sources":["../../src/sagas/router_sagas.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAGvE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAqBzD,OAAO,EACH,KAAK,eAAe,IAAI,sBAAsB,EAE9C,eAAe,EAGf,oBAAoB,EACvB,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAUnD,wBAAiB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,oLAWjE;AAED,wBAAiB,gBAAgB,CAAC,KAAK,EAAE,SAAS,6QAYjD;AAED,wBAAiB,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,kIAKvE;AAED,wBAAiB,iBAAiB,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,kIAKjF;AAED,wBAAiB,eAAe,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6DA6FjF;AAUD,wBAAiB,WAAW,6EAM3B"}

package/esm/sagas/router_sagas.js

@@ -0,0 +1,129 @@
+// (C) 2007-2026 GoodData Corporation
+import { call, put, select, takeEvery, takeLatest } from "redux-saga/effects";
+import { requestExplain } from "../actions/explain_actions.js";
+import { explainExecDef } from "../backend.js";
+import { ActionTypeKeys } from "../constants/actions.js";
+import { isExplainSupported } from "../selectors/backend_capabilities_selector.js";
+import { getProjectId } from "../selectors/bootstrap_selector.js";
+import { getDataSet, getExplainType, getReportId, getSourceInsightId, isExplainRequested, isForceReload, isFullReloadNeeded, isLocationChangeLocked, isSourceInsightParamChanged, reportIdParamChanged, } from "../selectors/route_selector.js";
+import { buildApplicationResetCarrier, wholeApplicationReset, } from "../store/app_context/application_reset_events.js";
+import { hasAttributeHierarchiesChanged } from "../store/catalog/catalog_selector.js";
+import { setAttributeHierarchiesChanged } from "../store/catalog/catalog_store_actions.js";
+import { locationRedirectLock, reportIdChanged, routeChanged, routeParamsChanged, sourceInsightChanged, } from "../store/router/router_actions.js";
+import { buildNextRoute, shouldResetOnNavigation } from "../store/router/router_helpers.js";
+import { getRouteState } from "../store/router/router_selectors.js";
+import { getVisualizationClassesState } from "../store/visualization_classes/visualization_classes_selectors.js";
+import { explainDownload } from "../utils/explainDownloader.js";
+import { getBaseUri, getRouteParams, getRouteUri, setLocation } from "../utils/location.js";
+import { bootstrap } from "./bootstrap_sagas.js";
+import { loadAttributeHierarchies } from "./catalog/catalog_saga.js";
+import { updateSelectedDataset } from "./datasets_sagas.js";
+import { fetchDraftReport, fetchReport } from "./open_report_sagas.js";
+export function* setDatasetRouteParam(action) {
+    const { dataset } = action.payload;
+    const currentDataSet = yield select(getDataSet);
+    if (dataset !== currentDataSet) {
+        const state = yield select();
+        const options = { dataset };
+        const uri = yield call(getRouteUri, state, options);
+        yield call(setLocation, uri);
+    }
+}
+export function* invokeFullReload(state) {
+    const uriParams = yield call(getRouteParams, state);
+    yield call(updateSelectedDataset, true);
+    yield call(bootstrap, uriParams);
+    const forceReload = yield call(isForceReload, state);
+    if (forceReload) {
+        const uri = yield call(getRouteUri, state);
+        yield call(setLocation, uri.replace(/\/reload(\W|$)/, "$1"));
+    }
+}
+export function* updateReport(action) {
+    const projectId = yield select(getProjectId);
+    const reportId = action.payload.reportId;
+    yield call(fetchReport, projectId, reportId);
+}
+export function* updateDraftReport(action) {
+    const projectId = yield select(getProjectId);
+    const sourceInsightId = action.payload.sourceInsightId;
+    yield call(fetchDraftReport, projectId, sourceInsightId);
+}
+export function* locationChanged(action) {
+    /**
+     * THE ROUTE WRITE AND THE RESET DECISION COME FIRST, before anything that can yield or
+     * dispatch — including the click handlers `document.body.click()` below can fire. The prefix up
+     * to the two puts is synchronous effects only, so a rapid follow-up navigation cannot cancel
+     * this takeLatest worker before the route pair and the reset have landed.
+     *
+     * The previous route is the pre-navigation `route` value read HERE: LOCATION_CHANGED itself
+     * writes nothing, so the read still sees the old value, and the `routeChanged` event carries the
+     * pair for the two leaves (store/router/route_leaf_reducers.ts). The reset decision is pure over
+     * the same pair.
+     */
+    const previousRoute = yield select(getRouteState);
+    const route = yield call(buildNextRoute, action.payload.hash, previousRoute);
+    yield put(routeChanged(route, previousRoute));
+    if (shouldResetOnNavigation(route, previousRoute)) {
+        const visualizationClasses = yield select(getVisualizationClassesState);
+        yield put(wholeApplicationReset({ reset: buildApplicationResetCarrier(visualizationClasses) }));
+    }
+    // hide menu and dialogs
+    document.body.click();
+    const state = yield select();
+    const explainType = yield select(getExplainType);
+    const explainRequested = yield select(isExplainRequested);
+    const explainSupported = yield select(isExplainSupported);
+    if (explainRequested && explainSupported) {
+        if (explainExecDef) {
+            yield call(explainDownload, explainExecDef, { explainType });
+            return;
+        }
+        else {
+            yield put(requestExplain());
+        }
+    }
+    const locationChangeLocked = yield call(isLocationChangeLocked, state);
+    if (locationChangeLocked) {
+        yield put(locationRedirectLock(false));
+        return;
+    }
+    const fullReloadNeeded = yield call(isFullReloadNeeded, state);
+    if (fullReloadNeeded) {
+        yield call(invokeFullReload, state);
+        return;
+    }
+    const isReportIdParamChanged = yield call(reportIdParamChanged, state);
+    if (isReportIdParamChanged) {
+        const newReportId = yield call(getReportId, state);
+        yield put(setAttributeHierarchiesChanged(false));
+        yield put(reportIdChanged(newReportId));
+    }
+    else {
+        const isSourceInsightChanged = yield call(isSourceInsightParamChanged, state);
+        if (isSourceInsightChanged) {
+            const sourceInsightId = yield call(getSourceInsightId, state);
+            yield put(setAttributeHierarchiesChanged(false));
+            yield put(sourceInsightChanged(sourceInsightId));
+        }
+    }
+    const shouldLoadAttributeHierarchies = yield select(hasAttributeHierarchiesChanged);
+    if (shouldLoadAttributeHierarchies) {
+        yield call(loadAttributeHierarchies);
+    }
+    yield put(routeParamsChanged());
+}
+function* openCurrentInsightInNewTab() {
+    const state = yield select();
+    const uriParams = yield call(getRouteParams, state);
+    // The page of the host shell that owns AD, without the embedding query params.
+    const uri = `/workspace/${uriParams.projectId}/analyze/${getBaseUri(uriParams)}`;
+    open(uri, "_blank");
+}
+export function* watchRouter() {
+    yield takeLatest(ActionTypeKeys.LOCATION_CHANGED, locationChanged);
+    yield takeEvery(ActionTypeKeys.UI_CHANGE_DATASET, setDatasetRouteParam);
+    yield takeLatest(ActionTypeKeys.SAGA_REPORT_ID_CHANGED, updateReport);
+    yield takeLatest(ActionTypeKeys.SAGA_SOURCE_INSIGHT_CHANGED, updateDraftReport);
+    yield takeEvery(ActionTypeKeys.UI_OPEN_IN_ANALYTICAL_DESIGNER, openCurrentInsightInNewTab);
+}

package/esm/sagas/sagas.d.ts

@@ -0,0 +1,9 @@
+import { type BootstrapError } from "../actions/app_context_actions.js";
+export declare function root(): Generator<import("redux-saga/effects").AllEffect<Generator<import("redux-saga/effects").AllEffect<Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>>, void, unknown> | import("redux-saga").SagaIterator> | import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").ForkEffect<void> | import("redux-saga/effects").PutEffect<{
+    payload: {
+        projectId: string;
+        error: BootstrapError;
+    };
+    type: import("../constants/actions.js").ActionTypeKeys.BOOTSTRAP_ERROR;
+}>, void, unknown>;
+//# sourceMappingURL=sagas.d.ts.map

package/esm/sagas/sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sagas.d.ts","sourceRoot":"","sources":["../../src/sagas/sagas.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,mCAAmC,CAAC;AAyDxF,wBAAiB,IAAI;;;;;;mBAiFpB"}

package/esm/sagas/sagas.js

@@ -0,0 +1,139 @@
+// (C) 2007-2026 GoodData Corporation
+import { all, call, fork, put } from "redux-saga/effects";
+import { bootstrapError } from "../actions/app_context_actions.js";
+import { watchCancelEditFromKD } from "../postMessageApi/sagas/cancel_edit_from_kd_saga.js";
+import { deliverHostCommands } from "../postMessageApi/sagas/host_command_delivery_saga.js";
+import { watchIncomingCommands } from "../postMessageApi/sagas/incoming_command_sagas.js";
+import { watchArithmeticMeasureOperations } from "../store/arithmetic_measures/arithmetic_measures_operations_saga.js";
+import { watchArithmeticMeasures } from "../store/arithmetic_measures/arithmetic_measures_saga.js";
+import { watchBucketFilterOperations } from "../store/bucket_filters/bucket_filters_operations_saga.js";
+import { watchBucketFilters } from "../store/bucket_filters/bucket_filters_sagas.js";
+import { watchBucketFiltersTelemetry } from "../store/bucket_filters/bucket_filters_telemetry_sagas.js";
+import { watchBucketsOperations } from "../store/buckets/buckets_operations_saga.js";
+import { watchExecutionCoordination } from "../store/execution/execution_coordination_saga.js";
+import { watchMetricEditor } from "../store/metric_editor/metric_editor_sagas.js";
+import { watchPropertiesOperations } from "../store/properties/properties_operations_saga.js";
+import { watchRecommendationOperations } from "../store/recommendations/recommendations_operations_saga.js";
+import { watchRecommendations } from "../store/recommendations/recommendations_sagas.js";
+import { watchDispatchPostponedAction } from "../store/shortcuts/postponed_action_sagas.js";
+import { watchShortcutOperations } from "../store/shortcuts/shortcuts_operations_saga.js";
+import { loadIntlMessages, watchApplicationContext } from "./application_context/application_context_saga.js";
+import { watchApplicationInitialization } from "./application_initialization_tracking_sagas.js";
+import { watchApplicationRedirect } from "./application_redirect_sagas.js";
+import { waitForBackendInitialization } from "./backend_sagas.js";
+import { watchErrorBootstrap } from "./bootstrap_error_sagas.js";
+import { watchBuckets } from "./bucket_saga.js";
+import { watchBucketsToSetNotifications } from "./buckets_notifications/buckets_notifications_saga.js";
+import { watchCatalog } from "./catalog/catalog_saga.js";
+import { watchChartSort } from "./chart_sort/chart_sort_saga.js";
+import { watchDraggedCatalogItems } from "./config_panel/config_panel_saga.js";
+import { confirmUnsavedChangesWatcher } from "./confirm_unsaved_changes_sagas.js";
+import { watchDataSampling } from "./data_sample_sagas.js";
+import { watchDateDatasets } from "./date_datasets/date_datasets_sagas.js";
+import { watchDeleteReport } from "./delete_report_sagas.js";
+import { watchDescriptionTooltip } from "./description_tooltip/description_tooltip_saga.js";
+import { dragAndDropWatcher } from "./drag_and_drop/drag_and_drop_saga.js";
+import { drillWatcher } from "./drill_sagas.js";
+import { watchDrillableItems } from "./drillable_items_sagas.js";
+import { watchEmbedDialogSaga } from "./embed_dialog_sagas.js";
+import { watchExecuteReport } from "./execute_report_sagas.js";
+import { watchExportReport } from "./export_report_sagas.js";
+import { watchLoadExternalScripts } from "./external_scripts_saga.js";
+import { watchFeatureFlags } from "./featureFlags_sagas.js";
+import { watchFilterBar } from "./filter_bar/filter_bar_saga.js";
+import { highlightingWatcher } from "./highlighting/highlighting_saga.js";
+import { watchInsightAccess } from "./insight_access_sagas.js";
+import { messagesWatcher } from "./messages_sagas.js";
+import { watchOpenReport } from "./open_report_sagas.js";
+import { watchPermissions } from "./permissions_saga.js";
+import { watchPoweredByGDC } from "./powered_by_gdc/powered_by_gdc_saga.js";
+import { watchProperties } from "./properties_sagas.js";
+import { watchReset } from "./reset_sagas.js";
+import { watchRouter } from "./router_sagas.js";
+import { watchSaveReport } from "./save_report_sagas.js";
+import { watchSelectVisualizationType } from "./select_visualization_type_sagas.js";
+import { watchShortcuts } from "./shortcut_sagas.js";
+import { watchTelemetryInitialized } from "./tracking/telemetry_initialized_saga.js";
+import { watchUiExtendedReferencePointChanged } from "./ui_extended_reference_point_changed_sagas.js";
+export function* root() {
+    yield call(loadIntlMessages, "en-US");
+    yield fork(watchApplicationContext);
+    yield call(waitForBackendInitialization);
+    try {
+        yield all([
+            // FIRST, and the position is deliberate. The buckets family's 24 triggers → ~15 operations →
+            // one semantic event each; it replaced `bucketsApplyReducer`, so without it the
+            // triggers write nothing at all. That reducer ran BEFORE any saga observed a trigger, so the
+            // buckets write always landed ahead of every other reaction to the same trigger. Registering
+            // this watcher first is what keeps that true: takers run in registration order, so its event
+            // is the first dispatch the trigger produces.
+            //
+            // It is a DEFAULT, not a guarantee any other saga may lean on — a `put` only reaches the
+            // reducer after the current scheduler flush, so a watcher that needs the committed value has
+            // to wait for the event itself (`store/shortcuts/postponed_action_sagas.ts` is the one that
+            // does, and the shortcut it replays was dropped on the floor until it did).
+            watchBucketsOperations(),
+            // these operation watchers sit right behind the buckets family's, for the same
+            // reason it is registered first: their event should be the trigger's first reaction
+            watchPropertiesOperations(),
+            watchArithmeticMeasureOperations(),
+            watchRecommendationOperations(),
+            watchShortcutOperations(),
+            // the bucket-filters family — same slot, same reasoning
+            watchBucketFilterOperations(),
+            // REPORT_EXECUTION_FINISHED → the current-execution coordination event that
+            // closes report.nowOpen — same slot, same reasoning
+            watchExecutionCoordination(),
+            watchErrorBootstrap(),
+            watchDateDatasets(),
+            watchReset(),
+            watchExecuteReport(),
+            watchExportReport(),
+            watchShortcuts(),
+            watchOpenReport(),
+            watchSaveReport(),
+            watchInsightAccess(),
+            watchCancelEditFromKD(),
+            watchDeleteReport(),
+            watchRouter(),
+            watchDrillableItems(),
+            watchIncomingCommands(),
+            watchDispatchPostponedAction(),
+            watchLoadExternalScripts(),
+            watchCatalog(),
+            watchFilterBar(),
+            watchFeatureFlags(),
+            watchArithmeticMeasures(),
+            watchRecommendations(),
+            watchBucketFilters(),
+            watchBucketFiltersTelemetry(),
+            highlightingWatcher(),
+            watchDraggedCatalogItems(),
+            watchBucketsToSetNotifications(),
+            watchBuckets(),
+            watchDataSampling(),
+            dragAndDropWatcher(),
+            drillWatcher(),
+            watchProperties(),
+            watchPermissions(),
+            confirmUnsavedChangesWatcher(),
+            watchApplicationRedirect(),
+            messagesWatcher(),
+            watchMetricEditor(),
+            watchChartSort(),
+            watchSelectVisualizationType(),
+            watchUiExtendedReferencePointChanged(),
+            watchEmbedDialogSaga(),
+            watchApplicationInitialization(),
+            watchPoweredByGDC(),
+            watchDescriptionTooltip(),
+            watchTelemetryInitialized(),
+            // LAST: it delivers the in-process host commands, so every watcher above listens first.
+            deliverHostCommands(),
+        ]);
+    }
+    catch (e) {
+        console.error(e);
+        yield put(bootstrapError("", e));
+    }
+}

package/esm/sagas/save_report_sagas.d.ts

@@ -0,0 +1,34 @@
+import { type SagaIterator } from "redux-saga";
+import { type AccessGranularPermission, type IInsight, type IInsightDefinition } from "@gooddata/sdk-model";
+import { type ISaveReportCheckAction, type ISaveReportRequestedAction, type ISaveReportStartedAction } from "../actions/save_actions.js";
+import { ActionTypeKeys } from "../constants/actions.js";
+import { type IVisualization } from "../typings/bear/bearTypes.js";
+export declare const SHOW_LONG_SAVING_MESSAGE_AFTER = 1000;
+export declare const HIDE_SUCCESS_MESSAGE_AFTER = 2500;
+export declare function performSaveExisting(projectId: string, insightToSave: IInsight): Promise<IInsight>;
+export declare function performSaveNew(projectId: string, insightToSave: IInsightDefinition): Promise<IInsight>;
+export declare function getReportObjectForSaveEmbeddingMessage(_projectId: string, insight: IInsight): IInsight;
+export declare function savedInsightPermissions(projectId: string, reportId: string, isUpdate: boolean): SagaIterator<AccessGranularPermission[] | undefined>;
+export declare function saveReport({ payload: { saveAsNew, editingFromKD, postMessageContext }, }: ISaveReportStartedAction): SagaIterator<void>;
+export declare function saveReportCheck({ payload: { saveAsNew, editingFromKD, reOpenEmbedDialog }, }: ISaveReportCheckAction): SagaIterator<void>;
+/** The save terminated, either way. An RTK matcher over the two creators, not a string list. */
+export declare const isSavingDoneAction: (action: any) => action is {
+    payload: {
+        reportMDObject: IVisualization;
+        saveAsNew: boolean;
+        time: number;
+        editingFromKD: any;
+    };
+    type: ActionTypeKeys.SAVE_REPORT_FINISHED;
+} | {
+    payload: {
+        saveAsNew: boolean;
+        time: number;
+        editingFromKD: any;
+        error: Error | undefined;
+    };
+    type: ActionTypeKeys.SAVE_REPORT_ERROR;
+};
+export declare function saveReportRequested({ payload: { saveAsNew, editingFromKD, postMessageContext, reOpenEmbedDialog }, }: ISaveReportRequestedAction): SagaIterator<void>;
+export declare function watchSaveReport(): Generator<import("redux-saga/effects").AllEffect<import("redux-saga/effects").ForkEffect<never>>, void, unknown>;
+//# sourceMappingURL=save_report_sagas.d.ts.map

package/esm/sagas/save_report_sagas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"save_report_sagas.d.ts","sourceRoot":"","sources":["../../src/sagas/save_report_sagas.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAa/C,OAAO,EACH,KAAK,wBAAwB,EAC7B,KAAK,QAAQ,EACb,KAAK,kBAAkB,EAE1B,MAAM,qBAAqB,CAAC;AAU7B,OAAO,EACH,KAAK,sBAAsB,EAC3B,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAMhC,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAwBzD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAYnE,eAAO,MAAM,8BAA8B,OAAO,CAAC;AACnD,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,qBAG7E;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,kBAAkB,qBAGlF;AAED,wBAAgB,sCAAsC,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,YAE3F;AAGD,wBAAiB,uBAAuB,CACpC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,OAAO,GAClB,YAAY,CAAC,wBAAwB,EAAE,GAAG,SAAS,CAAC,CAoBtD;AAED,wBAAiB,UAAU,CAAC,EACxB,OAAO,EAAE,EAAE,SAAS,EAAE,aAAa,EAAE,kBAAkB,EAAE,GAC5D,EAAE,wBAAwB,GAAG,YAAY,CAAC,IAAI,CAAC,CA8G/C;AAED,wBAAiB,eAAe,CAAC,EAC7B,OAAO,EAAE,EAAE,SAAS,EAAE,aAAa,EAAE,iBAAiB,EAAE,GAC3D,EAAE,sBAAsB,GAAG,YAAY,CAAC,IAAI,CAAC,CAW7C;AAED,gGAAgG;AAChG,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;CAA+C,CAAC;AAE/E,wBAAiB,mBAAmB,CAAC,EACjC,OAAO,EAAE,EAAE,SAAS,EAAE,aAAa,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,GAC/E,EAAE,0BAA0B,GAAG,YAAY,CAAC,IAAI,CAAC,CA2BjD;AAED,wBAAiB,eAAe,qHAM/B"}