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

package/esm/create_store.js

@@ -0,0 +1,79 @@
+// (C) 2007-2026 GoodData Corporation
+import { configureStore } from "@reduxjs/toolkit";
+import createSagaMiddleware from "redux-saga";
+import { IS_DEBUG, IS_TESTING } from "./buildParams.js";
+import { availableCommandChanged, } from "./postMessageApi/outgoing/supported_commands_events.js";
+import { availableCommandsStateSelector } from "./postMessageApi/state/selectors/post_message_context_selector.js";
+import { rootReducer } from "./reducers/root_reducer.js";
+import { root as sagas } from "./sagas/sagas.js";
+import { observeStore } from "./store/_infra/observe_store.js";
+// Subtrees the RTK dev checks must not walk. `timeTravel` holds whole past states BY REFERENCE, so
+// walking it re-traverses every snapshot on every dispatch — a frozen main thread in dev. Cost of
+// traversal is the only reason to add an entry here, and nothing else is large enough to need one.
+const DEV_CHECK_IGNORED_PATHS = ["timeTravel"];
+// NodeNext resolves redux-saga's default to a module namespace; the cast restores callability.
+const sagaMiddleware = createSagaMiddleware({
+    onError(error) {
+        console.error(error);
+    },
+});
+/**
+ * Replaces the undo history with its shape, so the devtools do not carry N copies of the root.
+ *
+ * Generic in the state so it satisfies the extension's `stateSanitizer` signature; the cast on
+ * the way out is inherent to what a sanitizer is — it hands the extension a state-shaped view,
+ * not the state.
+ */
+function sanitizeTimeTravel(state) {
+    const root = state;
+    const timeTravel = root?.timeTravel;
+    if (timeTravel === undefined) {
+        return state;
+    }
+    return {
+        ...root,
+        timeTravel: `«${timeTravel.past.length} undo / ${timeTravel.future.length} redo steps»`,
+    };
+}
+function subscribeToControlsState(store) {
+    // observeStore: reference-equality change detection, no redux-watch dependency
+    return observeStore(store, availableCommandsStateSelector, (availableCommandState) => {
+        availableCommandChanged(availableCommandState);
+    });
+}
+export function createStore(reducer = rootReducer) {
+    const store = configureStore({
+        // No preloadedState: the combined root self-initializes every owned key, and each store
+        // gets its own fresh build from the reducer itself (see reducers/initial_state.ts).
+        reducer: reducer,
+        middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+            // No thunks — redux-saga is the only orchestration layer in AD.
+            thunk: false,
+            // Both checks are dev-only — RTK compiles them out of production builds.
+            immutableCheck: {
+                warnAfter: 128,
+                ignoredPaths: DEV_CHECK_IGNORED_PATHS,
+            },
+            serializableCheck: {
+                warnAfter: 128,
+                ignoredPaths: DEV_CHECK_IGNORED_PATHS,
+                // some action payloads carry non-serializable values (occasionally
+                // functions) — the state-side check is the valuable half
+                ignoreActions: true,
+            },
+        }).concat(sagaMiddleware),
+        devTools: (IS_DEBUG || IS_TESTING) && {
+            name: "Analytical Designer",
+            trace: true,
+            // The devtools serialize the whole state per action; the undo history holds whole
+            // past states, so it is collapsed to its stack depths. The extension only ever sees
+            // the sanitized copy — the store itself is untouched.
+            stateSanitizer: sanitizeTimeTravel,
+        },
+    });
+    // Sagas are never auto-started — every caller (standalone bootstrap, the pluggable wrapper)
+    // invokes startSagas() explicitly when ready.
+    const startSagas = () => sagaMiddleware.run(sagas);
+    const subscribeControls = () => subscribeToControlsState(store);
+    return { store, sagaMiddleware, startSagas, subscribeControls };
+}

package/esm/embedding/AnalyticalDesigner.d.ts

@@ -0,0 +1,32 @@
+import { type ReactElement, type Ref } from "react";
+import { type IAdSetApiTokenBody } from "@gooddata/sdk-embedding";
+import { type IApiToken } from "../backend.js";
+import { type IAnalyticalDesignerApi, type IAnalyticalDesignerProps } from "./analyticalDesignerTypes.js";
+/** Commands of the GoodData apps: the public commands plus the token renewal. */
+export interface IAnalyticalDesignerInternalApi extends IAnalyticalDesignerApi {
+    setApiToken(body: IAdSetApiTokenBody): void;
+}
+/** Props of the GoodData apps that do not own the auth provider of the backend. */
+export interface IAnalyticalDesignerInternalProps extends Omit<IAnalyticalDesignerProps, "apiRef"> {
+    /** Seeds the stored token, so the SetApiToken renewals update it in place. */
+    auth?: IApiToken;
+    externalProviderId?: string;
+    apiRef?: Ref<IAnalyticalDesignerInternalApi>;
+}
+/**
+ * Analytical Designer with the props of the GoodData apps. The public component and the ./internal
+ * one render it.
+ */
+export declare function AnalyticalDesignerInternal(props: IAnalyticalDesignerInternalProps): ReactElement;
+/**
+ * Analytical Designer as a React component.
+ *
+ * @remarks
+ * Render it inside a `BackendProvider` and a `WorkspaceProvider`, or pass `backend` and `workspace`.
+ * Import the stylesheets the package README lists. One instance can be mounted per page: mounting a
+ * second one throws an error.
+ *
+ * @alpha
+ */
+export declare function AnalyticalDesigner(props: IAnalyticalDesignerProps): ReactElement;
+//# sourceMappingURL=AnalyticalDesigner.d.ts.map

