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

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"}

package/esm/model/fixtures/CatalogAvailability.fixtures.js

@@ -0,0 +1,57 @@
+// (C) 2021-2026 GoodData Corporation
+import { invariant } from "ts-invariant";
+import { idRef } from "@gooddata/sdk-model";
+/*
+ * The catalog availability mocks for date dataset queries.
+ *
+ * Normally the recorded backend from mockingbird returns all data sets available in the catalog as available. Mockingbird
+ * allows to customize filtering functions to 'simulate' the availability.
+ *
+ * Here are a couple of functions that you can use.
+ *
+ * To set up DashboardTester you can do something like:
+ *
+ *             const Tester = DashboardTester.forRecording(
+ *              ComplexDashboardIdentifier,
+ *              {},
+ *              {
+ *                  catalogAvailability: {
+ *                      availableDateDatasets: MockAvailabilityWithDifferentRelevance,
+ *                  },
+ *              },
+ *          );
+ */
+/**
+ * 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 const MockAvailabilityWithDifferentRelevance = (datasets) => {
+    const available = datasets
+        .filter((d) => ["Activity", "Timeline"].includes(d.dataSet.title))
+        .map((d) => {
+        return {
+            ...d,
+            relevance: d.dataSet.title === "Timeline" ? 1 : 0,
+        };
+    });
+    invariant(available.length === 2, "unexpected mock");
+    return available;
+};
+/**
+ * given all available datasets, this mock will pick 2 by name and ensure they have same relevance
+ */
+export const MockAvailabilityWithSameRelevance = (datasets) => {
+    const available = datasets
+        .filter((d) => ["Activity", "Timeline"].includes(d.dataSet.title))
+        .map((d) => {
+        return {
+            ...d,
+            relevance: 1,
+        };
+    });
+    invariant(available.length === 2, "unexpected mock");
+    return available;
+};
+export const ActivityDateDatasetRef = idRef("dt_activity_timestamp", "dataSet");

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

@@ -0,0 +1,56 @@
+import { type IDashboardWithReferences } from "@gooddata/sdk-backend-spi";
+import { type IDashboardAttributeFilter, type IDashboardDateFilter, type IFilterContext, type IInsightWidget, type IKpiWidget, type IListedDashboard } from "@gooddata/sdk-model";
+/**
+ * A more complex dashboard that has 3 sections (rows).
+ *
+ * Two attribute filters: Region & Product
+ * First row: 6 KPIs, first three without date filtering, second three with full filtering
+ * Second row: two tables; same tables, each with 3 measures. first without any filtering whatsoever but with all drills; second with date filter and no attribute filtering, no drills
+ * Third row: single heatmap with all filters applied
+ */
+export declare const ComplexDashboardIdentifier = "e6473e57-1914-46ec-9cb9-5611f1298100";
+export declare const ComplexDashboardWithReferences: IDashboardWithReferences;
+export declare const ComplexDashboardFilterContext: IFilterContext;
+/**
+ * Contains breakdown of the complex dashboard's filters context. There is date filter and
+ * two attribute filters. For each attribute filter the entry contains both the full filter
+ * definition and then uriRef and idRef of the display form used in the attribute filter.
+ */
+export declare const ComplexDashboardFilters: {
+    Date: IDashboardDateFilter;
+    FirstAttribute: {
+        filter: IDashboardAttributeFilter;
+        idRef: import("@gooddata/sdk-model").IdentifierRef;
+        sampleElementValue: string;
+    };
+    SecondAttribute: {
+        filter: IDashboardAttributeFilter;
+        idRef: import("@gooddata/sdk-model").IdentifierRef;
+    };
+};
+export declare const ComplexDashboardLayout: import("@gooddata/sdk-model").IDashboardLayout<import("@gooddata/sdk-model").IDashboardWidget>;
+export declare const ComplexDashboardWidgets: {
+    FirstSection: {
+        /**
+         * KPI with date filter disabled
+         */
+        FirstKpi: IKpiWidget;
+        /**
+         * KPI with all filters disabled
+         */
+        ThirdKpi: IKpiWidget;
+        /**
+         * KPI with all filters enabled
+         */
+        LastKpi: IKpiWidget;
+    };
+    SecondSection: {
+        FirstTable: IInsightWidget;
+        SecondTable: IInsightWidget;
+    };
+    ThirdSection: {
+        Heatmap: IInsightWidget;
+    };
+};
+export declare const ComplexDashboardListed: IListedDashboard;
+//# sourceMappingURL=ComplexDashboard.fixtures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ComplexDashboard.fixtures.d.ts","sourceRoot":"","sources":["../../../src/model/fixtures/ComplexDashboard.fixtures.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,EACH,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,gBAAgB,EAExB,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,yCAAyC,CAAC;AACjF,eAAO,MAAM,8BAA8B,0BAEV,CAAC;AAClC,eAAO,MAAM,6BAA6B,gBACL,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;CAWnC,CAAC;AAEF,eAAO,MAAM,sBAAsB,gGAAmD,CAAC;AAEvF,eAAO,MAAM,uBAAuB;;QAE5B;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;;;;;;;;;CAaV,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,gBAWpC,CAAC"}

