@gooddata/sdk-ui-dashboard 11.54.0-alpha.3 → 11.54.0-alpha.5

package/esm/model/DashboardTester.d.ts

@@ -0,0 +1,150 @@
+import { type PayloadAction } from "@reduxjs/toolkit";
+import { type RecordedBackendConfig } from "@gooddata/sdk-backend-mockingbird";
+import { type IBackendCapabilities } from "@gooddata/sdk-backend-spi";
+import { type Identifier } from "@gooddata/sdk-model";
+import { type IRenderingWorkerConfiguration } from "./commandHandlers/render/types.js";
+import { type DashboardCommandType } from "./commands/base.js";
+import { type InitializeDashboard } from "./commands/dashboard.js";
+import { type DashboardEventType } from "./events/base.js";
+import { type DashboardEvents } from "./events/index.js";
+import { HeadlessDashboard } from "./headlessDashboard/HeadlessDashboard.js";
+import { type IDashboardQueryService } from "./store/_infra/queryService.js";
+import { type DashboardState } from "./store/types.js";
+import { type DashboardContext, type DashboardModelCustomizationFns } from "./types/commonTypes.js";
+type DashboardTesterConfig = {
+    queryServices?: IDashboardQueryService<any, any>[];
+    renderingWorkerConfig?: IRenderingWorkerConfiguration;
+    customizationFns?: DashboardModelCustomizationFns;
+};
+export declare class DashboardTester extends HeadlessDashboard {
+    protected constructor(ctx: DashboardContext, config?: DashboardTesterConfig);
+    /**
+     * Creates an instance of DashboardTester set up to run tests on top of a dashboard with the provided
+     * identifier. The dashboard will be loaded from recorded backend, from its reference workspace.
+     *
+     * You may additionally influence how the different query services behave (typically to stub/mock the service)
+     */
+    static forRecording(identifier: Identifier, testerConfig?: DashboardTesterConfig, backendConfig?: RecordedBackendConfig, customCapabilities?: Partial<IBackendCapabilities>): DashboardTester;
+    /**
+     * Creates an instance of DashboardTester set up to run tests on top of an empty, freshly initialized dashboard.
+     *
+     * You may additionally influence how the different query services behave (typically to stub/mock the service)
+     */
+    static forNewDashboard(testerConfig?: DashboardTesterConfig, backendConfig?: RecordedBackendConfig): DashboardTester;
+    /**
+     * Wait the specified time.
+     *
+     * @param timeout - timeout after which the wait will be resolved
+     * @returns promise
+     */
+    wait(timeout: number): Promise<void>;
+    /**
+     * Returns all actions that were dispatched since the tester was created or since it was last reset.
+     */
+    dispatchedActions(): ReadonlyArray<PayloadAction<any>>;
+    /**
+     * Wait for all of the listed actions to occur. The wait is bounded by a timeout that is 1s by default.
+     *
+     * This is useful when testing commands that emit multiple events and you need to verify that all of the
+     * events happened. This function does not care about the order in which the events occurred.
+     *
+     * @param actionTypes - action types to wait for
+     * @param timeout - timeout after which the wait fails
+     */
+    waitForAll(actionTypes: ReadonlyArray<DashboardEventType | DashboardCommandType | string>, timeout?: number): Promise<any>;
+    /**
+     * Returns all events that were emitted during execution. Events are a sub-type of actions - they are
+     * actions that are suitable for external consumption and describe what has happened in the dashboard.
+     *
+     * The events are accumulated during test run. You may reset them using `resetMonitors`
+     */
+    emittedEvents(): ReadonlyArray<DashboardEvents>;
+    /**
+     * Resets internal state of the tester's monitors. The captured actions will be cleared up as part
+     * of this.
+     */
+    resetMonitors(): void;
+    /**
+     * Returns dashboard state.
+     */
+    state(): DashboardState;
+    /**
+     * Returns digests of all events that were emitted during execution. Digest contains just the event
+     * type and the correlation id of the event. The payload is discarded.
+     *
+     * This is useful for snapshotting event sequence.
+     */
+    emittedEventsDigest(): ReadonlyArray<{
+        type: string;
+        correlationId?: string;
+    }>;
+}
+export interface IPreloadedTesterOptions {
+    /**
+     * Customize the load command.
+     *
+     * Default is plain command created by `initializeDashboard()`.
+     */
+    initCommand?: InitializeDashboard;
+    /**
+     * Customize recorded backend configuration.
+     *
+     * Default is no customization.
+     */
+    backendConfig?: RecordedBackendConfig;
+    /**
+     * Customize recorded backend capabilities
+     *
+     * Default is no customization
+     */
+    customCapabilities?: Partial<IBackendCapabilities>;
+    /**
+     * Customize implementations of query services to use for the component.
+     *
+     * Default is no customization, meaning default implementations will be used. Note that with default
+     * implementations you may encounter runtime errors as they want to use SPI methods that are not implemented
+     * on the recorded analytical backend.
+     */
+    queryServices?: IDashboardQueryService<any, any>[];
+    /**
+     * Customize dashboard model customization functions.
+     *
+     * Default is no customization.
+     */
+    customizationFns?: DashboardModelCustomizationFns;
+}
+/**
+ * This factory will return a function that can be integrated into vitest's `beforeAll` or `beforeEach` statements. That returned
+ * function will drive initialization of the dashboard tester and will tell vitest it's `done` or it will `fail`.
+ *
+ * When successfully loaded, the returned function will call the `onLoaded` callback
+ *
+ * An example usage:
+ *
+ * ```
+ *    let Tester: DashboardTester;
+ *
+ *       beforeEach(async ()=> {
+ *           await preloadedTesterFactory2((tester) => {
+ *               Tester = tester;
+ *           }, SimpleDashboardIdentifier);
+ *       });
+ *
+ *    it("should do xyz", () => {
+ *
+ *    })
+ * ```
+ *
+ * Obvious warning: beforeAll creates one instance for all tests and is therefore not safe when some tests do modifications of
+ * the dashboard. Use beforeEach in that case.
+ *
+ * Note: before sending the instance of dashboard tester, the function will ensure all the event monitors are reset so
+ * that the captured events related to load do not interfere with the test itself.
+ *
+ * @param onLoaded - function to call when the dashboard is successfully loaded
+ * @param identifier - identifier of the dashboard to load
+ * @param options - options influencing how the tester is created
+ */
+export declare function preloadedTesterFactory(onLoaded: (tester: DashboardTester) => void | Promise<void>, identifier?: Identifier, options?: IPreloadedTesterOptions): Promise<void>;
+export {};
+//# sourceMappingURL=DashboardTester.d.ts.map