package/esm/embedding/AnalyticalDesigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnalyticalDesigner.d.ts","sourceRoot":"","sources":["../../src/embedding/AnalyticalDesigner.tsx"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,GAAG,EAMX,MAAM,OAAO,CAAC;AAGf,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAKlE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAa/C,OAAO,EACH,KAAK,sBAAsB,EAE3B,KAAK,wBAAwB,EAChC,MAAM,8BAA8B,CAAC;AAOtC,iFAAiF;AACjF,MAAM,WAAW,8BAA+B,SAAQ,sBAAsB;IAC1E,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAAC;CAC/C;AAED,mFAAmF;AACnF,MAAM,WAAW,gCAAiC,SAAQ,IAAI,CAAC,wBAAwB,EAAE,QAAQ,CAAC;IAC9F,8EAA8E;IAC9E,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,MAAM,CAAC,EAAE,GAAG,CAAC,8BAA8B,CAAC,CAAC;CAChD;AAwDD;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,gCAAgC,GAAG,YAAY,CAkIhG;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,wBAAwB,GAAG,YAAY,CAgBhF"}

package/esm/embedding/AnalyticalDesigner.js

@@ -0,0 +1,165 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useEffect, useImperativeHandle, useRef, useState, } from "react";
+import { ErrorComponent, LoadingComponent, useBackendStrict, useWorkspaceStrict } from "@gooddata/sdk-ui";
+import { backendBootstrapData, loadSettings } from "../sagas/bootstrap/backendBootstrapData.js";
+import { applyConfigToBootstrapData, resolveRouteIdentifiers, resolveTheme, routeTargetKey, toEmbeddedCallbacks, toRouteConfig, } from "./analyticalDesignerConfig.js";
+import { AnalyticalDesignerEmbedded } from "./AnalyticalDesignerEmbedded.js";
+import { renderSlot, } from "./slots.js";
+const NO_CONFIG = {};
+function DefaultLoading({ className }) {
+    return _jsx(LoadingComponent, { className: className });
+}
+function DefaultError({ error }) {
+    const message = error instanceof Error ? error.message : "Analytical Designer cannot start.";
+    return _jsx(ErrorComponent, { message: message });
+}
+async function loadHostData(props, backend, workspace) {
+    const config = props.config ?? NO_CONFIG;
+    const { organization } = config;
+    const settings = config.settings ?? (await loadSettings(backend, workspace));
+    const [data, permissions] = await Promise.all([
+        backendBootstrapData(backend, workspace, config.locale, {
+            settings,
+            user: config.user,
+            organization: organization?.id ? { id: organization.id, title: organization.title } : undefined,
+            entitlements: organization?.entitlements,
+            colorPalette: config.colorPalette,
+            loadTheme: !props.theme && !props.disableThemeLoading,
+        }),
+        props.permissions ?? backend.workspace(workspace).permissions().getPermissionsForCurrentUser(),
+    ]);
+    const theme = resolveTheme(props, data.theme);
+    return { bootstrapData: applyConfigToBootstrapData(data, config, theme), settings, permissions };
+}
+function routeKey(props) {
+    const config = props.config ?? NO_CONFIG;
+    const sourceDashboard = typeof config.sourceDashboard === "string"
+        ? `id:${config.sourceDashboard}`
+        : routeTargetKey(config.sourceDashboard);
+    return [routeTargetKey(props.insight), sourceDashboard, routeTargetKey(config.sourceInsight)].join("|");
+}
+/**
+ * Analytical Designer with the props of the GoodData apps. The public component and the ./internal
+ * one render it.
+ */
+export function AnalyticalDesignerInternal(props) {
+    const backend = useBackendStrict(props.backend, "AnalyticalDesigner");
+    const workspace = useWorkspaceStrict(props.workspace, "AnalyticalDesigner");
+    const config = props.config ?? NO_CONFIG;
+    // The effects read the latest props through the ref, so a new callback or config object does not
+    // restart them.
+    const propsRef = useRef(props);
+    useEffect(() => {
+        propsRef.current = props;
+    });
+    const [hostData, setHostData] = useState(null);
+    const [error, setError] = useState(null);
+    const reportError = useCallback((reason) => {
+        setError(reason);
+        propsRef.current.onError?.(reason);
+    }, []);
+    // A route that fails to resolve shows the error until a later route resolves.
+    const [routeError, setRouteError] = useState(null);
+    const reportRouteError = useCallback((reason) => {
+        setRouteError(reason);
+        propsRef.current.onError?.(reason);
+    }, []);
+    // The host data is mount-scoped, as the runtime it seeds: the runtime gets the same backend and
+    // workspace as the host data, even when the props change before it mounts.
+    const [mount] = useState(() => ({ backend, workspace }));
+    // The runtime reads its host context once, so the resets call the latest `cacheReset`.
+    const [cacheReset] = useState(() => ({
+        resetAllCaches: () => propsRef.current.cacheReset?.resetAll?.(),
+        resetCatalogs: () => propsRef.current.cacheReset?.resetCatalogs?.(),
+    }));
+    useEffect(() => {
+        let cancelled = false;
+        loadHostData(propsRef.current, mount.backend, mount.workspace).then((data) => !cancelled && setHostData(data), (reason) => !cancelled && reportError(reason));
+        return () => {
+            cancelled = true;
+        };
+    }, [mount, reportError]);
+    // The route follows the props: a new insight or flow navigates AD once its identifiers resolve.
+    const currentRouteKey = routeKey(props);
+    const [route, setRoute] = useState(null);
+    useEffect(() => {
+        let cancelled = false;
+        const latest = propsRef.current;
+        resolveRouteIdentifiers(mount.backend, mount.workspace, latest.insight, latest.config ?? NO_CONFIG).then((identifiers) => {
+            if (!cancelled) {
+                setRoute({ key: currentRouteKey, identifiers });
+                setRouteError(null);
+            }
+        }, (reason) => !cancelled && reportRouteError(reason));
+        return () => {
+            cancelled = true;
+        };
+    }, [mount, currentRouteKey, reportRouteError]);
+    // AD mounts only after the host data loads; the commands sent before that wait for it.
+    const embeddedApiRef = useRef(null);
+    const pendingCommandsRef = useRef([]);
+    const runCommand = useCallback((command) => {
+        if (embeddedApiRef.current) {
+            command(embeddedApiRef.current);
+        }
+        else {
+            pendingCommandsRef.current.push(command);
+        }
+    }, []);
+    const failure = error ?? routeError;
+    const isMounted = !!hostData && !!route && !failure;
+    useEffect(() => {
+        const api = embeddedApiRef.current;
+        if (isMounted && api) {
+            pendingCommandsRef.current.splice(0).forEach((command) => command(api));
+        }
+    }, [isMounted]);
+    useImperativeHandle(props.apiRef, () => ({
+        clear: () => runCommand((api) => api.clear()),
+        requestCancellation: () => runCommand((api) => api.requestCancellation()),
+        setFilterContext: (data, contextId) => runCommand((api) => api.setFilterContext(data, contextId)),
+        sendCommand: (command) => runCommand((api) => api.sendCommand(command)),
+        setApiToken: (body) => runCommand((api) => api.setApiToken(body)),
+    }), [runCommand]);
+    if (failure) {
+        return renderSlot(props.slots?.Error, DefaultError, { error: failure });
+    }
+    if (!hostData || !route) {
+        return renderSlot(props.slots?.Loading, DefaultLoading, {});
+    }
+    const callbacks = toEmbeddedCallbacks(props);
+    return (_jsx(AnalyticalDesignerEmbedded, { config: toRouteConfig(route.identifiers, config), host: {
+            workspaceId: mount.workspace,
+            bootstrapData: hostData.bootstrapData,
+            featureFlags: hostData.settings,
+            workspacePermissions: hostData.permissions,
+            hostBackend: { instance: mount.backend, ...cacheReset },
+            auth: props.auth,
+            externalProviderId: props.externalProviderId,
+            locale: config.locale,
+            telemetryCallbacks: config.telemetryCallbacks,
+            isReadOnly: config.isReadOnly,
+        }, callbacks: callbacks, apiRef: embeddedApiRef, slots: props.slots }));
+}
+/**
+ * Analytical Designer as a React component.
+ *
+ * @remarks
+ * Render it inside a `BackendProvider` and a `WorkspaceProvider`, or pass `backend` and `workspace`.
+ * Import the stylesheets the package README lists. One instance can be mounted per page: mounting a
+ * second one throws an error.
+ *
+ * @alpha
+ */
+export function AnalyticalDesigner(props) {
+    const { apiRef, ...rest } = props;
+    const internalApiRef = useRef(null);
+    useImperativeHandle(apiRef, () => ({
+        clear: () => internalApiRef.current?.clear(),
+        requestCancellation: () => internalApiRef.current?.requestCancellation(),
+        setFilterContext: (data, contextId) => internalApiRef.current?.setFilterContext(data, contextId),
+        sendCommand: (command) => internalApiRef.current?.sendCommand(command),
+    }), []);
+    return _jsx(AnalyticalDesignerInternal, { ...rest, apiRef: internalApiRef });
+}