package/esm/model/fixtures/ComplexDashboard.fixtures.js

@@ -0,0 +1,71 @@
+// (C) 2021-2026 GoodData Corporation
+import { ReferenceRecordings } from "@gooddata/reference-workspace";
+import { idRef, } from "@gooddata/sdk-model";
+/**
+ * A more complex dashboard that has 3 sections (rows).
+ *
+ * Two attribute filters: Region & Product
+ * First row: 6 KPIs, first three without date filtering, second three with full filtering
+ * Second row: two tables; same tables, each with 3 measures. first without any filtering whatsoever but with all drills; second with date filter and no attribute filtering, no drills
+ * Third row: single heatmap with all filters applied
+ */
+export const ComplexDashboardIdentifier = "e6473e57-1914-46ec-9cb9-5611f1298100";
+export const ComplexDashboardWithReferences = ReferenceRecordings.Recordings.metadata?.dashboards?.["dash_e6473e57_1914_46ec_9cb9_5611f1298100"].obj;
+export const ComplexDashboardFilterContext = ComplexDashboardWithReferences.dashboard
+    .filterContext;
+/**
+ * Contains breakdown of the complex dashboard's filters context. There is date filter and
+ * two attribute filters. For each attribute filter the entry contains both the full filter
+ * definition and then uriRef and idRef of the display form used in the attribute filter.
+ */
+export const ComplexDashboardFilters = {
+    Date: ComplexDashboardFilterContext.filters[0],
+    FirstAttribute: {
+        filter: ComplexDashboardFilterContext.filters[1],
+        idRef: idRef("f_owner.region_id"),
+        sampleElementValue: "East Coast",
+    },
+    SecondAttribute: {
+        filter: ComplexDashboardFilterContext.filters[2],
+        idRef: idRef("attr.f_product.product"),
+    },
+};
+export const ComplexDashboardLayout = ComplexDashboardWithReferences.dashboard.layout;
+export const ComplexDashboardWidgets = {
+    FirstSection: {
+        /**
+         * KPI with date filter disabled
+         */
+        FirstKpi: ComplexDashboardWithReferences.dashboard.layout.sections[0].items[0].widget,
+        /**
+         * KPI with all filters disabled
+         */
+        ThirdKpi: ComplexDashboardWithReferences.dashboard.layout.sections[0].items[2].widget,
+        /**
+         * KPI with all filters enabled
+         */
+        LastKpi: ComplexDashboardWithReferences.dashboard.layout.sections[0].items[5].widget,
+    },
+    SecondSection: {
+        FirstTable: ComplexDashboardWithReferences.dashboard.layout.sections[1].items[0]
+            .widget,
+        SecondTable: ComplexDashboardWithReferences.dashboard.layout.sections[1].items[1]
+            .widget,
+    },
+    ThirdSection: {
+        Heatmap: ComplexDashboardWithReferences.dashboard.layout.sections[2].items[0]
+            .widget,
+    },
+};
+export const ComplexDashboardListed = {
+    ref: ComplexDashboardWithReferences.dashboard.ref,
+    identifier: ComplexDashboardWithReferences.dashboard.identifier,
+    uri: ComplexDashboardWithReferences.dashboard.uri,
+    title: ComplexDashboardWithReferences.dashboard.title,
+    description: ComplexDashboardWithReferences.dashboard.description,
+    updated: ComplexDashboardWithReferences.dashboard.updated,
+    created: ComplexDashboardWithReferences.dashboard.created,
+    tags: ComplexDashboardWithReferences.dashboard.tags,
+    shareStatus: ComplexDashboardWithReferences.dashboard.shareStatus,
+    availability: "full",
+};

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

@@ -0,0 +1,10 @@
+import { type IDashboardWithReferences } from "@gooddata/sdk-backend-spi";
+export declare const TestCorrelation = "testCorrelationId";
+export declare const TestStash = "testStash";
+export declare const BeforeTestCorrelation = "beforeTestId";
+/**
+ * Empty dashboard. No filter context, empty layout.
+ */
+export declare const EmptyDashboardIdentifier = "emptyDashboard";
+export declare const EmptyDashboardWithReferences: IDashboardWithReferences;
+//# sourceMappingURL=Dashboard.fixtures.d.ts.map