package/esm/model/DashboardTester.d.ts.map

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

package/esm/model/DashboardTester.js

@@ -0,0 +1,208 @@
+// (C) 2021-2026 GoodData Corporation
+import { ReferenceRecordings } from "@gooddata/reference-workspace";
+import { defaultRecordedBackendCapabilities, objRefsToStringKey, recordedBackend, } from "@gooddata/sdk-backend-mockingbird";
+import { idRef } from "@gooddata/sdk-model";
+import { newRenderingWorker } from "./commandHandlers/render/renderingWorker.js";
+import { initializeDashboard } from "./commands/dashboard.js";
+import { isDashboardCommandStarted, isDashboardQueryCompleted, isDashboardQueryStarted, } from "./events/general.js";
+import { HeadlessDashboard } from "./headlessDashboard/HeadlessDashboard.js";
+export class DashboardTester extends HeadlessDashboard {
+    constructor(ctx, config) {
+        const headlessDahboardConfig = {
+            queryServices: config?.queryServices,
+            backgroundWorkers: [newRenderingWorker(config?.renderingWorkerConfig || {})],
+            customizationFns: config?.customizationFns,
+        };
+        super(ctx, headlessDahboardConfig);
+    }
+    /**
+     * Creates an instance of DashboardTester set up to run tests on top of a dashboard with the provided
+     * identifier. The dashboard will be loaded from recorded backend, from its reference workspace.
+     *
+     * You may additionally influence how the different query services behave (typically to stub/mock the service)
+     */
+    static forRecording(identifier, testerConfig, backendConfig, customCapabilities) {
+        const ctx = {
+            backend: recordedBackend(ReferenceRecordings.Recordings, {
+                ...backendConfig,
+                getCommonAttributesResponses: {
+                    ...commonAttributeResponses,
+                    ...(backendConfig?.getCommonAttributesResponses || {}),
+                },
+            }, {
+                ...defaultRecordedBackendCapabilities,
+                ...customCapabilities,
+            }),
+            workspace: "reference-workspace",
+            dashboardRef: idRef(identifier),
+        };
+        return new DashboardTester(ctx, testerConfig);
+    }
+    /**
+     * Creates an instance of DashboardTester set up to run tests on top of an empty, freshly initialized dashboard.
+     *
+     * You may additionally influence how the different query services behave (typically to stub/mock the service)
+     */
+    static forNewDashboard(testerConfig, backendConfig) {
+        const ctx = {
+            backend: recordedBackend(ReferenceRecordings.Recordings, {
+                ...backendConfig,
+                getCommonAttributesResponses: {
+                    ...commonAttributeResponses,
+                    ...(backendConfig?.getCommonAttributesResponses || {}),
+                },
+            }),
+            workspace: "reference-workspace",
+        };
+        return new DashboardTester(ctx, testerConfig);
+    }
+    /**
+     * Wait the specified time.
+     *
+     * @param timeout - timeout after which the wait will be resolved
+     * @returns promise
+     */
+    wait(timeout) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve();
+            }, timeout);
+        });
+    }
+    /**
+     * Returns all actions that were dispatched since the tester was created or since it was last reset.
+     */
+    dispatchedActions() {
+        return this.capturedActions.slice();
+    }
+    /**
+     * Wait for all of the listed actions to occur. The wait is bounded by a timeout that is 1s by default.
+     *
+     * This is useful when testing commands that emit multiple events and you need to verify that all of the
+     * events happened. This function does not care about the order in which the events occurred.
+     *
+     * @param actionTypes - action types to wait for
+     * @param timeout - timeout after which the wait fails
+     */
+    waitForAll(actionTypes, timeout = 1000) {
+        return Promise.race([
+            Promise.all(actionTypes.map((actionType) => this.getOrCreateMonitoredAction(actionType).promise)),
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error(`Wait for all actions '${actionTypes.join(", ")}' timed out after ${timeout}ms`));
+                }, timeout);
+            }),
+        ]);
+    }
+    /**
+     * Returns all events that were emitted during execution. Events are a sub-type of actions - they are
+     * actions that are suitable for external consumption and describe what has happened in the dashboard.
+     *
+     * The events are accumulated during test run. You may reset them using `resetMonitors`
+     */
+    emittedEvents() {
+        return this.capturedEvents.slice();
+    }
+    /**
+     * Resets internal state of the tester's monitors. The captured actions will be cleared up as part
+     * of this.
+     */
+    resetMonitors() {
+        this.capturedActions = [];
+        this.capturedEvents = [];
+        this.monitoredActions = {};
+    }
+    /**
+     * Returns dashboard state.
+     */
+    state() {
+        return super.state();
+    }
+    /**
+     * Returns digests of all events that were emitted during execution. Digest contains just the event
+     * type and the correlation id of the event. The payload is discarded.
+     *
+     * This is useful for snapshotting event sequence.
+     */
+    emittedEventsDigest() {
+        return this.emittedEvents().map((evt) => {
+            if (isDashboardQueryStarted(evt) || isDashboardQueryCompleted(evt)) {
+                return {
+                    type: evt.type,
+                    correlationId: evt.correlationId,
+                    queryType: evt.payload.query.type,
+                };
+            }
+            if (isDashboardCommandStarted(evt)) {
+                return {
+                    type: evt.type,
+                    correlationId: evt.correlationId,
+                    commandType: evt.payload.command.type,
+                };
+            }
+            return {
+                type: evt.type,
+                correlationId: evt.correlationId,
+            };
+        });
+    }
+}
+/**
+ * This factory will return a function that can be integrated into vitest's `beforeAll` or `beforeEach` statements. That returned
+ * function will drive initialization of the dashboard tester and will tell vitest it's `done` or it will `fail`.
+ *
+ * When successfully loaded, the returned function will call the `onLoaded` callback
+ *
+ * An example usage:
+ *
+ * ```
+ *    let Tester: DashboardTester;
+ *
+ *       beforeEach(async ()=> {
+ *           await preloadedTesterFactory2((tester) => {
+ *               Tester = tester;
+ *           }, SimpleDashboardIdentifier);
+ *       });
+ *
+ *    it("should do xyz", () => {
+ *
+ *    })
+ * ```
+ *
+ * Obvious warning: beforeAll creates one instance for all tests and is therefore not safe when some tests do modifications of
+ * the dashboard. Use beforeEach in that case.
+ *
+ * Note: before sending the instance of dashboard tester, the function will ensure all the event monitors are reset so
+ * that the captured events related to load do not interfere with the test itself.
+ *
+ * @param onLoaded - function to call when the dashboard is successfully loaded
+ * @param identifier - identifier of the dashboard to load
+ * @param options - options influencing how the tester is created
+ */
+export async function preloadedTesterFactory(onLoaded, identifier, options = {}) {
+    const { initCommand = initializeDashboard(), queryServices, backendConfig, customCapabilities, customizationFns, } = options;
+    const tester = identifier
+        ? DashboardTester.forRecording(identifier, { queryServices, customizationFns }, {
+            ...backendConfig,
+        }, {
+            ...customCapabilities,
+        })
+        : DashboardTester.forNewDashboard({ queryServices, customizationFns }, {
+            ...backendConfig,
+        });
+    tester.dispatch(initCommand);
+    await tester
+        .waitFor("GDC.DASH/EVT.INITIALIZED")
+        .then(() => Promise.resolve(onLoaded(tester)).then(() => tester.resetMonitors()))
+        .catch((err) => {
+        throw `DashboardTester failed to load dashboard: ${err.message}`;
+    });
+}
+const commonAttributeResponses = {
+    [objRefsToStringKey([idRef("obj_1054"), idRef("obj_1086")])]: [idRef("obj_1057")],
+    [objRefsToStringKey([idRef("obj_1054"), idRef("obj_1088")])]: [idRef("obj_1057")],
+    [objRefsToStringKey([idRef("obj_1054"), idRef("obj_1070")])]: [idRef("obj_1057")],
+    [objRefsToStringKey([idRef("obj_1070"), idRef("obj_1088")])]: [idRef("obj_1057")],
+    [objRefsToStringKey([idRef("obj_1086"), idRef("obj_1088")])]: [idRef("obj_1057")],
+    [objRefsToStringKey([idRef("obj_1070"), idRef("obj_1086")])]: [idRef("obj_1057")],
+};