package/esm/embedding/AnalyticalDesignerEmbedded.d.ts

@@ -0,0 +1,71 @@
+import { type ReactElement, type Ref } from "react";
+import { type IUserSettings, type IUserWorkspaceSettings } from "@gooddata/sdk-backend-spi";
+import { type IAdSetApiTokenBody, type IFilterContextContent } from "@gooddata/sdk-embedding";
+import { type IWorkspacePermissions } from "@gooddata/sdk-model";
+import { type IBootstrapData } from "../actions/app_context_actions.js";
+import { type IAdHostBackend, type IApiToken } from "../backend.js";
+import { type IHostTelemetryCallbacks } from "../services/telemetry/tracker.js";
+import { type IAdEmbeddedRouteConfig } from "./buildEmbeddedHash.js";
+import { type IAdEmbeddedCallbacks } from "./embeddedCallbacks.js";
+import { type AdCommandEnvelope } from "./hostBridge.js";
+import { type IAnalyticalDesignerSlots } from "./slots.js";
+/**
+ * Mount-scoped context of the host application. Captured once at mount; later changes are ignored
+ * (token renewals go through the SetApiToken command, see IAdEmbeddedApi.setApiToken).
+ */
+export interface IAdEmbeddedHostContext {
+    workspaceId: string;
+    /** When omitted, AD loads the bootstrap data from the backend. */
+    bootstrapData?: IBootstrapData;
+    featureFlags?: IUserWorkspaceSettings | IUserSettings;
+    workspacePermissions?: IWorkspacePermissions;
+    /** Undefined means context-deferred (cookie-based) authentication. */
+    auth?: IApiToken;
+    /**
+     * Host-owned backend to adopt instead of creating an AD-owned instance. When provided, the
+     * host's auth provider owns authentication and token renewal and the host's cache is shared;
+     * `auth` then only seeds the stored token for components that read it directly (SetApiToken
+     * renewals keep it in sync without touching the backend).
+     */
+    hostBackend?: IAdHostBackend;
+    externalProviderId?: string;
+    locale?: string;
+    /**
+     * Telemetry forwarding into the host's pipeline. When omitted, no-op callbacks are registered
+     * instead.
+     */
+    telemetryCallbacks?: IHostTelemetryCallbacks;
+    /** Hides the actions that change the insight (save, save as, create new). */
+    isReadOnly?: boolean;
+}
+/** Imperative command surface, exposed through the apiRef prop. */
+export interface IAdEmbeddedApi {
+    /** Raw escape hatch — inject any supported command envelope. */
+    sendCommand(envelope: AdCommandEnvelope): void;
+    clear(): void;
+    requestCancellation(): void;
+    setFilterContext(data: IFilterContextContent, contextId?: string): void;
+    setApiToken(body: IAdSetApiTokenBody): void;
+}
+export interface IAnalyticalDesignerEmbeddedProps {
+    /** Route configuration: which insight, which flow, which UI actions. Changes navigate AD. */
+    config: IAdEmbeddedRouteConfig;
+    /** Mount-scoped host context (workspace, bootstrap data, auth, feature flags). */
+    host: IAdEmbeddedHostContext;
+    callbacks?: IAdEmbeddedCallbacks;
+    apiRef?: Ref<IAdEmbeddedApi>;
+    /** Regions the host replaces or wraps. */
+    slots?: IAnalyticalDesignerSlots;
+}
+/**
+ * Analytical Designer rendered in-process as a React component — the iframe-free alternative to
+ * embedding the deployed AD app. Communication uses the same @gooddata/sdk-embedding contract as
+ * the postMessage transport, carried over the host adapter: events arrive through `callbacks`,
+ * commands are sent through `apiRef`.
+ *
+ * Constraints (v1, same as pluggable-shell mode): the AD runtime uses a singleton store, so at
+ * most one instance may be mounted per page. The mount sequence mirrors pluggableApp.tsx: seed
+ * store, reinitialize backend, start sagas; unmount cancels the saga task and resets the store.
+ */
+export declare function AnalyticalDesignerEmbedded({ config, host, callbacks, apiRef, slots, }: IAnalyticalDesignerEmbeddedProps): ReactElement | null;
+//# sourceMappingURL=AnalyticalDesignerEmbedded.d.ts.map

