@gooddata/sdk-ui-analytical-designer 11.65.0-alpha.8 → 11.65.0

package/esm/models/metadata.js

@@ -46,9 +46,9 @@ function numberOrUndefined(value) {
 /** The granularity of a stored All time date filter, which the sdk-model types as a literal. */
 const ALL_TIME_GRANULARITY = "ALL_TIME_GRANULARITY";
 /**
- * The `emptyValueHandling` a metric date filter stores for the empty date values mode. Like the filter
- * bar's `""` attribute filter, only exclude and only are stored: include is the backend default for All
- * time and the picker does not offer it with a period.
+ * The `emptyValueHandling` a date filter stores for the empty date values mode. Like the legacy `""`
+ * attribute filter, only exclude and only are stored: include is the backend default for All time and
+ * the picker does not offer it with a period.
  */
 export function emptyValueHandlingToMd(emptyDateValuesFilter) {
     return emptyDateValuesFilter === "exclude" || emptyDateValuesFilter === "only"
@@ -165,14 +165,29 @@ function measureFilterToMd(filter) {
         },
     };
 }
-function dateFilterToMd({ filterConfig, dateDatasetRef, }) {
+function dateFilterToMd({ filterConfig, dateDatasetRef, emptyDateValuesFilter }, useEmptyValueHandling) {
     const [from, to] = filterConfig?.interval || [undefined, undefined];
+    const emptyValueHandlingProp = useEmptyValueHandling ? emptyValueHandlingToMd(emptyDateValuesFilter) : {};
     if (filterConfig?.type === "absolute") {
         return {
             absoluteDateFilter: {
                 dataSet: dateDatasetRef,
                 from: from,
                 to: to,
+                ...emptyValueHandlingProp,
+            },
+        };
+    }
+    // All time is stored without bounds, a no-op the execution drops. To carry the empty date values mode
+    // it has to be the real All time filter, the one the execution sends.
+    if ((from === undefined || to === undefined) && !isEmpty(emptyValueHandlingProp)) {
+        return {
+            relativeDateFilter: {
+                dataSet: dateDatasetRef,
+                granularity: ALL_TIME_GRANULARITY,
+                from: 0,
+                to: 0,
+                ...emptyValueHandlingProp,
             },
         };
     }
@@ -184,6 +199,7 @@ function dateFilterToMd({ filterConfig, dateDatasetRef, }) {
             from: numberOrUndefined(from),
             to: numberOrUndefined(to),
             ...(filterConfig?.boundedFilter ? { boundedFilter: filterConfig.boundedFilter } : {}),
+            ...emptyValueHandlingProp,
         }),
     };
 }
@@ -293,9 +309,9 @@ function rankingFilterToMd(filter) {
         },
     };
 }