package/esm/model/commandHandlers/dashboard/initializeDashboardHandler/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/dashboard/initializeDashboardHandler/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,WAAW,EAAgB,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAiC,KAAK,iBAAiB,EAAc,MAAM,2BAA2B,CAAC;AAC9G,OAAO,EACH,KAAK,UAAU,EAIf,KAAK,sBAAsB,EAW9B,MAAM,qBAAqB,CAAC;AAM7B,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAqB1E,OAAO,EACH,KAAK,gBAAgB,EAGxB,MAAM,+BAA+B,CAAC;AA4bvC,wBAAiB,cAAc,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,mBAAmB;;;yDAgB9E;AAkCD,wBAAiB,2BAA2B,CAAC,GAAG,EAAE,gBAAgB,EAAE,SAAS,EAAE,UAAU;;;0EAKxF;AAED,wBAAiB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,sNAW3D;AAcD,wBAAiB,0BAA0B,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,mBAAmB,GAAG,YAAY,CA6BzG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/dashboard/initializeDashboardHandler/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,WAAW,EAAgB,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAiC,KAAK,iBAAiB,EAAc,MAAM,2BAA2B,CAAC;AAC9G,OAAO,EACH,KAAK,UAAU,EAIf,KAAK,sBAAsB,EAW9B,MAAM,qBAAqB,CAAC;AAM7B,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAsB1E,OAAO,EACH,KAAK,gBAAgB,EAGxB,MAAM,+BAA+B,CAAC;AAwcvC,wBAAiB,cAAc,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,mBAAmB;;;yDAgB9E;AAkCD,wBAAiB,2BAA2B,CAAC,GAAG,EAAE,gBAAgB,EAAE,SAAS,EAAE,UAAU;;;0EAKxF;AAED,wBAAiB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,sNAW3D;AAoCD,wBAAiB,0BAA0B,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,mBAAmB,GAAG,YAAY,CAoCzG"}