package/esm/embedding/AnalyticalDesignerEmbedded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnalyticalDesignerEmbedded.d.ts","sourceRoot":"","sources":["../../src/embedding/AnalyticalDesignerEmbedded.tsx"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,GAAG,EAMX,MAAM,OAAO,CAAC;AAEf,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAC5F,OAAO,EAIH,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAE7B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEjE,OAAO,EAAE,KAAK,cAAc,EAA4B,MAAM,mCAAmC,CAAC;AAMlG,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,SAAS,EAAyC,MAAM,eAAe,CAAC;AAG3G,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAShF,OAAO,EAAE,KAAK,sBAAsB,EAAqB,MAAM,wBAAwB,CAAC;AACxF,OAAO,EAAE,KAAK,oBAAoB,EAA2B,MAAM,wBAAwB,CAAC;AAC5F,OAAO,EAAE,KAAK,iBAAiB,EAAsB,MAAM,iBAAiB,CAAC;AAY7E,OAAO,EAAmB,KAAK,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAG5E;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,aAAa,CAAC,EAAE,cAAc,CAAC;IAC/B,YAAY,CAAC,EAAE,sBAAsB,GAAG,aAAa,CAAC;IACtD,oBAAoB,CAAC,EAAE,qBAAqB,CAAC;IAC7C,sEAAsE;IACtE,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,cAAc,CAAC;IAC7B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,uBAAuB,CAAC;IAC7C,6EAA6E;IAC7E,UAAU,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,mEAAmE;AACnE,MAAM,WAAW,cAAc;IAC3B,gEAAgE;IAChE,WAAW,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC/C,KAAK,IAAI,IAAI,CAAC;IACd,mBAAmB,IAAI,IAAI,CAAC;IAC5B,gBAAgB,CAAC,IAAI,EAAE,qBAAqB,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxE,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAAC;CAC/C;AAED,MAAM,WAAW,gCAAgC;IAC7C,6FAA6F;IAC7F,MAAM,EAAE,sBAAsB,CAAC;IAC/B,kFAAkF;IAClF,IAAI,EAAE,sBAAsB,CAAC;IAC7B,SAAS,CAAC,EAAE,oBAAoB,CAAC;IACjC,MAAM,CAAC,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC;IAC7B,0CAA0C;IAC1C,KAAK,CAAC,EAAE,wBAAwB,CAAC;CACpC;AAuBD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,EACvC,MAAM,EACN,IAAI,EACJ,SAAS,EACT,MAAM,EACN,KAAK,GACR,EAAE,gCAAgC,GAAG,YAAY,GAAG,IAAI,CAkJxD"}

