@notionhq/custom-blocks-host 0.0.1

package/dist/createCustomBlockHost.js

@@ -0,0 +1,433 @@
+import { DEFAULT_CONTRAST_MODE, } from "./protocol/contrast.js";
+import { sandboxToHostMessageSchema } from "./protocol/messages/sandboxToHost.js";
+import { CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION } from "./protocol/protocolVersion.js";
+import * as v from "valibot";
+import { initErrorForFailureReason } from "./lifecycle/initErrors.js";
+import { createInitializationController } from "./lifecycle/initializationController.js";
+import { getInvalidSandboxMessageResponse } from "./messages/invalidSandboxMessage.js";
+import { QuerySubscriptions, } from "./queries/querySubscriptions.js";
+import { validateQueryDataSourceFilter } from "./queries/validateQueryDataSourceFilter.js";
+import { validateQueryDataSourceSorts } from "./queries/validateQueryDataSourceSorts.js";
+import { unreachable } from "./utils.js";
+const initializationIdentitySchema = v.object({
+    initializationId: v.string(),
+});
+export function createCustomBlockHost(options) {
+    const { iframe, initialState, handlers, onConnect, onInitResult, onIgnoredConnect, onLog, sandboxOrigin, minBridgeProtocolVersion: configuredMinBridgeProtocolVersion, noConnectTimeoutMs, noInitResultTimeoutMs, } = options;
+    const minBridgeProtocolVersion = Math.max(configuredMinBridgeProtocolVersion ?? CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION, CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION);
+    let theme = initialState.theme;
+    let contrastMode = initialState.contrastMode ?? DEFAULT_CONTRAST_MODE;
+    let parent = initialState.parent;
+    let page = initialState.page;
+    let dataSources = initialState.dataSources;
+    let activeDataSources;
+    let manifest = initialState.manifest;
+    let currentUser = initialState.currentUser;
+    let pendingThemeChange = false;
+    let pendingContrastModeChange = false;
+    let pendingParentChange = false;
+    let pendingPageChange = false;
+    let pendingDataSourcesChange;
+    let pendingCurrentUserChange = false;
+    const querySubscriptions = new QuerySubscriptions();
+    function emit(direction, payload) {
+        onLog?.(direction, payload);
+    }
+    function post(message) {
+        emit("out", message);
+        iframe.contentWindow?.postMessage(message, sandboxOrigin);
+    }
+    function postQueryDataSourceResult(args) {
+        const message = args.response.status === "error"
+            ? {
+                type: "queryDataSourceResult",
+                subscriptionId: args.subscriptionId,
+                status: "error",
+                error: args.response.error,
+            }
+            : {
+                type: "queryDataSourceResult",
+                subscriptionId: args.subscriptionId,
+                status: "success",
+                items: args.response.items,
+                hasMore: args.response.hasMore,
+            };
+        post(message);
+    }
+    async function handleQuery(message, token = querySubscriptions.track(message)) {
+        const collectionSchema = getCollectionSchema(activeDataSources, message.dataSourceId);
+        const filterError = validateQueryDataSourceFilter(message.filter, collectionSchema);
+        if (filterError !== undefined) {
+            if (querySubscriptions.isCurrent(message.subscriptionId, token)) {
+                postQueryDataSourceResult({
+                    subscriptionId: message.subscriptionId,
+                    response: { status: "error", error: filterError },
+                });
+            }
+            return;
+        }
+        const sortError = validateQueryDataSourceSorts(message.sorts, collectionSchema);
+        if (sortError !== undefined) {
+            if (querySubscriptions.isCurrent(message.subscriptionId, token)) {
+                postQueryDataSourceResult({
+                    subscriptionId: message.subscriptionId,
+                    response: { status: "error", error: sortError },
+                });
+            }
+            return;
+        }
+        const response = await handlers.queryDataSource(message);
+        if (!querySubscriptions.isCurrent(message.subscriptionId, token)) {
+            return;
+        }
+        postQueryDataSourceResult({
+            subscriptionId: message.subscriptionId,
+            response,
+        });
+    }
+    async function handleCreatePage(message) {
+        if (handlers.createPage === undefined) {
+            return;
+        }
+        const response = await handlers.createPage(message);
+        const result = {
+            type: "createPageResult",
+            requestId: message.requestId,
+            ...response,
+        };
+        post(result);
+    }
+    async function handleGetPage(message) {
+        if (handlers.getPage === undefined) {
+            return;
+        }
+        const response = await handlers.getPage(message);
+        const result = {
+            type: "getPageResult",
+            requestId: message.requestId,
+            ...response,
+        };
+        post(result);
+    }
+    async function handleGetUser(message) {
+        if (handlers.getUser === undefined) {
+            return;
+        }
+        const response = await handlers.getUser(message);
+        const result = {
+            type: "getUserResult",
+            requestId: message.requestId,
+            ...response,
+        };
+        post(result);
+    }
+    async function handleListUsers(message) {
+        if (handlers.listUsers === undefined) {
+            return;
+        }
+        const response = await handlers.listUsers(message);
+        const result = {
+            type: "listUsersResult",
+            requestId: message.requestId,
+            ...response,
+        };
+        post(result);
+    }
+    async function handleUpdatePage(message) {
+        if (handlers.updatePage === undefined) {
+            return;
+        }
+        const response = await handlers.updatePage(message);
+        const result = {
+            type: "updatePageResult",
+            requestId: message.requestId,
+            ...response,
+        };
+        post(result);
+    }
+    /**
+     * Sends any pending host state changes to the sandbox. It is possible for these to change
+     * between when the host sends `init` and when the sandbox responds with `initResult`. The host
+     * does send any pending state changes until hearing back from the sandbox.
+     */
+    function flushPendingHostStateChanges() {
+        if (pendingThemeChange) {
+            pendingThemeChange = false;
+            post({ type: "themeChanged", theme });
+        }
+        if (pendingContrastModeChange) {
+            pendingContrastModeChange = false;
+            post({ type: "contrastModeChanged", contrastMode });
+        }
+        if (pendingParentChange) {
+            pendingParentChange = false;
+            post({ type: "parentChanged", parent });
+        }
+        if (pendingPageChange) {
+            pendingPageChange = false;
+            post({ type: "pageChanged", page });
+        }
+        if (pendingDataSourcesChange !== undefined) {
+            const nextDataSources = pendingDataSourcesChange;
+            pendingDataSourcesChange = undefined;
+            post({ type: "dataSourcesChanged", dataSources: nextDataSources });
+        }
+        if (pendingCurrentUserChange) {
+            pendingCurrentUserChange = false;
+            post({ type: "currentUserChanged", currentUser });
+        }
+    }
+    const initializationController = createInitializationController({
+        blockId: initialState.blockId,
+        getState: () => ({
+            theme,
+            contrastMode,
+            parent,
+            page,
+            currentUser,
+        }),
+        prepareInit(connect) {
+            manifest = connect.manifest ?? initialState.manifest;
+            const resolvedDataSources = typeof dataSources === "function" ? dataSources(connect) : dataSources;
+            const bindingErrorCode = getBindingErrorCode(manifest, resolvedDataSources);
+            if (bindingErrorCode !== undefined) {
+                return {
+                    status: "error",
+                    error: initErrorForFailureReason(bindingErrorCode),
+                };
+            }
+            activeDataSources = resolvedDataSources;
+            return {
+                status: "success",
+                manifest,
+                dataSources: resolvedDataSources,
+            };
+        },
+        post,
+        warn: payload => emit("warn", payload),
+        flushPendingHostStateChanges,
+        minBridgeProtocolVersion,
+        noConnectTimeoutMs,
+        noInitResultTimeoutMs,
+        onConnect,
+        onInitResult,
+        onIgnoredConnect,
+    });
+    function onInvalidSandboxMessage(data, issues) {
+        emit("warn", {
+            message: "Ignored unsupported sandbox message",
+            payload: data,
+            issues,
+        });
+        const response = getInvalidSandboxMessageResponse(data);
+        const parsedIdentity = v.safeParse(initializationIdentitySchema, data);
+        const initializationId = parsedIdentity.success
+            ? parsedIdentity.output.initializationId
+            : undefined;
+        if (response.incomingType === "connect" &&
+            initializationId !== undefined &&
+            initializationController.handleInvalidConnect(initializationId)) {
+            return;
+        }
+        if (response.incomingType === "initResult" &&
+            initializationController.handleInvalidInitResult()) {
+            if (response.nack !== undefined) {
+                post(response.nack);
+            }
+            return;
+        }
+        if (response.nack !== undefined) {
+            post(response.nack);
+        }
+    }
+    function onMessage(event) {
+        // Ignore messages from windows other than this host's iframe.
+        if (event.source !== iframe.contentWindow) {
+            return;
+        }
+        // Ignore messages that do not come from the configured sandbox origin.
+        if (event.origin !== sandboxOrigin) {
+            return;
+        }
+        const parsed = v.safeParse(sandboxToHostMessageSchema, event.data);
+        if (!parsed.success) {
+            onInvalidSandboxMessage(event.data, parsed.issues);
+            return;
+        }
+        const message = parsed.output;
+        emit("in", message);
+        if (message.type !== "connect" &&
+            message.type !== "initResult" &&
+            initializationController.status !== "success") {
+            // The SDK reports resize as soon as it renders, before the
+            // handshake completes, so an early resize is routine.
+            if (message.type !== "resize") {
+                emit("warn", {
+                    message: `Ignored ${message.type} before initialization completed`,
+                    payload: message,
+                });
+            }
+            return;
+        }
+        switch (message.type) {
+            case "connect":
+                initializationController.handleConnect(message);
+                return;
+            case "initResult":
+                initializationController.handleInitResult(message);
+                return;
+            case "queryDataSource":
+                void handleQuery(message);
+                return;
+            case "createPage":
+                void handleCreatePage(message);
+                return;
+            case "getPage":
+                void handleGetPage(message);
+                return;
+            case "getUser":
+                void handleGetUser(message);
+                return;
+            case "listUsers":
+                void handleListUsers(message);
+                return;
+            case "updatePage":
+                void handleUpdatePage(message);
+                return;
+            case "resize":
+                handlers.resize?.(message);
+                return;
+            case "invalidHostMessage":
+                return;
+            default:
+                unreachable(message);
+        }
+    }
+    window.addEventListener("message", onMessage);
+    iframe.addEventListener("load", initializationController.onIframeLoad);
+    return {
+        stop() {
+            window.removeEventListener("message", onMessage);
+            iframe.removeEventListener("load", initializationController.onIframeLoad);
+            initializationController.stop();
+            querySubscriptions.clear();
+        },
+        post,
+        setTheme(nextTheme) {
+            theme = nextTheme;
+            if (initializationController.status !== "success") {
+                if (initializationController.status === "waitingForInitResult") {
+                    pendingThemeChange = true;
+                }
+                return;
+            }
+            const message = { type: "themeChanged", theme };
+            post(message);
+        },
+        setContrastMode(nextContrastMode) {
+            contrastMode = nextContrastMode;
+            if (initializationController.status !== "success") {
+                if (initializationController.status === "waitingForInitResult") {
+                    pendingContrastModeChange = true;
+                }
+                return;
+            }
+            const message = {
+                type: "contrastModeChanged",
+                contrastMode,
+            };
+            post(message);
+        },
+        setParent(nextParent) {
+            parent = nextParent;
+            if (initializationController.status !== "success") {
+                if (initializationController.status === "waitingForInitResult") {
+                    pendingParentChange = true;
+                }
+                return;
+            }
+            const message = { type: "parentChanged", parent };
+            post(message);
+        },
+        setPage(nextPage) {
+            page = nextPage;
+            if (initializationController.status !== "success") {
+                if (initializationController.status === "waitingForInitResult") {
+                    pendingPageChange = true;
+                }
+                return;
+            }
+            const message = { type: "pageChanged", page };
+            post(message);
+        },
+        setDataSources(nextDataSources) {
+            if (initializationController.hasConnectedSandbox &&
+                getBindingErrorCode(manifest, nextDataSources) !== undefined) {
+                emit("warn", {
+                    message: "Ignored invalid data source bindings update",
+                    payload: nextDataSources,
+                });
+                return;
+            }
+            dataSources = nextDataSources;
+            activeDataSources = nextDataSources;
+            if (initializationController.status !== "success") {
+                if (initializationController.status === "waitingForInitResult") {
+                    pendingDataSourcesChange = nextDataSources;
+                }
+                return;
+            }
+            const message = {
+                type: "dataSourcesChanged",
+                dataSources: nextDataSources,
+            };
+            post(message);
+        },
+        setCurrentUser(nextCurrentUser) {
+            currentUser = nextCurrentUser;
+            if (initializationController.status !== "success") {
+                if (initializationController.status === "waitingForInitResult") {
+                    pendingCurrentUserChange = true;
+                }
+                return;
+            }
+            post({ type: "currentUserChanged", currentUser });
+        },
+        refreshQuery({ dataSourceId }) {
+            if (initializationController.status !== "success") {
+                return;
+            }
+            const refreshes = querySubscriptions.refresh(dataSourceId);
+            if (refreshes.length === 0) {
+                emit("warn", `No active query exists for data source "${dataSourceId}"`);
+                return;
+            }
+            for (const refresh of refreshes) {
+                void handleQuery(refresh.message, refresh.token);
+            }
+        },
+    };
+}
+function getCollectionSchema(dataSources, dataSourceId) {
+    return Object.values(dataSources?.bindings ?? {}).find(binding => binding.collectionPointer?.id === dataSourceId)?.collectionSchema;
+}
+function getBindingErrorCode(manifest, dataSources) {
+    for (const [dataSourceKey, manifestDataSource] of Object.entries(manifest.dataSources)) {
+        const binding = dataSources.bindings[dataSourceKey];
+        if (binding?.collectionPointer === undefined ||
+            binding.collectionSchema === undefined) {
+            return "missing_data_source_binding";
+        }
+        for (const [propertyKey, manifestProperty] of Object.entries(manifestDataSource.properties ?? {})) {
+            const propertyId = binding.propertyIdsByKey?.[propertyKey];
+            if (propertyId === undefined) {
+                return "missing_property_binding";
+            }
+            if (binding.collectionSchema.propertiesById[propertyId]?.type !==
+                manifestProperty.type) {
+                return "invalid_property_binding";
+            }
+        }
+    }
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { type AutoBindableProperty, getAutoBoundPropertyIdsByKey, } from "./autoBindProperties.js";
+export { type CustomBlockHostHandle, type CustomBlockHostOptions, createCustomBlockHost, } from "./createCustomBlockHost.js";
+export type { ConnectSuccessMessage, CustomBlockHostDataSourcesPayload, CustomBlockHostInitialDataSources, CustomBlockHostInitialState, } from "./lifecycle/types.js";
+export type { CustomBlockHostCreatePageResult, CustomBlockHostGetPageResult, CustomBlockHostGetUserResult, CustomBlockHostHandlers, CustomBlockHostListUsersResult, CustomBlockHostLogDirection, CustomBlockHostUpdatePageResult, } from "./messages/types.js";
+export type { CustomBlockHostQueryDataSourceResult } from "./queries/types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,oBAAoB,EACzB,4BAA4B,GAC5B,MAAM,yBAAyB,CAAA;AAChC,OAAO,EACN,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,qBAAqB,GACrB,MAAM,4BAA4B,CAAA;AACnC,YAAY,EACX,qBAAqB,EACrB,iCAAiC,EACjC,iCAAiC,EACjC,2BAA2B,GAC3B,MAAM,sBAAsB,CAAA;AAC7B,YAAY,EACX,+BAA+B,EAC/B,4BAA4B,EAC5B,4BAA4B,EAC5B,uBAAuB,EACvB,8BAA8B,EAC9B,2BAA2B,EAC3B,+BAA+B,GAC/B,MAAM,qBAAqB,CAAA;AAC5B,YAAY,EAAE,oCAAoC,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { getAutoBoundPropertyIdsByKey, } from "./autoBindProperties.js";
+export { createCustomBlockHost, } from "./createCustomBlockHost.js";

package/dist/lifecycle/initErrors.d.ts

@@ -0,0 +1,13 @@
+import type { CustomBlockInitErrorCode, CustomBlockInitErrorInfo } from "../protocol/messages/init.js";
+/**
+ * Returns the error info for a given `init` failure code.
+ *
+ * `init` handshakes are one-shot: after an `init` error, this host instance will not answer another
+ * `connect` message. `isRetryable` means a fresh iframe / `init` attempt could plausibly succeed
+ * without changing block code or host configuration.
+ */
+export declare function initErrorForFailureReason(reason: CustomBlockInitErrorCode, data?: {
+    minBridgeProtocolVersion?: number;
+    currentBridgeProtocolVersion?: number;
+}): CustomBlockInitErrorInfo;
+//# sourceMappingURL=initErrors.d.ts.map

package/dist/lifecycle/initErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initErrors.d.ts","sourceRoot":"","sources":["../../src/lifecycle/initErrors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,wBAAwB,EACxB,wBAAwB,EACxB,MAAM,mDAAmD,CAAA;AAK1D;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACxC,MAAM,EAAE,wBAAwB,EAChC,IAAI,GAAE;IACL,wBAAwB,CAAC,EAAE,MAAM,CAAA;IACjC,4BAA4B,CAAC,EAAE,MAAM,CAAA;CAChC,GACJ,wBAAwB,CA+I1B"}

package/dist/lifecycle/initErrors.js

@@ -0,0 +1,152 @@
+const UNKNOWN_ERROR_MESSAGE = "Unexpected error while initializing custom block.";
+/**
+ * Returns the error info for a given `init` failure code.
+ *
+ * `init` handshakes are one-shot: after an `init` error, this host instance will not answer another
+ * `connect` message. `isRetryable` means a fresh iframe / `init` attempt could plausibly succeed
+ * without changing block code or host configuration.
+ */
+export function initErrorForFailureReason(reason, data = {}) {
+    switch (reason) {
+        case "no_connect":
+            return {
+                code: reason,
+                message: "Sandbox did not send a connect message.",
+                isRetryable: true,
+            };
+        case "invalid_connect_payload":
+            return {
+                code: reason,
+                message: "Sandbox sent an invalid connect message.",
+                // The sandbox must be updated to send a valid connect message.
+                isRetryable: false,
+            };
+        case "manifest_unavailable":
+            return {
+                code: reason,
+                message: "The custom block manifest is unavailable.",
+                isRetryable: true,
+            };
+        case "manifest_invalid":
+            return {
+                code: reason,
+                message: "Sandbox sent an invalid manifest.",
+                // The sandbox must be updated to a valid manifest.
+                isRetryable: false,
+            };
+        case "invalid_protocol_version": {
+            const versionText = data.currentBridgeProtocolVersion
+                ? `: ${data.currentBridgeProtocolVersion}`
+                : ".";
+            return {
+                code: reason,
+                message: `Sandbox reported an invalid bridge protocol version ${versionText}`,
+                // The sandbox must be updated to a supported protocol version.
+                isRetryable: false,
+            };
+        }
+        case "unsupported_protocol_version": {
+            const currentVersionText = data.currentBridgeProtocolVersion
+                ? `${data.currentBridgeProtocolVersion} `
+                : "";
+            const minVersionText = data.minBridgeProtocolVersion
+                ? ` Minimum supported version is ${data.minBridgeProtocolVersion}.`
+                : "";
+            return {
+                code: reason,
+                message: `Sandbox bridge protocol version ${currentVersionText}is not supported.${minVersionText}`,
+                // The sandbox must be updated to a supported protocol version.
+                isRetryable: false,
+            };
+        }
+        case "context_unavailable":
+            return {
+                code: reason,
+                message: "Host page context is unavailable.",
+                isRetryable: true,
+            };
+        case "current_user_unavailable":
+            return {
+                code: reason,
+                message: "Current user is unavailable.",
+                isRetryable: true,
+            };
+        case "missing_data_source_binding":
+            return {
+                code: reason,
+                message: "A required data source is not mapped.",
+                // Host configuration must be changed before this block can initialize.
+                isRetryable: false,
+            };
+        case "data_source_unavailable":
+            return {
+                code: reason,
+                message: "A mapped data source is unavailable.",
+                // This error combines some retryable errors (e.g. data source failed to load) with
+                // some non-retryable errors (e.g. data source does not exist or user does not have
+                // access). Fallback to assuming the error is retryable.
+                isRetryable: true,
+            };
+        case "missing_property_binding":
+            return {
+                code: reason,
+                message: "A required data source property is not mapped.",
+                // Host configuration must be changed before this block can initialize.
+                isRetryable: false,
+            };
+        case "invalid_property_binding":
+            return {
+                code: reason,
+                message: "A mapped data source property is missing or incompatible.",
+                // The bound property's schema must be updated or the binding must be updated to
+                // a property with a compatible schema.
+                isRetryable: false,
+            };
+        case "no_init_result":
+            return {
+                code: reason,
+                message: "Sandbox did not acknowledge initialization.",
+                isRetryable: true,
+            };
+        case "invalid_init_result_payload":
+            return {
+                code: reason,
+                message: "Sandbox sent an invalid initialization result.",
+                isRetryable: false,
+            };
+        case "invalid_init_bindings":
+            return {
+                code: reason,
+                message: "Sandbox rejected the host-provided data source bindings.",
+                isRetryable: false,
+            };
+        case "not_in_iframe":
+            return {
+                code: reason,
+                message: "<NotionCustomBlock> only works inside an iframe.",
+                // The block must be embedded in an iframe.
+                isRetryable: false,
+            };
+        case "init_timeout":
+            return {
+                code: reason,
+                message: "Host did not respond to init before the timeout.",
+                isRetryable: true,
+            };
+        case "unknown_error":
+            return {
+                code: reason,
+                message: UNKNOWN_ERROR_MESSAGE,
+                // Treat unknown errors as non-retryable.
+                isRetryable: false,
+            };
+        default:
+            console.warn(`Unexpected custom block init error: ${reason}`);
+            return {
+                code: reason,
+                message: UNKNOWN_ERROR_MESSAGE,
+                // Treat unknown error codes as non-retryable.
+                isRetryable: false,
+            };
+    }
+}

package/dist/lifecycle/initializationController.d.ts

@@ -0,0 +1,54 @@
+import type { NotionContrastMode } from "../protocol/contrast.js";
+import type { NotionBlockId } from "../protocol/ids.js";
+import type { CustomBlockManifest } from "../protocol/manifest.js";
+import type { ConnectMessage } from "../protocol/messages/connect.js";
+import type { HostToSandboxMessage } from "../protocol/messages/hostToSandbox.js";
+import type { CustomBlockInitErrorInfo } from "../protocol/messages/init.js";
+import type { InitResultMessage } from "../protocol/messages/initResult.js";
+import type { CustomBlockPage } from "../protocol/pages/page.js";
+import type { NotionParent } from "../protocol/parent.js";
+import type { NotionTheme } from "../protocol/theme.js";
+import type { NotionUser } from "../protocol/users/user.js";
+import type { ConnectSuccessMessage, CustomBlockHostDataSourcesPayload, InitStatus } from "./types.js";
+type InitializationState = {
+    theme: NotionTheme;
+    contrastMode: NotionContrastMode;
+    parent: NotionParent;
+    page: CustomBlockPage;
+    currentUser: NotionUser;
+};
+type InitializationPreparation = {
+    status: "success";
+    manifest: CustomBlockManifest;
+    dataSources: CustomBlockHostDataSourcesPayload;
+} | {
+    status: "error";
+    error: CustomBlockInitErrorInfo;
+};
+export type InitializationControllerOptions = {
+    blockId: NotionBlockId;
+    getState: () => InitializationState;
+    prepareInit: (connect: ConnectSuccessMessage) => InitializationPreparation;
+    post: (message: HostToSandboxMessage) => void;
+    warn: (payload: unknown) => void;
+    flushPendingHostStateChanges: () => void;
+    minBridgeProtocolVersion: number;
+    noConnectTimeoutMs?: number;
+    noInitResultTimeoutMs?: number;
+    onConnect?: (message: ConnectSuccessMessage) => void;
+    onInitResult?: (message: InitResultMessage) => void;
+    onIgnoredConnect?: (message: ConnectMessage) => void;
+};
+export type InitializationController = {
+    readonly status: InitStatus;
+    readonly hasConnectedSandbox: boolean;
+    handleConnect: (message: ConnectMessage) => void;
+    handleInitResult: (message: InitResultMessage) => void;
+    handleInvalidConnect: (initializationId: string) => boolean;
+    handleInvalidInitResult: () => boolean;
+    onIframeLoad: () => void;
+    stop: () => void;
+};
+export declare function createInitializationController(options: InitializationControllerOptions): InitializationController;
+export {};
+//# sourceMappingURL=initializationController.d.ts.map

package/dist/lifecycle/initializationController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializationController.d.ts","sourceRoot":"","sources":["../../src/lifecycle/initializationController.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAA;AACtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAA;AAC5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8CAA8C,CAAA;AACvF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sDAAsD,CAAA;AAC1F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4DAA4D,CAAA;AACtG,OAAO,KAAK,EACX,wBAAwB,EAExB,MAAM,mDAAmD,CAAA;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yDAAyD,CAAA;AAChG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gDAAgD,CAAA;AACrF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAA;AAC9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2CAA2C,CAAA;AAC5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gDAAgD,CAAA;AAGhF,OAAO,KAAK,EACX,qBAAqB,EACrB,iCAAiC,EACjC,UAAU,EACV,MAAM,YAAY,CAAA;AAKnB,KAAK,mBAAmB,GAAG;IAC1B,KAAK,EAAE,WAAW,CAAA;IAClB,YAAY,EAAE,kBAAkB,CAAA;IAChC,MAAM,EAAE,YAAY,CAAA;IACpB,IAAI,EAAE,eAAe,CAAA;IACrB,WAAW,EAAE,UAAU,CAAA;CACvB,CAAA;AAED,KAAK,yBAAyB,GAC3B;IACA,MAAM,EAAE,SAAS,CAAA;IACjB,QAAQ,EAAE,mBAAmB,CAAA;IAC7B,WAAW,EAAE,iCAAiC,CAAA;CAC7C,GACD;IACA,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,EAAE,wBAAwB,CAAA;CAC9B,CAAA;AAEJ,MAAM,MAAM,+BAA+B,GAAG;IAC7C,OAAO,EAAE,aAAa,CAAA;IACtB,QAAQ,EAAE,MAAM,mBAAmB,CAAA;IACnC,WAAW,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,yBAAyB,CAAA;IAC1E,IAAI,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAA;IAC7C,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IAChC,4BAA4B,EAAE,MAAM,IAAI,CAAA;IACxC,wBAAwB,EAAE,MAAM,CAAA;IAChC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,IAAI,CAAA;IACpD,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAA;IACnD,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAA;CACpD,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACtC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAA;IACrC,aAAa,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAA;IAChD,gBAAgB,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAA;IACtD,oBAAoB,EAAE,CAAC,gBAAgB,EAAE,MAAM,KAAK,OAAO,CAAA;IAC3D,uBAAuB,EAAE,MAAM,OAAO,CAAA;IACtC,YAAY,EAAE,MAAM,IAAI,CAAA;IACxB,IAAI,EAAE,MAAM,IAAI,CAAA;CAChB,CAAA;AAED,wBAAgB,8BAA8B,CAC7C,OAAO,EAAE,+BAA+B,GACtC,wBAAwB,CAyN1B"}