package/esm/model/commandHandlers/dashboard/initializeDashboardHandler/index.js

@@ -5,6 +5,7 @@ import { all, call, put, spawn } from "redux-saga/effects";
 import { walkLayout } from "@gooddata/sdk-backend-spi";
 import { areObjRefsEqual, isDrillToInsight, isInsightWidget, isVisualizationSwitcherWidget, serializeObjRef, } from "@gooddata/sdk-model";
 import { createDisplayFormMap, createDisplayFormMapFromCatalog, } from "../../../../_staging/catalog/displayFormMap.js";
+import { changeDashboardTimezoneOverride } from "../../../commands/timezone.js";
 import { dashboardInitialized } from "../../../events/dashboard.js";
 import { getPrivateContext } from "../../../store/_infra/contexts.js";
 import { accessibleDashboardsActions } from "../../../store/accessibleDashboards/index.js";
@@ -25,8 +26,10 @@ import { tabsActions } from "../../../store/tabs/index.js";
 import { DEFAULT_TAB_ID } from "../../../store/tabs/tabsState.js";
 import { uiActions } from "../../../store/ui/index.js";
 import { userActions } from "../../../store/user/index.js";
+import { changeDashboardTimezoneOverrideHandler } from "../../timezone/changeDashboardTimezoneOverrideHandler.js";
 import { applyDefaultFilterView } from "../common/filterViews.js";
 import { actionsToInitializeExistingDashboard, actionsToInitializeNewDashboard, } from "../common/stateInitializers.js";