package/esm/embedding/AnalyticalDesignerEmbedded.js

@@ -0,0 +1,176 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useEffect, useImperativeHandle, useRef, useState, } from "react";
+import { GdcAdCommandType, GdcProductName, } from "@gooddata/sdk-embedding";
+import { bootstrapData, setLocale } from "../actions/app_context_actions.js";
+import { setEmbedded, setReadOnlyMode } from "../actions/embedded_actions.js";
+import { setFeatureFlagsItems } from "../actions/featureFlags_actions.js";
+import { workspacePermissionsSuccess } from "../actions/permissions_actions.js";
+import { resetForPluggableMount } from "../actions/reset_for_pluggable_mount_actions.js";
+import { setHostedComponentMode } from "../appMode/appMode.js";
+import { adoptHostBackend, reinitializeBackend } from "../backend.js";
+import { startSagas, store } from "../reduxStore.js";
+import { Root } from "../Root.js";
+import { clearHostTelemetryCallbacks, setHostTelemetryCallbacks, } from "../services/telemetry/tracking_events.js";
+import { getErrorsState } from "../store/app_context/app_context_selectors.js";
+import { storeApiToken } from "../store/application_context/app_context_actions.js";
+import { setRouteProjectId } from "../store/router/router_actions.js";
+import { buildEmbeddedHash } from "./buildEmbeddedHash.js";
+import { deliverEventToCallbacks } from "./embeddedCallbacks.js";
+import { installHostAdapter } from "./hostBridge.js";
+import { activateHostCommandOwner, deactivateHostCommandOwner, } from "./hostCommandGate.js";
+import { sendCommandToAd } from "./hostCommands.js";
+import { SECOND_MOUNT_ERROR_MESSAGE, claimAnalyticalDesignerRuntime, releaseAnalyticalDesignerRuntime, } from "./mountGuard.js";
+import { AdSlotsProvider } from "./slots.js";
+import { getVirtualNavigate } from "./virtualLocation.js";
+function commandEnvelope(name, data, contextId) {
+    return {
+        gdc: {
+            product: GdcProductName.ANALYTICAL_DESIGNER,
+            event: { name, data, contextId },
+        },
+    };
+}
+const NO_SLOTS = {};
+const NOOP_TELEMETRY = {
+    trackEvent: () => { },
+    trackPageView: () => { },
+    trackTiming: () => { },
+};
+/**
+ * Analytical Designer rendered in-process as a React component — the iframe-free alternative to
+ * embedding the deployed AD app. Communication uses the same @gooddata/sdk-embedding contract as
+ * the postMessage transport, carried over the host adapter: events arrive through `callbacks`,
+ * commands are sent through `apiRef`.
+ *
+ * Constraints (v1, same as pluggable-shell mode): the AD runtime uses a singleton store, so at
+ * most one instance may be mounted per page. The mount sequence mirrors pluggableApp.tsx: seed
+ * store, reinitialize backend, start sagas; unmount cancels the saga task and resets the store.
+ */
+export function AnalyticalDesignerEmbedded({ config, host, callbacks, apiRef, slots, }) {
+    const [ready, setReady] = useState(false);
+    const [mountError, setMountError] = useState(null);
+    const callbacksRef = useRef(callbacks);
+    useEffect(() => {
+        callbacksRef.current = callbacks;
+    });
+    // Host context is mount-scoped by contract; capture it so the mount effect can run once.
+    const hostRef = useRef(host);
+    const initialLocationRef = useRef(null);
+    if (initialLocationRef.current === null) {
+        initialLocationRef.current = `/${buildEmbeddedHash(config)}`;
+    }
+    const lastNavigatedHashRef = useRef(null);
+    // The imperative api binds during the render commit, before the sagas start. sendCommandToAd
+    // keeps a command until the command watchers listen, so an early command is not lost.
+    // This mount owns its queued commands: when it unmounts before AD listens, they are dropped
+    // rather than delivered to the runtime of a later mount.
+    const commandOwnerRef = useRef({});
+    const dispatchCommand = useCallback((envelope) => {
+        sendCommandToAd(envelope, commandOwnerRef.current);
+    }, []);
+    useEffect(() => {
+        if (!claimAnalyticalDesignerRuntime()) {
+            const error = new Error(SECOND_MOUNT_ERROR_MESSAGE);
+            callbacksRef.current?.onError?.(error);
+            setMountError(error);
+            return undefined;
+        }
+        const commandOwner = commandOwnerRef.current;
+        activateHostCommandOwner(commandOwner);
+        const mountHost = hostRef.current;
+        // Scope for the embedded-mode stacking overrides (styles/embedded_overrides.scss): AD's
+        // floating elements portal to document.body, so an ancestor class cannot reach them —
+        // only a body-level marker can.
+        document.body.classList.add("gd-ad-embedded");
+        const uninstallAdapter = installHostAdapter({
+            onEvent: (event) => deliverEventToCallbacks(event, callbacksRef.current),
+        });
+        // setHostedComponentMode(true): differentiates the router choice and postMessage registration.
+        store.dispatch(setHostedComponentMode(true));
+        store.dispatch(setEmbedded(true));
+        if (mountHost.isReadOnly) {
+            store.dispatch(setReadOnlyMode(true));
+        }
+        if (mountHost.bootstrapData) {
+            store.dispatch(bootstrapData(mountHost.bootstrapData, window));
+        }
+        store.dispatch(setRouteProjectId(mountHost.workspaceId));
+        if (mountHost.workspacePermissions) {
+            store.dispatch(workspacePermissionsSuccess(mountHost.workspaceId, mountHost.workspacePermissions));
+        }
+        store.dispatch(setFeatureFlagsItems(mountHost.featureFlags ?? {}));
+        if (mountHost.locale) {
+            store.dispatch(setLocale(mountHost.locale));
+        }
+        // Seeding the token is what makes later SetApiToken renewals take the update-in-place path
+        // instead of a full backend replacement.
+        if (mountHost.auth?.apiToken) {
+            store.dispatch(storeApiToken(mountHost.auth.apiToken, mountHost.auth.apiTokenType ?? "gooddata"));
+        }
+        if (mountHost.hostBackend) {
+            adoptHostBackend(mountHost.hostBackend);
+        }
+        else {
+            reinitializeBackend(mountHost.auth, mountHost.externalProviderId);
+        }
+        const telemetryCallbacks = mountHost.telemetryCallbacks ?? NOOP_TELEMETRY;
+        setHostTelemetryCallbacks(telemetryCallbacks);
+        // Report each error that stops AD from starting; the store keeps them in order.
+        let reportedErrors = 0;
+        const unsubscribeErrors = store.subscribe(() => {
+            const errors = getErrorsState(store.getState());
+            if (errors.length > reportedErrors) {
+                reportedErrors = errors.length;
+                callbacksRef.current?.onError?.(errors[errors.length - 1]);
+            }
+            else if (errors.length < reportedErrors) {
+                reportedErrors = errors.length;
+            }
+        });
+        const rootTask = startSagas();
+        setReady(true);
+        return () => {
+            deactivateHostCommandOwner(commandOwner);
+            unsubscribeErrors();
+            rootTask.cancel();
+            uninstallAdapter();
+            clearHostTelemetryCallbacks(telemetryCallbacks);
+            store.dispatch(resetForPluggableMount());
+            document.body.classList.remove("gd-ad-embedded");
+            releaseAnalyticalDesignerRuntime();
+        };
+        // Mount/unmount lifecycle only — the host context is captured at mount by contract.
+    }, []);
+    // Route changes after mount (open/switch insight) navigate the memory router — the same
+    // trigger semantics as the iframe src hash swap.
+    const currentHash = buildEmbeddedHash(config);
+    useEffect(() => {
+        if (!ready) {
+            return;
+        }
+        if (lastNavigatedHashRef.current === null) {
+            // First pass: the memory router already booted at the initial location.
+            lastNavigatedHashRef.current = currentHash;
+            return;
+        }
+        if (currentHash !== lastNavigatedHashRef.current) {
+            lastNavigatedHashRef.current = currentHash;
+            getVirtualNavigate()?.(currentHash);
+        }
+    }, [ready, currentHash]);
+    useImperativeHandle(apiRef, () => ({
+        sendCommand: dispatchCommand,
+        clear: () => dispatchCommand(commandEnvelope(GdcAdCommandType.Clear, null)),
+        requestCancellation: () => dispatchCommand(commandEnvelope(GdcAdCommandType.RequestCancellation, null)),
+        setFilterContext: (data, contextId) => dispatchCommand(commandEnvelope(GdcAdCommandType.SetFilterContext, data, contextId)),
+        setApiToken: (body) => dispatchCommand(commandEnvelope(GdcAdCommandType.SetApiToken, body)),
+    }), [dispatchCommand]);
+    if (mountError) {
+        throw mountError;
+    }
+    if (!ready) {
+        return null;
+    }
+    return (_jsx(AdSlotsProvider, { value: slots ?? NO_SLOTS, children: _jsx(Root, { initialLocation: initialLocationRef.current }) }));
+}