-function filterToMd(filter, attributeFilterConfigs) {
+function filterToMd(filter, attributeFilterConfigs, useEmptyValueHandling) {
     if (FilterBar.isDateFilter(filter)) {
-        return dateFilterToMd(filter);
+        return dateFilterToMd(filter, useEmptyValueHandling);
     }
     else if (FilterBar.isAttributeFilter(filter)) {
         return attributeFilterToMd(filter, attributeFilterConfigs);
@@ -519,8 +535,10 @@ function findDateAttributeDfRef(dateDatasetRef, dateDatasets, granularity) {
     return dateAttribute?.dfRef;
 }
 /**
- * Creates an attribute filter for empty date values based on the emptyDateValuesFilter mode.
- * The filter uses the same granularity as the date filter to ensure consistency.
+ * LEGACY representation of the empty date values mode, written while `enableImprovedMetricDateFilter` is
+ * off: an attribute filter on the date attribute of the date filter's granularity with the single empty
+ * string element. With the flag on the mode is written as the date filter's `emptyValueHandling`
+ * instead; both representations are always read (see transformVisualizationFilters).
  * Returns undefined if no filter should be created (e.g., for "include" mode).
  */
 function createEmptyDateValuesAttributeFilter(dateFilter, dateDatasets) {
@@ -554,12 +572,16 @@ function createEmptyDateValuesAttributeFilter(dateFilter, dateDatasets) {
     }
     return undefined;
 }
-export function filtersToMetadata(filters, attributeFilterConfigs = {}, dateDatasets) {
+/**
+ * @param useEmptyValueHandling - whether the empty date values mode is written as the date filter's
+ *  `emptyValueHandling` (the `enableImprovedMetricDateFilter` flag) or as the legacy `""` attribute filter,
+ *  which needs `dateDatasets` to find the date attribute.
+ */
+export function filtersToMetadata(filters, attributeFilterConfigs = {}, dateDatasets, useEmptyValueHandling = false) {
     const result = [];
     filters.forEach((filter) => {
-        result.push(filterToMd(filter, attributeFilterConfigs));
-        // Add empty date values attribute filter if applicable
-        if (FilterBar.isDateFilter(filter)) {
+        result.push(filterToMd(filter, attributeFilterConfigs, useEmptyValueHandling));
+        if (!useEmptyValueHandling && FilterBar.isDateFilter(filter)) {
             const emptyValuesFilter = createEmptyDateValuesAttributeFilter(filter, dateDatasets);
             if (emptyValuesFilter) {
                 result.push(emptyValuesFilter);
@@ -807,7 +829,8 @@ function transformVisualizationFilter(filter, data, overTimeComparisonType) {
 function transformToDateFilterConfig(visualizationFilter) {
     if (isVisualizationObjectRelativeDateFilter(visualizationFilter)) {
         const { granularity, from, to, boundedFilter } = visualizationFilter.relativeDateFilter;
-        if (from === undefined || to === undefined) {
+        // All time: stored without bounds, or as the real All time filter when it carries a mode
+        if (granularity === ALL_TIME_GRANULARITY || from === undefined || to === undefined) {
             return undefined;
         }
         const selectedPresetItem = PRESETS.find((presetItem) => presetItem.granularity === granularity &&
@@ -831,9 +854,7 @@ function transformToDateFilterConfig(visualizationFilter) {
     throw new Error("Unsupported visualization date filter type");
 }
 function transformVisualizationDateFilter(visualizationFilter, overTimeComparisonType, ignoreOverTimeComparisonType) {
-    let datasetRef = isVisualizationObjectRelativeDateFilter(visualizationFilter)
-        ? visualizationFilter.relativeDateFilter.dataSet
-        : visualizationFilter.absoluteDateFilter.dataSet;
+    let datasetRef = getDateFilterDataSet(visualizationFilter);
     /**
      * convertor from SDK returns ref without type
      */
@@ -841,6 +862,7 @@ function transformVisualizationDateFilter(visualizationFilter, overTimeCompariso
         ...datasetRef,
         type: "dataSet",
     };
+    const emptyDateValuesFilter = getDateFilterEmptyValueHandling(visualizationFilter);
     return {
         type: "date",
         localIdentifier: generateBucketItemIdentifier(),
@@ -850,8 +872,15 @@ function transformVisualizationDateFilter(visualizationFilter, overTimeCompariso
             : { overTimeComparisonType }),
         filterConfig: transformToDateFilterConfig(visualizationFilter),
         dateDatasetRef: datasetRef,
+        ...(emptyDateValuesFilter ? { emptyDateValuesFilter } : {}),
     };
 }
+/** The date dataset a stored date filter filters on. */
+function getDateFilterDataSet(visualizationFilter) {
+    return isVisualizationObjectRelativeDateFilter(visualizationFilter)
+        ? visualizationFilter.relativeDateFilter.dataSet
+        : visualizationFilter.absoluteDateFilter.dataSet;
+}
 /** The empty date values mode a stored date filter carries as `emptyValueHandling`, if any. */
 function getDateFilterEmptyValueHandling(visualizationFilter) {
     return isVisualizationObjectRelativeDateFilter(visualizationFilter)
@@ -1049,23 +1078,71 @@ function detectEmptyDateValuesAttributeFilter(attributeFilter, dateDatasets) {
     }
     return undefined;
 }
-function transformVisualizationFilters(metadataObject, overTimeComparisonType, additionalData) {
-    const visualizationFilters = metadataObject.filters || [];
-    const dateDatasets = additionalData?.dateDatasets || undefined;
-    // First pass: identify empty date values attribute filters
+/**
+ * Finds the LEGACY empty date values attribute filters (the single-"" element filters on a date
+ * attribute), kept readable so insights saved before the mode moved to `emptyValueHandling` open.
+ */
+function collectLegacyEmptyDateValuesFilters(visualizationFilters, dateDatasets) {
+    // keyed by the date dataset ref string
     const emptyDateValuesFilters = {};
     const emptyDateValuesFilterIndices = new globalThis.Set();
     visualizationFilters.forEach((filter, index) => {
         if (isVisualizationObjectAttributeFilter(filter)) {
             const detected = detectEmptyDateValuesAttributeFilter(filter, dateDatasets);
             if (detected) {
-                // Key by date dataset ref string for lookup
-                const key = objRefToString(detected.dateDatasetRef);
-                emptyDateValuesFilters[key] = detected;
+                emptyDateValuesFilters[objRefToString(detected.dateDatasetRef)] = detected;
                 emptyDateValuesFilterIndices.add(index);
             }
         }
     });
+    return { emptyDateValuesFilters, emptyDateValuesFilterIndices };
+}
+/**
+ * Rewrites the stored filters so that every representation of the same empty date values mode compares
+ * equal: the legacy `""` attribute filter is folded into its date filter's `emptyValueHandling` (the way
+ * the reader does), All time with a mode becomes the ALL_TIME_GRANULARITY filter whether it is stored with
+ * bounds or without, and the `include` default is dropped as the writer drops it. Only for comparing
+ * stored content, the result is never saved.
+ */
+export function normalizeEmptyDateValuesFilters(visualizationFilters, dateDatasets) {
+    const { emptyDateValuesFilters, emptyDateValuesFilterIndices } = collectLegacyEmptyDateValuesFilters(visualizationFilters, dateDatasets);
+    return visualizationFilters
+        .filter((_filter, index) => !emptyDateValuesFilterIndices.has(index))
+        .map((filter) => {
+        if (!isVisualizationObjectDateFilter(filter)) {
+            return filter;
+        }
+        const dataSet = getDateFilterDataSet(filter);
+        const storedMode = getDateFilterEmptyValueHandling(filter);
+        const mode = emptyValueHandlingToMd(storedMode ?? emptyDateValuesFilters[objRefToString(dataSet)]?.mode);
+        if (isVisualizationObjectAbsoluteDateFilter(filter)) {
+            return {
+                absoluteDateFilter: { ...omit(filter.absoluteDateFilter, "emptyValueHandling"), ...mode },
+            };
+        }
+        const { granularity, from, to } = filter.relativeDateFilter;
+        const isAllTime = granularity === ALL_TIME_GRANULARITY || from === undefined || to === undefined;
+        if (isAllTime && !isEmpty(mode)) {
+            return {
+                relativeDateFilter: {
+                    dataSet,
+                    granularity: ALL_TIME_GRANULARITY,
+                    from: 0,
+                    to: 0,
+                    ...mode,
+                },
+            };
+        }
+        return {
+            relativeDateFilter: { ...omit(filter.relativeDateFilter, "emptyValueHandling"), ...mode },
+        };
+    });
+}
+function transformVisualizationFilters(metadataObject, overTimeComparisonType, additionalData) {
+    const visualizationFilters = metadataObject.filters || [];
+    const dateDatasets = additionalData?.dateDatasets || undefined;
+    // First pass: identify the legacy empty date values attribute filters
+    const { emptyDateValuesFilters, emptyDateValuesFilterIndices } = collectLegacyEmptyDateValuesFilters(visualizationFilters, dateDatasets);
     // Second pass: transform filters, setting emptyDateValuesFilter on date filters
     let firstDateFilterTransformed = false;
     const result = [];
@@ -1081,11 +1158,12 @@ function transformVisualizationFilters(metadataObject, overTimeComparisonType, a
         }
         else if (isVisualizationObjectDateFilter(visualizationFilter)) {
             let df = transformVisualizationDateFilter(visualizationFilter, overTimeComparisonType, firstDateFilterTransformed);
-            // Check if there's a matching empty date values filter
+            // the legacy "" attribute filter sets the mode unless the date filter carries it itself; either
+            // way the attribute filter is dropped, so re-saving migrates the insight to the field
             const dateDatasetRef = df.dateDatasetRef;
             const key = objRefToString(dateDatasetRef);
             const emptyValuesInfo = emptyDateValuesFilters[key];
-            if (emptyValuesInfo) {
+            if (emptyValuesInfo && !df.emptyDateValuesFilter) {
                 df = { ...df, emptyDateValuesFilter: emptyValuesInfo.mode };
             }
             firstDateFilterTransformed = true;

package/esm/postMessageApi/outgoing/drill_events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"drill_events.d.ts","sourceRoot":"","sources":["../../../src/postMessageApi/outgoing/drill_events.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAMpD,wBAAgB,cAAc,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI,CAG5D"}
+{"version":3,"file":"drill_events.d.ts","sourceRoot":"","sources":["../../../src/postMessageApi/outgoing/drill_events.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAOpD,wBAAgB,cAAc,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI,CAS5D"}

package/esm/postMessageApi/outgoing/drill_events.js

@@ -1,8 +1,15 @@
 // (C) 2020-2026 GoodData Corporation
 import { GdcAdEventType } from "@gooddata/sdk-embedding";
+import { getHostAdapter } from "../../embedding/hostBridge.js";
 import { transformDrillEventToLegacy } from "../../utils/drilling/index.js";
-import { adPostEvent } from "./post_event_helper.js";
+import { postHostEvent, postWindowEvent } from "./post_event_helper.js";
 export function drillPerformed(drillEvent) {
-    const transformed = transformDrillEventToLegacy(drillEvent);
-    adPostEvent(GdcAdEventType.Drill, transformed);
+    // A host component receives the drill event of @gooddata/sdk-ui; the postMessage contract carries
+    // the legacy shape.
+    const hostAdapter = getHostAdapter();
+    if (hostAdapter) {
+        postHostEvent(hostAdapter, GdcAdEventType.Drill, drillEvent);
+        return;
+    }
+    postWindowEvent(GdcAdEventType.Drill, transformDrillEventToLegacy(drillEvent));
 }

package/esm/postMessageApi/outgoing/open_insight_events.d.ts

@@ -6,7 +6,7 @@ export declare const insightNotFoundError: ICommandFailedBody;
  */
 /**
  * What the InsightOpened event carries. Deliberately NOT sdk-embedding's AdInsightOpenedBody:
- * its `definition` differs from what AD has always posted (ONE-4679).
+ * its `definition` differs from what AD has always posted.
  */
 export interface IAdInsightOpenedBody {
     availableCommands: GdcAdCommandType[];

package/esm/postMessageApi/outgoing/post_event_helper.d.ts

@@ -1,2 +1,12 @@
-export declare const adPostEvent: (name: string, data: unknown, contextId?: string) => void;
+import { type AnalyticalDesignerEventType, type IAnalyticalDesignerEventDataMap } from "../../embedding/analyticalDesignerTypes.js";
+import { type IAdHostAdapter } from "../../embedding/hostBridge.js";
+/** Delivers an event to the host that renders AD as a React component. */
+export declare function postHostEvent<T extends AnalyticalDesignerEventType>(hostAdapter: IAdHostAdapter, type: T, data: IAnalyticalDesignerEventDataMap[T], contextId?: string): void;
+/** Posts an event as a window message; data is the @gooddata/sdk-embedding contract payload. */
+export declare function postWindowEvent(type: AnalyticalDesignerEventType, data: unknown, contextId?: string): void;
+/**
+ * Emits an event to the host: to the host component when one is installed, else as a window message.
+ * Drill is emitted by drillPerformed: the two transports carry different payloads for it.
+ */
+export declare function adPostEvent<T extends Exclude<AnalyticalDesignerEventType, "drill">>(type: T, data: IAnalyticalDesignerEventDataMap[T], contextId?: string): void;
 //# sourceMappingURL=post_event_helper.d.ts.map

package/esm/postMessageApi/outgoing/post_event_helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"post_event_helper.d.ts","sourceRoot":"","sources":["../../../src/postMessageApi/outgoing/post_event_helper.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,WAAW,SAAU,MAAM,QAAQ,OAAO,cAAc,MAAM,KAAG,IAoB7E,CAAC"}
+{"version":3,"file":"post_event_helper.d.ts","sourceRoot":"","sources":["../../../src/postMessageApi/outgoing/post_event_helper.ts"],"names":[],"mappings":"AAKA,OAAO,EAEH,KAAK,2BAA2B,EAChC,KAAK,+BAA+B,EACvC,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,+BAA+B,CAAC;AAOpF,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,CAAC,SAAS,2BAA2B,EAC/D,WAAW,EAAE,cAAc,EAC3B,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,+BAA+B,CAAC,CAAC,CAAC,EACxC,SAAS,CAAC,EAAE,MAAM,GACnB,IAAI,CAKN;AAED,gGAAgG;AAChG,wBAAgB,eAAe,CAAC,IAAI,EAAE,2BAA2B,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAO1G;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,OAAO,CAAC,2BAA2B,EAAE,OAAO,CAAC,EAC/E,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,+BAA+B,CAAC,CAAC,CAAC,EACxC,SAAS,CAAC,EAAE,MAAM,GACnB,IAAI,CAON"}

package/esm/postMessageApi/outgoing/post_event_helper.js

@@ -3,20 +3,29 @@ import { GdcProductName } from "@gooddata/sdk-embedding";
 import { messagingUtils } from "@gooddata/sdk-embedding/internal";
 import { getHostAdapter } from "../../embedding/hostBridge.js";
 import { DEFAULT_POST_MESSAGE_CONTEXT_ID } from "../actions/post_message_action_helper.js";
-// data is the raw @gooddata/sdk-embedding contract payload — an opaque passthrough here
-export const adPostEvent = (name, data, contextId) => {
-    const resetDefaultContextId = (contextId) => {
-        return contextId && contextId === DEFAULT_POST_MESSAGE_CONTEXT_ID ? undefined : contextId;
-    };
+const resetDefaultContextId = (contextId) => {
+    return contextId && contextId === DEFAULT_POST_MESSAGE_CONTEXT_ID ? undefined : contextId;
+};
+/** Delivers an event to the host that renders AD as a React component. */
+export function postHostEvent(hostAdapter, type, data, contextId) {
+    const event = { type, data, contextId: resetDefaultContextId(contextId) };
+    // every AnalyticalDesignerEvent<T> is an AnalyticalDesignerEvent; TypeScript cannot widen a
+    // generic mapped union (TS#30581)
+    hostAdapter.onEvent(event);
+}
+/** Posts an event as a window message; data is the @gooddata/sdk-embedding contract payload. */
+export function postWindowEvent(type, data, contextId) {
+    messagingUtils.postEvent(GdcProductName.ANALYTICAL_DESIGNER, type, data, resetDefaultContextId(contextId));
+}
+/**
+ * Emits an event to the host: to the host component when one is installed, else as a window message.
+ * Drill is emitted by drillPerformed: the two transports carry different payloads for it.
+ */
+export function adPostEvent(type, data, contextId) {
     const hostAdapter = getHostAdapter();
     if (hostAdapter) {
-        hostAdapter.onEvent({
-            product: GdcProductName.ANALYTICAL_DESIGNER,
-            name,
-            data,
-            contextId: resetDefaultContextId(contextId),
-        });
+        postHostEvent(hostAdapter, type, data, contextId);
         return;
     }
-    messagingUtils.postEvent(GdcProductName.ANALYTICAL_DESIGNER, name, data, resetDefaultContextId(contextId));
-};
+    postWindowEvent(type, data, contextId);
+}

package/esm/postMessageApi/sagas/api_token_received_saga.d.ts

@@ -1,3 +1,6 @@
 import { type AdSetApiTokenCommandData } from "@gooddata/sdk-embedding";
-export declare function handleReceivedApiToken(setApiTokenContext: AdSetApiTokenCommandData): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").SelectEffect, void, string | undefined>;
+export declare function handleReceivedApiToken(setApiTokenContext: AdSetApiTokenCommandData): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").PutEffect<{
+    payload: undefined;
+    type: import("../../sagas/application_context/application_context_actions.js").ApplicationContextActionsTypeKeys;
+}> | import("redux-saga/effects").SelectEffect, void, string | undefined>;
 //# sourceMappingURL=api_token_received_saga.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"api_token_received_saga.d.ts","sourceRoot":"","sources":["../../../src/postMessageApi/sagas/api_token_received_saga.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAuBxE,wBAAiB,sBAAsB,CAAC,kBAAkB,EAAE,wBAAwB,kIAoCnF"}
+{"version":3,"file":"api_token_received_saga.d.ts","sourceRoot":"","sources":["../../../src/postMessageApi/sagas/api_token_received_saga.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAexE,wBAAiB,sBAAsB,CAAC,kBAAkB,EAAE,wBAAwB;;;0EAuCnF"}

package/esm/postMessageApi/sagas/api_token_received_saga.js

@@ -1,10 +1,9 @@
 // (C) 2020-2026 GoodData Corporation
 import { call, put, select } from "redux-saga/effects";
-import { isHostBackendAdopted, isValidApiTokenType, reinitializeBackend, setApiTokenHandler, setJwtHandler, } from "../../backend.js";
+import { isValidApiTokenType, setApiTokenHandler, setJwtHandler } from "../../backend.js";
 import { backendInitialized } from "../../sagas/application_context/application_context_actions.js";
 import { storeApiToken } from "../../store/application_context/app_context_actions.js";
 import { selectApiToken, selectApiTokenType } from "../../store/application_context/app_context_selector.js";
-import { getExternalProviderIdParam } from "../../utils/location.js";
 import { postInvalidCommandArgument } from "../outgoing/invalid_command_events.js";
 import { getPostMessageContextIdFromCommandData } from "./post_message_saga_helper.js";
 const DEFAULT_TOKEN_TYPE = "gooddata";
@@ -31,29 +30,20 @@ export function* handleReceivedApiToken(setApiTokenContext) {
         return;
     }
     const previousToken = yield select(selectApiToken);
-    if (previousToken === undefined) {
-        yield call(initializeBackendForTheFirstTime, apiToken);
-    }
-    else if (type === "gooddata") {
+    // The first token and a renewal take the same path: the host's setter decides whether it renews
+    // its provider in place or switches the backend to the token (a first token over cookie auth).
+    if (type === "gooddata") {
         yield call(updateApiTokenValue, apiToken);
     }
     else if (type === "jwt") {
         yield call(updateJwtValue, apiToken, contextId);
     }
-}
-function* initializeBackendForTheFirstTime(apiToken) {
-    // A host-adopted backend must never be replaced from here — the host's provider already
-    // authenticates; only record the token (components like the metric editor read it).
-    if (!isHostBackendAdopted) {
-        const externalProviderId = yield call(getExternalProviderIdParam);
-        yield call(reinitializeBackend, apiToken, externalProviderId);
+    if (previousToken === undefined) {
+        yield put(backendInitialized());
     }
-    yield put(storeApiToken(apiToken.apiToken, apiToken.apiTokenType));
-    yield put(backendInitialized());
 }
 function* updateApiTokenValue({ apiToken: token, apiTokenType }) {
-    // No handler means there is no AD-side auth provider (host-adopted backend) — the host has
-    // already renewed its provider in place; only keep the stored token in sync.
+    // No handler means the host renews its auth provider itself; only keep the stored token in sync.
     if (setApiTokenHandler) {
         setApiTokenHandler(token);
         // oxlint-disable-next-line eslint-js/no-console
@@ -64,8 +54,7 @@ function* updateApiTokenValue({ apiToken: token, apiTokenType }) {
 function* updateJwtValue(apiToken, contextId) {
     const { apiToken: token, apiTokenType, secondsBeforeTokenExpirationToCallReminder } = apiToken;
     try {
-        // No handler means there is no AD-side auth provider (host-adopted backend) — the host has
-        // already renewed its provider in place; only keep the stored token in sync.
+        // No handler means the host renews its auth provider itself; only keep the stored token in sync.
         if (setJwtHandler) {
             // set token to backend instance via callback we received from the expiration reminder
             setJwtHandler(token, secondsBeforeTokenExpirationToCallReminder);

package/esm/postMessageApi/sagas/command_received_saga.d.ts

@@ -2,7 +2,10 @@ import { type IDrillableItemsCommandBody } from "@gooddata/sdk-embedding";
 import { PostEventActionTypeKeys } from "../actions/action_types.js";
 import { type ICommandReceivedAction } from "../actions/command_received_actions.js";
 export declare function validateHostDomain(organizationId: string, url: string): Promise<boolean>;
-export declare function handleReceivedCommand({ payload: { data: commandData, origin: commandOrigin }, }: ICommandReceivedAction): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<boolean> | Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").SelectEffect, void, string | undefined> | Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").PutEffect<{
+export declare function handleReceivedCommand({ payload: { data: commandData, origin: commandOrigin }, }: ICommandReceivedAction): Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<boolean> | Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").PutEffect<{
+    payload: undefined;
+    type: import("../../sagas/application_context/application_context_actions.js").ApplicationContextActionsTypeKeys;
+}> | import("redux-saga/effects").SelectEffect, void, string | undefined> | Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").PutEffect<{
     payload: import("../../actions/confirm_unsaved_changes_actions.js").IConfirmUnsavedChangesDialogActionPayload;
     type: import("../../constants/actions.js").ActionTypeKeys.SAGA_CONFIRM_UNSAVED_CHANGES_REQUEST;
 }> | import("redux-saga/effects").SelectEffect, void, boolean> | Generator<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").PutEffect<{

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

@@ -1 +1 @@
-{"version":3,"file":"command_received_saga.d.ts","sourceRoot":"","sources":["../../../src/postMessageApi/sagas/command_received_saga.ts"],"names":[],"mappings":"AAIA,OAAO,EAIH,KAAK,0BAA0B,EAgBlC,MAAM,yBAAyB,CAAC;AAYjC,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAIrE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAiBrF,wBAAsB,kBAAkB,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAE9F;AAqDD,wBAAiB,qBAAqB,CAAC,EACnC,OAAO,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,GACxD,EAAE,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA4DxB;AAED,wBAAiB,oBAAoB,6EAEpC"}
+{"version":3,"file":"command_received_saga.d.ts","sourceRoot":"","sources":["../../../src/postMessageApi/sagas/command_received_saga.ts"],"names":[],"mappings":"AAIA,OAAO,EAIH,KAAK,0BAA0B,EAgBlC,MAAM,yBAAyB,CAAC;AAYjC,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAIrE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAiBrF,wBAAsB,kBAAkB,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAE9F;AAqDD,wBAAiB,qBAAqB,CAAC,EACnC,OAAO,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,GACxD,EAAE,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA4DxB;AAED,wBAAiB,oBAAoB,6EAEpC"}

package/esm/sagas/bootstrap_sagas.d.ts

@@ -18,15 +18,10 @@ export declare function bootstrap(routeParams: ICustomRouteParams): Generator<im
         isEmptyReport: boolean;
     };
     type: import("../constants/actions.js").ActionTypeKeys.APP_FINISHED_SUCCESSFUL_INITIALIZATION;
-}> | import("redux-saga/effects").PutEffect<{
-    payload: {
-        scripts: import("../actions/app_context_actions.js").IExternalScripts;
-    };
-    type: import("../constants/actions.js").ActionTypeKeys.LOAD_EXTERNAL_SCRIPTS_REQUESTED;
 }> | import("redux-saga/effects").PutEffect<{
     payload: {
         firstLoaded: boolean;
     };
     type: import("../store/catalog/catalog_store_actions.js").CatalogActionTypeKeys.STORE_SET_CATALOG_FIRST_LOADED;
-}> | import("redux-saga/effects").SelectEffect, void, (import("../actions/app_context_actions.js").IExternalScripts & string) | undefined>;
+}> | import("redux-saga/effects").SelectEffect, void, string | undefined>;
 //# sourceMappingURL=bootstrap_sagas.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bootstrap_sagas.d.ts","sourceRoot":"","sources":["../../src/sagas/bootstrap_sagas.ts"],"names":[],"mappings":"AAOA,OAAO,EACH,KAAK,cAAc,EAMtB,MAAM,mCAAmC,CAAC;AAM3C,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAejE,wBAAiB,SAAS,0HAGzB;AAED,wBAAiB,SAAS,CAAC,WAAW,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;2IA0EzD"}
+{"version":3,"file":"bootstrap_sagas.d.ts","sourceRoot":"","sources":["../../src/sagas/bootstrap_sagas.ts"],"names":[],"mappings":"AAOA,OAAO,EACH,KAAK,cAAc,EAKtB,MAAM,mCAAmC,CAAC;AAM3C,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAejE,wBAAiB,SAAS,0HAGzB;AAED,wBAAiB,SAAS,CAAC,WAAW,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;0EAoEzD"}

package/esm/sagas/bootstrap_sagas.js

@@ -2,9 +2,9 @@
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 import { all, call, put, select } from "redux-saga/effects";
 import { isContractExpired, isNotAuthenticated, isProtectedDataError } from "@gooddata/sdk-backend-spi";
-import { appFinishedLoading, appFinishedSuccessfulInitialization, appStartedLoading, bootstrapError, loadExternalScripts, } from "../actions/app_context_actions.js";
+import { appFinishedLoading, appFinishedSuccessfulInitialization, appStartedLoading, bootstrapError, } from "../actions/app_context_actions.js";
 import { DEFAULT_REPORT_ID } from "../constants/route_params.js";
-import { externalScripts, getProjectId } from "../selectors/bootstrap_selector.js";
+import { getProjectId } from "../selectors/bootstrap_selector.js";
 import { SERVICE_NAME, VERSION } from "../services/telemetry/openTelemetry/constants.js";
 import { logAccessingAD } from "../services/telemetry/tracking_events.js";
 import { setCatalogFirstLoaded } from "../store/catalog/catalog_store_actions.js";
@@ -31,11 +31,6 @@ export function* bootstrap(routeParams) {
         // Verify if user has all required permissions & feature flags for current app context
         // Throws error, when not
         yield call(verifyUserAccess);
-        // Load external scripts, when provided
-        const extScripts = yield select(externalScripts);
-        if (extScripts) {
-            yield put(loadExternalScripts(extScripts));
-        }
         // Set current workspaceId as a stashed project in the user profile settings
         const currentProjectId = yield select(getProjectId);
         yield call(loadVisualizationClasses, currentProjectId);

package/esm/sagas/open_report_sagas.d.ts

@@ -85,6 +85,12 @@ export declare function selectOpenReportFailureReset(): Generator<import("redux-
  * every missing item instead of surfacing as a backend error or a broken page.
  */
 export declare function failOnMissingDateFilterItems(insight: IInsight): Generator<import("redux-saga/effects").SelectEffect, void, import("../models/date_datasets_meta.js").IDateDatasetsMeta>;
+/**
+ * Whether one of the insight's relative date filters has a granularity AD cannot load. All time is
+ * supported: it is stored as the real All time filter (ALL_TIME_GRANULARITY) when it carries the empty
+ * date values mode.
+ */
+export declare function hasDateFilterWithUnsupportedGranularity(insight: IInsight): boolean;
 export declare function fetchReport(projectId: string, reportId: string): Generator<import("redux-saga/effects").AllEffect<import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<IMetadataObject[]>> | import("redux-saga/effects").CallEffect<void> | import("redux-saga/effects").CallEffect<number> | import("redux-saga/effects").CallEffect<import("@gooddata/sdk-model").IListedDashboard[]> | import("redux-saga/effects").CallEffect<IApplicationResetCarrier> | import("redux-saga/effects").CallEffect<import("../store/report/open_report_operation.js").IOpenReportResult> | import("redux-saga/effects").CallEffect<IParameterRestoreResult> | import("redux-saga/effects").CallEffect<{
     itemCache: {
         [x: string]: import("../typings/state_objects.js").ICatalogEntry;

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

@@ -1 +1 @@
-{"version":3,"file":"open_report_sagas.d.ts","sourceRoot":"","sources":["../../src/sagas/open_report_sagas.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,EACH,KAAK,QAAQ,EACb,KAAK,eAAe,EAUvB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EACH,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAKlC,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AA2BzD,OAAO,EACH,KAAK,uBAAuB,EAE/B,MAAM,iDAAiD,CAAC;AASzD,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAKnD,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,KAAK,kBAAkB,EAA+B,MAAM,sBAAsB,CAAC;AAyB5F,wBAAgB,YAAY,WAE3B;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,UAE5C;AAED,wBAAiB,mBAAmB,CAAC,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,EAAE,EAAE,0BAA0B;;;;;6DAuBtG;AAED,wBAAiB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,kHAazE;AAeD,wBAAiB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,2LAa1E;AAED;;;GAGG;AACH,wBAAiB,6BAA6B,CAAC,mBAAmB,EAAE,eAAe,EAAE;;;;;qJAsCpF;AAED,wBAAiB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,oBAAoB,GAAE,OAAe;;;;;;;;;;;;;;;;;;;GAoBtG;AAED;;;;;;;;;;GAUG;AACH,wBAAiB,uBAAuB,CAAC,MAAM,GAAE,kBAAuB;;;;;mBAKvE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACnC,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,QAAQ,EACjB,WAAW,EAAE,kBAAkB,EAC/B,eAAe,EAAE,OAAO,wEAwB3B;AAED,wBAAiB,qBAAqB,CAClC,OAAO,EAAE,QAAQ,EACjB,WAAW,EAAE,kBAAkB,EAC/B,eAAe,EAAE,OAAO,yIAI3B;AAED;;;;GAIG;AACH,wBAAiB,4BAA4B,uLAK5C;AAqBD;;;;;GAKG;AACH,wBAAiB,4BAA4B,CAAC,OAAO,EAAE,QAAQ,2HAU9D;AAKD,wBAAiB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uGAoG/D;AAED,wBAAiB,eAAe,CAAC,SAAS,EAAE,MAAM,4MAOjD;AAED,wBAAiB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+HAyEpE;AAED,wBAAiB,8BAA8B,CAAC,OAAO,EAAE,QAAQ,8JAchE;AAED,wBAAiB,qBAAqB,CAAC,EACnC,OAAO,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,GACrD,EAAE,yBAAyB;;;;;;;;0EA0B3B;AAMD,wBAAiB,eAAe,6EAK/B"}
+{"version":3,"file":"open_report_sagas.d.ts","sourceRoot":"","sources":["../../src/sagas/open_report_sagas.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,EACH,KAAK,QAAQ,EACb,KAAK,eAAe,EAWvB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EACH,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAKlC,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AA2BzD,OAAO,EACH,KAAK,uBAAuB,EAE/B,MAAM,iDAAiD,CAAC;AASzD,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAKnD,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,KAAK,kBAAkB,EAA+B,MAAM,sBAAsB,CAAC;AAyB5F,wBAAgB,YAAY,WAE3B;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,UAE5C;AAED,wBAAiB,mBAAmB,CAAC,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,EAAE,EAAE,0BAA0B;;;;;6DAuBtG;AAED,wBAAiB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,kHAazE;AAcD,wBAAiB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,2LAa1E;AAED;;;GAGG;AACH,wBAAiB,6BAA6B,CAAC,mBAAmB,EAAE,eAAe,EAAE;;;;;qJAsCpF;AAED,wBAAiB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,oBAAoB,GAAE,OAAe;;;;;;;;;;;;;;;;;;;GAoBtG;AAED;;;;;;;;;;GAUG;AACH,wBAAiB,uBAAuB,CAAC,MAAM,GAAE,kBAAuB;;;;;mBAKvE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACnC,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,QAAQ,EACjB,WAAW,EAAE,kBAAkB,EAC/B,eAAe,EAAE,OAAO,wEAwB3B;AAED,wBAAiB,qBAAqB,CAClC,OAAO,EAAE,QAAQ,EACjB,WAAW,EAAE,kBAAkB,EAC/B,eAAe,EAAE,OAAO,yIAI3B;AAED;;;;GAIG;AACH,wBAAiB,4BAA4B,uLAK5C;AAqBD;;;;;GAKG;AACH,wBAAiB,4BAA4B,CAAC,OAAO,EAAE,QAAQ,2HAU9D;AAED;;;;GAIG;AACH,wBAAgB,uCAAuC,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAQlF;AAKD,wBAAiB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uGA6F/D;AAED,wBAAiB,eAAe,CAAC,SAAS,EAAE,MAAM,4MAOjD;AAED,wBAAiB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+HAyEpE;AAED,wBAAiB,8BAA8B,CAAC,OAAO,EAAE,QAAQ,8JAchE;AAED,wBAAiB,qBAAqB,CAAC,EACnC,OAAO,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,GACrD,EAAE,yBAAyB;;;;;;;;0EA0B3B;AAMD,wBAAiB,eAAe,6EAK/B"}

package/esm/sagas/open_report_sagas.js

@@ -4,7 +4,7 @@ import { defineMessages } from "react-intl";
 import { all, call, delay, put, select, take, takeEvery } from "redux-saga/effects";
 import { v4 as uuid } from "uuid";
 import { dateAttributeIdToSdkGranularity } from "@gooddata/sdk-backend-tiger";
-import { insightParameters, insightSorts, insightUri, insightVisualizationUrl, isDateFilterGranularity, isRelativeDateFilter, isUriRef, objRefToString, uriRef, } from "@gooddata/sdk-model";
+import { insightParameters, insightSorts, insightUri, insightVisualizationUrl, isAllTimeDateFilter, isDateFilterGranularity, isRelativeDateFilter, isUriRef, objRefToString, uriRef, } from "@gooddata/sdk-model";
 import { changeDataset, updateInsightUsageOnDashboards, updateItemCache } from "../actions/data_actions.js";
 import { addMessage, hideMessage, showWarningMessage } from "../actions/messages_actions.js";
 import { openReportConfirmation, openReportFailed, openReportFinished, openReportStarted, } from "../actions/open_actions.js";
@@ -97,7 +97,6 @@ function stripQueryParams(uri) {
     const questionMarkIndex = uri.indexOf("?");
     // for some reason when we use includeObjectsWithTags or excludeObjectsWithTags, the URI contains a query parameter
     // we need to strip it to get the correct URI
-    // see https://gooddata.atlassian.net/browse/EB-448
     return questionMarkIndex === -1 ? uri : uri.substring(0, questionMarkIndex);
 }
 export function* getObjectsReferencing(projectId, insight) {
@@ -241,6 +240,17 @@ export function* failOnMissingDateFilterItems(insight) {
         throw new MissingInsightItemsError(missingItems);
     }
 }
+/**
+ * Whether one of the insight's relative date filters has a granularity AD cannot load. All time is
+ * supported: it is stored as the real All time filter (ALL_TIME_GRANULARITY) when it carries the empty
+ * date values mode.
+ */
+export function hasDateFilterWithUnsupportedGranularity(insight) {
+    return insight.insight.filters
+        .filter(isRelativeDateFilter)
+        .some((filter) => !isAllTimeDateFilter(filter) &&
+        !isDateFilterGranularity(filter.relativeDateFilter.granularity));
+}
 const missingItemsOf = (error) => isMissingInsightItemsError(error) ? error.missingItems : undefined;
 export function* fetchReport(projectId, reportId) {
     try {
@@ -261,13 +271,7 @@ export function* fetchReport(projectId, reportId) {
         const catalogSideloadEnabled = yield select(enableAnalyticalDesignerCatalogSideload);
         const sideloadInsightItems = catalogSideloadEnabled && !!(includeObjectsWithTags.length || excludeObjectsWithTags.length);
         const { insight, catalogItems } = yield call(getInsight, projectId, reportId, sideloadInsightItems);
-        const hasFilterWithInvalidGranularity = insight.insight.filters
-            .filter(isRelativeDateFilter)
-            .some((filter) => {
-            const granularity = filter.relativeDateFilter.granularity;
-            return !isDateFilterGranularity(granularity);
-        });
-        if (hasFilterWithInvalidGranularity) {
+        if (hasDateFilterWithUnsupportedGranularity(insight)) {
             const reset = yield call(selectOpenReportFailureReset);
             yield put(openReportFailed(reset, false, "incorrectMetadata"));
             // uses delay, must be called after previous call to not block it

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

@@ -1 +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"}
+{"version":3,"file":"sagas.d.ts","sourceRoot":"","sources":["../../src/sagas/sagas.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,mCAAmC,CAAC;AAwDxF,wBAAiB,IAAI;;;;;;mBAgFpB"}

package/esm/sagas/sagas.js

@@ -38,7 +38,6 @@ 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";
@@ -99,7 +98,6 @@ export function* root() {
             watchDrillableItems(),
             watchIncomingCommands(),
             watchDispatchPostponedAction(),
-            watchLoadExternalScripts(),
             watchCatalog(),
             watchFilterBar(),
             watchFeatureFlags(),