+import { loadAutomationTimezone } from "./loadAutomationTimezone.js";
 import { loadCatalog } from "./loadCatalog.js";
 import { loadDashboardList } from "./loadDashboardList.js";
 import { loadDashboardParameters } from "./loadDashboardParameters.js";
@@ -175,8 +178,9 @@ function* loadExistingDashboard(ctx, cmd, dashboardRef) {
         call(loadDateHierarchyTemplates, ctx),
         call(loadFilterViews, ctx),
         call(loadExportTimezone, ctx),
+        call(loadAutomationTimezone, ctx),
     ];
-    const [dashboardWithReferences, { resolvedConfig: config, additionalData: { workspaceAutomationsCount, notificationChannelsCount }, }, permissions, entitlements, user, dashboardPermissions, dateHierarchyTemplates, filterViews, exportTimezone,] = yield all(calls);
+    const [dashboardWithReferences, { resolvedConfig: config, additionalData: { workspaceAutomationsCount, notificationChannelsCount }, }, permissions, entitlements, user, dashboardPermissions, dateHierarchyTemplates, filterViews, exportTimezone, automationTimezone,] = yield all(calls);
     const { dashboard: loadedDashboard, references: { insights }, } = dashboardWithReferences;
     const dashboardWithFilterView = applyDefaultFilterView(loadedDashboard, filterViews, config.exportId);
     // Resolve active tab: URL's initialTabId takes precedence, otherwise default to first tab
@@ -221,6 +225,8 @@ function* loadExistingDashboard(ctx, cmd, dashboardRef) {
     return {
         batch,
         event,
+        // an export render takes its timezone from the export itself
+        automationTimezone: exportTimezone ? undefined : automationTimezone,
     };
 }
 function* initializeNewDashboard(ctx, cmd) {
@@ -339,6 +345,20 @@ function* advancedLoader(ctx, cmd, dashboard) {
         call(requestDashboardsList, ctx),
     ]);
 }