package/esm/embedding/HostedLocation.d.ts

@@ -0,0 +1,13 @@
+import { type PropsWithChildren } from "react";
+interface IHostedLocationProps {
+    /** Mount-time location, a hash route anchored at "/". */
+    initialLocation?: string;
+}
+/**
+ * The location of a hosted-component AD, kept in state instead of a router: AD routes by hash only,
+ * and a host with its own react-router tree cannot mount a second Router. Navigation arrives through
+ * the virtual-navigate registration setLocation uses in hosted mode.
+ */
+export declare function HostedLocation({ initialLocation, children }: PropsWithChildren<IHostedLocationProps>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=HostedLocation.d.ts.map

package/esm/embedding/HostedLocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HostedLocation.d.ts","sourceRoot":"","sources":["../../src/embedding/HostedLocation.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAuB,MAAM,OAAO,CAAC;AASpE,UAAU,oBAAoB;IAC1B,yDAAyD;IACzD,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B;AAaD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAAE,eAAe,EAAE,QAAQ,EAAE,EAAE,iBAAiB,CAAC,oBAAoB,CAAC,2CAWpG"}

package/esm/embedding/HostedLocation.js

@@ -0,0 +1,24 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useEffect, useState } from "react";
+import { useDispatch } from "react-redux";
+import { locationChanged } from "../store/router/router_actions.js";
+import { registerVirtualNavigate } from "./virtualLocation.js";
+function toVirtualLocation(to) {
+    const hashStart = to.indexOf("#");
+    return { hash: hashStart === -1 ? "" : to.slice(hashStart) };
+}
+/**
+ * The location of a hosted-component AD, kept in state instead of a router: AD routes by hash only,
+ * and a host with its own react-router tree cannot mount a second Router. Navigation arrives through
+ * the virtual-navigate registration setLocation uses in hosted mode.
+ */
+export function HostedLocation({ initialLocation, children }) {
+    const [location, setLocation] = useState(() => toVirtualLocation(initialLocation ?? "/"));
+    const dispatch = useDispatch();
+    useEffect(() => registerVirtualNavigate((to) => setLocation(toVirtualLocation(to))), []);
+    useEffect(() => {
+        dispatch(locationChanged(location.hash));
+    }, [location, dispatch]);
+    return _jsx(_Fragment, { children: children });
+}

