@notionhq/custom-blocks 0.1.6 → 0.1.8

package/dist/host/createCustomBlockHost.js

@@ -1,495 +0,0 @@
-import * as v from "valibot";
-import { DEFAULT_CONTRAST_MODE, } from "../bridge/contrast.js";
-import { sandboxToHostMessageSchema } from "../bridge/messages/sandboxToHost.js";
-import { CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION } from "../bridge/SandboxBridge.js";
-import { unreachable } from "../utils.js";
-import { initErrorForFailureReason } from "./lifecycle/initErrors.js";
-import { isValidBridgeProtocolVersion } from "./lifecycle/protocolVersion.js";
-import { getInvalidSandboxMessageResponse } from "./messages/invalidSandboxMessage.js";
-import { QuerySubscriptions } from "./queries/querySubscriptions.js";
-const DEFAULT_NO_CONNECT_TIMEOUT_MS = 5000;
-const DEFAULT_NO_INIT_RESULT_TIMEOUT_MS = 5000;
-const initializationIdentitySchema = v.object({
-    initializationId: v.string(),
-});
-export function createCustomBlockHost(options) {
-    const { iframe, initialState, handlers, onConnect, onInitResult, onLog, targetOrigin = "*", minBridgeProtocolVersion: configuredMinBridgeProtocolVersion, noConnectTimeoutMs = DEFAULT_NO_CONNECT_TIMEOUT_MS, noInitResultTimeoutMs = DEFAULT_NO_INIT_RESULT_TIMEOUT_MS, } = 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 manifest = initialState.manifest;
-    let currentUser = initialState.currentUser;
-    let initStatus = "waitingForConnect";
-    let noConnectTimeoutId;
-    let noInitResultTimeoutId;
-    let activeInitializationId;
-    let connectedSandbox;
-    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, targetOrigin);
-    }
-    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);
-    }
-    function clearNoConnectTimeout() {
-        if (noConnectTimeoutId !== undefined) {
-            window.clearTimeout(noConnectTimeoutId);
-            noConnectTimeoutId = undefined;
-        }
-    }
-    function clearNoInitResultTimeout() {
-        if (noInitResultTimeoutId !== undefined) {
-            window.clearTimeout(noInitResultTimeoutId);
-            noInitResultTimeoutId = undefined;
-        }
-    }
-    function resolveDataSourcesPayload(connect) {
-        return typeof dataSources === "function"
-            ? dataSources(connect)
-            : dataSources;
-    }
-    function sendInit(connect) {
-        if (initStatus !== "waitingForConnect") {
-            return false;
-        }
-        onConnect?.(connect);
-        manifest = connect.manifest ?? initialState.manifest;
-        const resolvedDataSources = resolveDataSourcesPayload(connect);
-        const bindingErrorCode = getBindingErrorCode(manifest, resolvedDataSources);
-        if (bindingErrorCode !== undefined) {
-            sendInitError(connect.initializationId, initErrorForFailureReason(bindingErrorCode));
-            return false;
-        }
-        initStatus = "waitingForInitResult";
-        activeInitializationId = connect.initializationId;
-        clearNoConnectTimeout();
-        const message = {
-            type: "init",
-            initializationId: connect.initializationId,
-            status: "success",
-            theme,
-            contrastMode,
-            blockId: initialState.blockId,
-            parent,
-            page,
-            manifest,
-            dataSources: resolvedDataSources,
-            currentUser,
-        };
-        post(message);
-        noInitResultTimeoutId = window.setTimeout(() => {
-            if (initStatus !== "waitingForInitResult") {
-                return;
-            }
-            initStatus = "error";
-            emit("warn", {
-                message: "Sandbox did not send initResult",
-                initializationId: connect.initializationId,
-            });
-        }, noInitResultTimeoutMs);
-        return true;
-    }
-    function sendInitError(initializationId, error) {
-        if (initStatus !== "waitingForConnect") {
-            return;
-        }
-        initStatus = "error";
-        activeInitializationId = initializationId;
-        clearNoConnectTimeout();
-        post({
-            type: "init",
-            initializationId,
-            status: "error",
-            error,
-        });
-    }
-    function onIframeLoad() {
-        clearNoConnectTimeout();
-        if (initStatus !== "waitingForConnect") {
-            // Only set the timeout if the iframe loaded before the `connect` message was sent.
-            return;
-        }
-        noConnectTimeoutId = window.setTimeout(() => {
-            if (initStatus !== "waitingForConnect") {
-                // Only do anything if the iframe loaded before the `connect` message was sent.
-                return;
-            }
-            initStatus = "error";
-            emit("warn", initErrorForFailureReason("no_connect"));
-        }, noConnectTimeoutMs);
-    }
-    async function handleQuery(message) {
-        const token = querySubscriptions.track(message);
-        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);
-    }
-    function handleConnect(message) {
-        // Verify the bridge protocol version is valid.
-        if (!isValidBridgeProtocolVersion(message.bridgeProtocolVersion)) {
-            const initError = initErrorForFailureReason("invalid_protocol_version", {
-                currentBridgeProtocolVersion: message.bridgeProtocolVersion,
-            });
-            sendInitError(message.initializationId, initError);
-            return;
-        }
-        if (message.bridgeProtocolVersion < minBridgeProtocolVersion) {
-            const initError = initErrorForFailureReason("unsupported_protocol_version", {
-                currentBridgeProtocolVersion: message.bridgeProtocolVersion,
-                minBridgeProtocolVersion,
-            });
-            sendInitError(message.initializationId, initError);
-            return;
-        }
-        // If the sandbox reported an error during `connect`, return it as an `init` error.
-        if (message.status === "error") {
-            sendInitError(message.initializationId, message.error);
-            return;
-        }
-        if (!sendInit(message)) {
-            return;
-        }
-        connectedSandbox = message;
-    }
-    /**
-     * 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 });
-        }
-    }
-    function handleInitResult(message) {
-        if (initStatus !== "waitingForInitResult" ||
-            message.initializationId !== activeInitializationId) {
-            emit("warn", {
-                message: "Ignored stale or unexpected initResult",
-                payload: message,
-            });
-            return;
-        }
-        clearNoInitResultTimeout();
-        initStatus = message.status === "success" ? "success" : "error";
-        if (initStatus === "success") {
-            flushPendingHostStateChanges();
-        }
-        onInitResult?.(message);
-    }
-    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 (initStatus === "waitingForConnect" &&
-            response.incomingType === "connect" &&
-            initializationId !== undefined) {
-            sendInitError(initializationId, initErrorForFailureReason("invalid_connect"));
-        }
-        else if (response.nack !== undefined) {
-            post(response.nack);
-        }
-    }
-    function onMessage(event) {
-        if (event.source !== iframe.contentWindow) {
-            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" &&
-            initStatus !== "success") {
-            emit("warn", {
-                message: `Ignored ${message.type} before initialization completed`,
-                payload: message,
-            });
-            return;
-        }
-        switch (message.type) {
-            case "connect":
-                handleConnect(message);
-                return;
-            case "initResult":
-                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", onIframeLoad);
-    return {
-        stop() {
-            window.removeEventListener("message", onMessage);
-            iframe.removeEventListener("load", onIframeLoad);
-            clearNoConnectTimeout();
-            clearNoInitResultTimeout();
-            querySubscriptions.clear();
-        },
-        post,
-        setTheme(nextTheme) {
-            theme = nextTheme;
-            if (initStatus !== "success") {
-                if (initStatus === "waitingForInitResult") {
-                    pendingThemeChange = true;
-                }
-                return;
-            }
-            const message = { type: "themeChanged", theme };
-            post(message);
-        },
-        setContrastMode(nextContrastMode) {
-            contrastMode = nextContrastMode;
-            if (initStatus !== "success") {
-                if (initStatus === "waitingForInitResult") {
-                    pendingContrastModeChange = true;
-                }
-                return;
-            }
-            const message = {
-                type: "contrastModeChanged",
-                contrastMode,
-            };
-            post(message);
-        },
-        setParent(nextParent) {
-            parent = nextParent;
-            if (initStatus !== "success") {
-                if (initStatus === "waitingForInitResult") {
-                    pendingParentChange = true;
-                }
-                return;
-            }
-            const message = { type: "parentChanged", parent };
-            post(message);
-        },
-        setPage(nextPage) {
-            page = nextPage;
-            if (initStatus !== "success") {
-                if (initStatus === "waitingForInitResult") {
-                    pendingPageChange = true;
-                }
-                return;
-            }
-            const message = { type: "pageChanged", page };
-            post(message);
-        },
-        setDataSources(nextDataSources) {
-            if (connectedSandbox !== undefined &&
-                getBindingErrorCode(manifest, nextDataSources) !== undefined) {
-                emit("warn", {
-                    message: "Ignored invalid data source bindings update",
-                    payload: nextDataSources,
-                });
-                return;
-            }
-            dataSources = nextDataSources;
-            if (initStatus !== "success") {
-                if (initStatus === "waitingForInitResult") {
-                    pendingDataSourcesChange = nextDataSources;
-                }
-                return;
-            }
-            const message = {
-                type: "dataSourcesChanged",
-                dataSources: nextDataSources,
-            };
-            post(message);
-        },
-        setCurrentUser(nextCurrentUser) {
-            currentUser = nextCurrentUser;
-            if (initStatus !== "success") {
-                if (initStatus === "waitingForInitResult") {
-                    pendingCurrentUserChange = true;
-                }
-                return;
-            }
-            post({ type: "currentUserChanged", currentUser });
-        },
-        refreshQuery({ dataSourceId, response }) {
-            if (initStatus !== "success") {
-                return;
-            }
-            const refreshes = querySubscriptions.resolveRefreshes({
-                dataSourceId,
-                response,
-            });
-            if (refreshes.length === 0) {
-                emit("warn", `No active query exists for data source "${dataSourceId}"`);
-                return;
-            }
-            for (const refresh of refreshes) {
-                postQueryDataSourceResult(refresh);
-            }
-        },
-    };
-}
-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/host/lifecycle/initErrors.d.ts

@@ -1,13 +0,0 @@
-import type { CustomBlockInitErrorCode, CustomBlockInitErrorInfo } from "../../bridge/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/host/lifecycle/initErrors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"initErrors.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/host/lifecycle/initErrors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,wBAAwB,EACxB,wBAAwB,EACxB,MAAM,+BAA+B,CAAA;AAKtC;;;;;;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/host/lifecycle/initErrors.js

@@ -1,152 +0,0 @@
-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":
-            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":
-            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/host/lifecycle/protocolVersion.d.ts

@@ -1,2 +0,0 @@
-export declare function isValidBridgeProtocolVersion(version: number): boolean;
-//# sourceMappingURL=protocolVersion.d.ts.map

package/dist/host/lifecycle/protocolVersion.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"protocolVersion.d.ts","sourceRoot":"","sources":["../../../../../home/runner/work/custom-blocks/custom-blocks/sdk/src/host/lifecycle/protocolVersion.ts"],"names":[],"mappings":"AAAA,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErE"}

package/dist/host/lifecycle/protocolVersion.js

@@ -1,3 +0,0 @@
-export function isValidBridgeProtocolVersion(version) {
-    return Number.isFinite(version) && Number.isInteger(version) && version >= 1;
-}