+/**
+ * Applies a deep-linked automation's timezone as the dashboard's timezone override. A rejection
+ * (feature disabled, invalid stored timezone) leaves the dashboard on its own timezone rather
+ * than failing the initialization.
+ */
+function* restoreAutomationTimezone(ctx, timezoneId, correlationId) {
+    try {
+        const event = yield call(changeDashboardTimezoneOverrideHandler, ctx, changeDashboardTimezoneOverride(timezoneId, correlationId, true));
+        yield put(event);
+    }
+    catch (reason) {
+        console.error(`Restoring the timezone "${timezoneId}" of the deep-linked automation failed`, reason);
+    }
+}
 export function* initializeDashboardHandler(ctx, cmd) {
     const { dashboardRef } = ctx;
     try {
@@ -351,6 +371,12 @@ export function* initializeDashboardHandler(ctx, cmd) {
             result = (yield call(initializeNewDashboard, ctx, cmd));
         }
         yield put(result.batch);
+        // before the loading success that lets the widgets render and execute, so the notification
+        // recipient never sees the dashboard's own timezone first. The view-mode override check is
+        // bypassed: the automation was evaluated in this timezone, whatever the dashboard says now.
+        if (result.automationTimezone) {
+            yield call(restoreAutomationTimezone, ctx, result.automationTimezone, cmd.correlationId);
+        }
         yield put(loadingActions.setLoadingSuccess());
         yield put(result.event);
         if (dashboardRef) {

package/esm/model/commandHandlers/dashboard/initializeDashboardHandler/loadAutomationTimezone.d.ts

@@ -0,0 +1,9 @@
+import { type DashboardContext } from "../../../types/commonTypes.js";
+/**
+ * Loads the timezone baked into the automation the dashboard is deep-linked to (the focus
+ * object's `automationId`, as used by the links in alert and scheduled-export notifications).
+ * Restoring it is what makes the dashboard match the numbers the recipient was mailed.
+ * Undefined means the dashboard's own (or workspace/organization) timezone applies.
+ */
+export declare function loadAutomationTimezone(ctx: DashboardContext): Promise<string | undefined>;
+//# sourceMappingURL=loadAutomationTimezone.d.ts.map

package/esm/model/commandHandlers/dashboard/initializeDashboardHandler/loadAutomationTimezone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadAutomationTimezone.d.ts","sourceRoot":"","sources":["../../../../../src/model/commandHandlers/dashboard/initializeDashboardHandler/loadAutomationTimezone.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEtE;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAmB/F"}

package/esm/model/commandHandlers/dashboard/initializeDashboardHandler/loadAutomationTimezone.js

@@ -0,0 +1,27 @@
+// (C) 2026 GoodData Corporation
+import { getAutomationTimezone } from "../../../../_staging/automation/index.js";
+/**
+ * Loads the timezone baked into the automation the dashboard is deep-linked to (the focus
+ * object's `automationId`, as used by the links in alert and scheduled-export notifications).
+ * Restoring it is what makes the dashboard match the numbers the recipient was mailed.
+ * Undefined means the dashboard's own (or workspace/organization) timezone applies.
+ */
+export async function loadAutomationTimezone(ctx) {
+    const { automationId } = ctx.config?.focusObject ?? {};
+    if (!automationId) {
+        return undefined;
+    }
+    try {
+        // the service getter itself throws on backends without automation support
+        const automation = await ctx.backend
+            .workspace(ctx.workspace)
+            .automations()
+            .getAutomation(automationId);
+        return getAutomationTimezone(automation);
+    }
+    catch (error) {
+        // a missing or inaccessible automation must not fail the dashboard load
+        console.error("Loading of the automation timezone failed", error);
+        return undefined;
+    }
+}

package/esm/model/commandHandlers/timezone/changeDashboardTimezoneOverrideHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"changeDashboardTimezoneOverrideHandler.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/timezone/changeDashboardTimezoneOverrideHandler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAK/C,OAAO,EAAE,KAAK,gCAAgC,EAAE,MAAM,4BAA4B,CAAC;AAEnF,OAAO,EACH,KAAK,iCAAiC,EAEzC,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAWnE,wBAAiB,sCAAsC,CACnD,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,gCAAgC,GACtC,YAAY,CAAC,iCAAiC,CAAC,CAuCjD"}
+{"version":3,"file":"changeDashboardTimezoneOverrideHandler.d.ts","sourceRoot":"","sources":["../../../../src/model/commandHandlers/timezone/changeDashboardTimezoneOverrideHandler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAK/C,OAAO,EAAE,KAAK,gCAAgC,EAAE,MAAM,4BAA4B,CAAC;AAEnF,OAAO,EACH,KAAK,iCAAiC,EAEzC,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,wBAAiB,sCAAsC,CACnD,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,gCAAgC,GACtC,YAAY,CAAC,iCAAiC,CAAC,CAuCjD"}

package/esm/model/commandHandlers/timezone/changeDashboardTimezoneOverrideHandler.js

@@ -1,20 +1,11 @@
 // (C) 2026 GoodData Corporation
 import { put, select } from "redux-saga/effects";
-import { resolveTimezoneId } from "@gooddata/sdk-model";
+import { isValidIanaTimezoneId, resolveTimezoneId } from "@gooddata/sdk-model";
 import { invalidArgumentsProvided } from "../../events/general.js";
 import { dashboardTimezoneOverrideChanged, } from "../../events/timezone.js";
 import { selectEnableTimezoneChange } from "../../store/config/configSelectors.js";
 import { selectDashboardTimezoneConfig, selectEffectiveDashboardTimezone, } from "../../store/meta/metaSelectors.js";
 import { uiActions } from "../../store/ui/index.js";
-function isValidIanaTimezoneId(timezoneId) {
-    try {
-        new Intl.DateTimeFormat(undefined, { timeZone: timezoneId });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 export function* changeDashboardTimezoneOverrideHandler(ctx, cmd) {
     // the gating protects paths that arrive from outside the UI (e.g. the embedding
     // setTimezone postMessage), which do not go through the menu-item visibility checks
@@ -23,7 +14,7 @@ export function* changeDashboardTimezoneOverrideHandler(ctx, cmd) {
         throw invalidArgumentsProvided(ctx, cmd, "Cannot change the timezone override: the dashboard timezone feature is disabled.");
     }
     const timezoneConfig = yield select(selectDashboardTimezoneConfig);
-    if (timezoneConfig?.allowUserOverrideInViewMode !== true) {
+    if (!cmd.payload.bypassUserOverrideCheck && timezoneConfig?.allowUserOverrideInViewMode !== true) {
         throw invalidArgumentsProvided(ctx, cmd, "Cannot change the timezone override: the dashboard's timezone configuration does not allow user overrides in view mode.");
     }
     // the model layer is the single resolution point of the browser-detected sentinel for the

package/esm/model/commands/timezone.d.ts

@@ -11,6 +11,12 @@ export interface IChangeDashboardTimezoneOverridePayload {
      * the dashboard/workspace configuration applies again.
      */
     readonly timezoneId: string | undefined;
+    /**
+     * Skips the check that the dashboard's timezone configuration allows user overrides in view
+     * mode, for restoring a timezone the platform already committed to (an export render, an
+     * automation deep link). The dashboard timezone feature flag is still honored.
+     */
+    readonly bypassUserOverrideCheck?: boolean;
 }
 /**
  * @alpha
@@ -29,14 +35,16 @@ export interface IChangeDashboardTimezoneOverride extends IDashboardCommand {
  *
  * The command is rejected when the ad-hoc override is not allowed: the dashboard timezone
  * feature is disabled or the dashboard's timezone configuration does not allow user overrides
- * in view mode.
+ * in view mode — the latter bypassable via `bypassUserOverrideCheck`.
  *
  * @param timezoneId - concrete IANA timezone id, the BROWSER_DETECTED sentinel (resolved to the
  *  viewer's browser timezone by the handler), or undefined to clear the override
  * @param correlationId - specify correlation id to use for this command. this will be included in all
  *  events that will be emitted during the command processing
+ * @param bypassUserOverrideCheck - see
+ *  {@link IChangeDashboardTimezoneOverridePayload.bypassUserOverrideCheck}
  *
  * @alpha
  */
-export declare function changeDashboardTimezoneOverride(timezoneId: string | undefined, correlationId?: string): IChangeDashboardTimezoneOverride;
+export declare function changeDashboardTimezoneOverride(timezoneId: string | undefined, correlationId?: string, bypassUserOverrideCheck?: boolean): IChangeDashboardTimezoneOverride;
 //# sourceMappingURL=timezone.d.ts.map

package/esm/model/commands/timezone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timezone.d.ts","sourceRoot":"","sources":["../../../src/model/commands/timezone.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;GAIG;AACH,MAAM,WAAW,uCAAuC;IACpD;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,gCAAiC,SAAQ,iBAAiB;IACvE,QAAQ,CAAC,IAAI,EAAE,uCAAuC,CAAC;IACvD,QAAQ,CAAC,OAAO,EAAE,uCAAuC,CAAC;CAC7D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,+BAA+B,CAC3C,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,aAAa,CAAC,EAAE,MAAM,GACvB,gCAAgC,CAQlC"}
+{"version":3,"file":"timezone.d.ts","sourceRoot":"","sources":["../../../src/model/commands/timezone.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;GAIG;AACH,MAAM,WAAW,uCAAuC;IACpD;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAExC;;;;OAIG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC;CAC9C;AAED;;GAEG;AACH,MAAM,WAAW,gCAAiC,SAAQ,iBAAiB;IACvE,QAAQ,CAAC,IAAI,EAAE,uCAAuC,CAAC;IACvD,QAAQ,CAAC,OAAO,EAAE,uCAAuC,CAAC;CAC7D;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,+BAA+B,CAC3C,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,aAAa,CAAC,EAAE,MAAM,EACtB,uBAAuB,CAAC,EAAE,OAAO,GAClC,gCAAgC,CASlC"}

package/esm/model/commands/timezone.js

@@ -9,21 +9,24 @@
  *
  * The command is rejected when the ad-hoc override is not allowed: the dashboard timezone
  * feature is disabled or the dashboard's timezone configuration does not allow user overrides
- * in view mode.
+ * in view mode — the latter bypassable via `bypassUserOverrideCheck`.
  *
  * @param timezoneId - concrete IANA timezone id, the BROWSER_DETECTED sentinel (resolved to the
  *  viewer's browser timezone by the handler), or undefined to clear the override
  * @param correlationId - specify correlation id to use for this command. this will be included in all
  *  events that will be emitted during the command processing
+ * @param bypassUserOverrideCheck - see
+ *  {@link IChangeDashboardTimezoneOverridePayload.bypassUserOverrideCheck}
  *
  * @alpha
  */
-export function changeDashboardTimezoneOverride(timezoneId, correlationId) {
+export function changeDashboardTimezoneOverride(timezoneId, correlationId, bypassUserOverrideCheck) {
     return {
         type: "GDC.DASH/CMD.CHANGE_TIMEZONE_OVERRIDE",
         correlationId,
         payload: {
             timezoneId,
+            ...(bypassUserOverrideCheck ? { bypassUserOverrideCheck } : {}),
         },
     };
 }

package/esm/model/fixtures/CatalogAvailability.fixtures.d.ts

@@ -0,0 +1,14 @@
+import { type ICatalogDateDataset } from "@gooddata/sdk-model";
+/**
+ * given all available datasets, this availability mock will pick 2 by name and associate relevance so that second one has more relevance
+ *
+ * Timeline date has greater relevance; see TimelineDateDatasetRef
+ * Activity date has lower relevance; see ActivityDateDatasetRef
+ */
+export declare const MockAvailabilityWithDifferentRelevance: (datasets: ICatalogDateDataset[]) => ICatalogDateDataset[];
+/**
+ * given all available datasets, this mock will pick 2 by name and ensure they have same relevance
+ */
+export declare const MockAvailabilityWithSameRelevance: (datasets: ICatalogDateDataset[]) => ICatalogDateDataset[];
+export declare const ActivityDateDatasetRef: import("@gooddata/sdk-model").IdentifierRef;
+//# sourceMappingURL=CatalogAvailability.fixtures.d.ts.map

package/esm/model/fixtures/CatalogAvailability.fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CatalogAvailability.fixtures.d.ts","sourceRoot":"","sources":["../../../src/model/fixtures/CatalogAvailability.fixtures.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,mBAAmB,EAAS,MAAM,qBAAqB,CAAC;AAuBtE;;;;;GAKG;AACH,eAAO,MAAM,sCAAsC,4DAclD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iCAAiC,4DAY7C,CAAC;AAEF,eAAO,MAAM,sBAAsB,6CAA4C,CAAC"}