package/esm/embedding/analyticalDesignerConfig.d.ts

@@ -0,0 +1,35 @@
+import { type IAnalyticalBackend } from "@gooddata/sdk-backend-spi";
+import { type IInsight, type ITheme, type ObjRef } from "@gooddata/sdk-model";
+import { type IBootstrapData } from "../actions/app_context_actions.js";
+import { type IAnalyticalDesignerConfig, type IAnalyticalDesignerProps } from "./analyticalDesignerTypes.js";
+import { type IAdEmbeddedRouteConfig } from "./buildEmbeddedHash.js";
+import { type IAdEmbeddedCallbacks } from "./embeddedCallbacks.js";
+/** The identifiers AD builds its route from, resolved from the identifiers and refs of the props. */
+export interface IResolvedRouteIdentifiers {
+    insightId?: string;
+    sourceDashboardId?: string;
+    sourceInsightId?: string;
+}
+/** A stable key of an insight, ref or identifier, for comparing the props between renders. */
+export declare function routeTargetKey(target: string | ObjRef | IInsight | undefined): string;
+/** The identifier of an insight; a URI ref is loaded from the backend. */
+export declare function resolveInsightIdentifier(backend: IAnalyticalBackend, workspace: string, target: string | ObjRef | IInsight | undefined): Promise<string | undefined>;
+/** The identifier of a dashboard; a URI ref is loaded from the backend. An empty string stays empty. */
+export declare function resolveDashboardIdentifier(backend: IAnalyticalBackend, workspace: string, target: string | ObjRef | undefined): Promise<string | undefined>;
+/** Resolves the identifiers AD builds its route from. */
+export declare function resolveRouteIdentifiers(backend: IAnalyticalBackend, workspace: string, insight: IAnalyticalDesignerProps["insight"], config: IAnalyticalDesignerConfig): Promise<IResolvedRouteIdentifiers>;
+/** The route AD navigates to: the resolved identifiers and the route values of the config. */
+export declare function toRouteConfig(identifiers: IResolvedRouteIdentifiers, config: IAnalyticalDesignerConfig): IAdEmbeddedRouteConfig;
+/**
+ * The theme AD applies: the theme of the props, else the loaded one, changed by the modifier. With
+ * theme loading disabled and no theme in the props, an empty theme stops AD from loading one itself.
+ */
+export declare function resolveTheme({ theme, disableThemeLoading, themeModifier }: IAnalyticalDesignerProps, loadedTheme: ITheme | undefined): ITheme | undefined;
+/** AD's bootstrap data loaded from the backend, with the values the config provides applied on top. */
+export declare function applyConfigToBootstrapData(data: IBootstrapData, config: IAnalyticalDesignerConfig, theme: ITheme | undefined): IBootstrapData;
+/**
+ * The callbacks AD delivers its events to: the typed callbacks of the props, then the catch-all, the
+ * event handlers and onMetricsChanged, which has no typed event of its own.
+ */
+export declare function toEmbeddedCallbacks(props: IAnalyticalDesignerProps): IAdEmbeddedCallbacks;
+//# sourceMappingURL=analyticalDesignerConfig.d.ts.map

package/esm/embedding/analyticalDesignerConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyticalDesignerConfig.d.ts","sourceRoot":"","sources":["../../src/embedding/analyticalDesignerConfig.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EACH,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,MAAM,EAKd,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAGxE,OAAO,EAAE,KAAK,yBAAyB,EAAE,KAAK,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAC7G,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEnE,qGAAqG;AACrG,MAAM,WAAW,yBAAyB;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,8FAA8F;AAC9F,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAWrF;AAED,0EAA0E;AAC1E,wBAAsB,wBAAwB,CAC1C,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAC/C,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAe7B;AAED,wGAAwG;AACxG,wBAAsB,0BAA0B,CAC5C,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GACpC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAY7B;AAED,yDAAyD;AACzD,wBAAsB,uBAAuB,CACzC,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,wBAAwB,CAAC,SAAS,CAAC,EAC5C,MAAM,EAAE,yBAAyB,GAClC,OAAO,CAAC,yBAAyB,CAAC,CAOpC;AAED,8FAA8F;AAC9F,wBAAgB,aAAa,CACzB,WAAW,EAAE,yBAAyB,EACtC,MAAM,EAAE,yBAAyB,GAClC,sBAAsB,CAexB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CACxB,EAAE,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,EAAE,wBAAwB,EACvE,WAAW,EAAE,MAAM,GAAG,SAAS,GAChC,MAAM,GAAG,SAAS,CAGpB;AAED,uGAAuG;AACvG,wBAAgB,0BAA0B,CACtC,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,yBAAyB,EACjC,KAAK,EAAE,MAAM,GAAG,SAAS,GAC1B,cAAc,CAwBhB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,GAAG,oBAAoB,CA+BzF"}