@notionhq/custom-blocks-host 0.1.31 → 0.2.0

package/src/lifecycle/initializationController.ts

@@ -1,56 +1,34 @@
-import type { NotionContrastMode } from "@notionhq/custom-blocks-protocol/contrast.js"
-import type { NotionBlockId } from "@notionhq/custom-blocks-protocol/ids.js"
-import type { CustomBlockManifest } from "@notionhq/custom-blocks-protocol/manifest.js"
+import { DEFAULT_CONTRAST_MODE } from "@notionhq/custom-blocks-protocol/contrast.js"
 import type { ConnectMessage } from "@notionhq/custom-blocks-protocol/messages/connect.js"
 import type {
 	CustomBlockInitErrorInfo,
 	InitMessage,
 } from "@notionhq/custom-blocks-protocol/messages/init.js"
 import type { InitResultMessage } from "@notionhq/custom-blocks-protocol/messages/initResult.js"
-import type { CustomBlockPage } from "@notionhq/custom-blocks-protocol/pages/page.js"
-import type { NotionParent } from "@notionhq/custom-blocks-protocol/parent.js"
-import type { NotionTheme } from "@notionhq/custom-blocks-protocol/theme.js"
-import type { NotionUser } from "@notionhq/custom-blocks-protocol/users/user.js"
 import type { CustomBlockHostFailure } from "../messages/types.js"
+import { unreachable } from "../utils.js"
 import { initErrorForFailureReason } from "./initErrors.js"
 import { isValidBridgeProtocolVersion } from "./protocolVersion.js"
 import type {
 	ConnectSuccessMessage,
-	CustomBlockHostDataSourcesPayload,
+	CustomBlockHostInitialStateResult,
 	InitStatus,
 } from "./types.js"
 
 const DEFAULT_NO_CONNECT_TIMEOUT_MS = 5_000
+const DEFAULT_INITIAL_STATE_TIMEOUT_MS = 5_000
 const DEFAULT_NO_INIT_RESULT_TIMEOUT_MS = 5_000
 
-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
+	prepareInit: (
+		connect: ConnectSuccessMessage,
+	) => Promise<CustomBlockHostInitialStateResult>
 	sendInitMessage: (message: InitMessage) => void
 	warn: (payload: unknown) => void
 	flushPendingHostStateChanges: () => void
 	minBridgeProtocolVersion: number
 	noConnectTimeoutMs?: number
+	initialStateTimeoutMs?: number
 	noInitResultTimeoutMs?: number
 	stopHostWithFailure: (error: CustomBlockHostFailure) => void
 	onInitResult?: (message: InitResultMessage) => void
@@ -79,14 +57,13 @@ export function createInitializationController(
 	options: InitializationControllerOptions,
 ): InitializationController {
 	const {
-		blockId,
-		getState,
 		prepareInit,
 		sendInitMessage,
 		warn,
 		flushPendingHostStateChanges,
 		minBridgeProtocolVersion,
 		noConnectTimeoutMs = DEFAULT_NO_CONNECT_TIMEOUT_MS,
+		initialStateTimeoutMs = DEFAULT_INITIAL_STATE_TIMEOUT_MS,
 		noInitResultTimeoutMs = DEFAULT_NO_INIT_RESULT_TIMEOUT_MS,
 		stopHostWithFailure,
 		onInitResult,
@@ -95,6 +72,7 @@ export function createInitializationController(
 
 	let initStatus: InitStatus = "waitingForConnect"
 	let noConnectTimeoutId: number | undefined
+	let initialStateTimeoutId: number | undefined
 	let noInitResultTimeoutId: number | undefined
 	let activeInitializationId: string | undefined
 	let hasObservedIframeLoad = false
@@ -107,6 +85,13 @@ export function createInitializationController(
 		}
 	}
 
+	function clearInitialStateTimeout() {
+		if (initialStateTimeoutId !== undefined) {
+			window.clearTimeout(initialStateTimeoutId)
+			initialStateTimeoutId = undefined
+		}
+	}
+
 	function clearNoInitResultTimeout() {
 		if (noInitResultTimeoutId !== undefined) {
 			window.clearTimeout(noInitResultTimeoutId)
@@ -119,12 +104,22 @@ export function createInitializationController(
 		error: CustomBlockInitErrorInfo
 	}) {
 		const { initializationId, error } = args
-		if (initStatus !== "waitingForConnect") {
-			return
+		switch (initStatus) {
+			case "waitingForConnect":
+			case "preparingInit":
+				break
+			case "waitingForInitResult":
+			case "initialized":
+			case "error":
+			case "stopped":
+				return
+			default:
+				return unreachable(initStatus)
 		}
 		initStatus = "error"
 		activeInitializationId = initializationId
 		clearNoConnectTimeout()
+		clearInitialStateTimeout()
 		sendInitMessage({
 			type: "init",
 			initializationId,
@@ -134,54 +129,79 @@ export function createInitializationController(
 		onFailure?.(error)
 	}
 
-	function prepareAndSendInit(connect: ConnectSuccessMessage): boolean {
-		if (initStatus !== "waitingForConnect") {
-			return false
-		}
-		const preparation = prepareInit(connect)
-		// The embedder can stop the host when it receives the manifest.
-		// If that happens, do not continue initialization or start its timer.
+	async function prepareAndSendInit(connect: ConnectSuccessMessage) {
 		if (initStatus !== "waitingForConnect") {
-			return false
-		}
-		if (preparation.status === "error") {
-			sendInitError({
-				initializationId: connect.initializationId,
-				error: preparation.error,
-			})
-			return false
+			return
 		}
-		initStatus = "waitingForInitResult"
+		initStatus = "preparingInit"
 		activeInitializationId = connect.initializationId
 		clearNoConnectTimeout()
-		const state = getState()
-		const message: InitMessage = {
-			type: "init",
-			initializationId: connect.initializationId,
-			status: "success",
-			theme: state.theme,
-			contrastMode: state.contrastMode,
-			blockId,
-			parent: state.parent,
-			page: state.page,
-			manifest: preparation.manifest,
-			dataSources: preparation.dataSources,
-			currentUser: state.currentUser,
-		}
-		sendInitMessage(message)
-		noInitResultTimeoutId = window.setTimeout(() => {
-			if (initStatus !== "waitingForInitResult") {
+		initialStateTimeoutId = window.setTimeout(() => {
+			if (initStatus !== "preparingInit") {
 				return
 			}
-			initStatus = "error"
-			const error = initErrorForFailureReason("no_init_result")
+			const error = initErrorForFailureReason("initial_state_timeout")
 			warn({
-				message: "Sandbox did not send initResult",
+				...error,
 				initializationId: connect.initializationId,
 			})
-			onFailure?.(error)
-		}, noInitResultTimeoutMs)
-		return true
+			sendInitError({ initializationId: connect.initializationId, error })
+		}, initialStateTimeoutMs)
+
+		try {
+			const preparation = await prepareInit(connect)
+			if (initStatus !== "preparingInit") {
+				return
+			}
+			clearInitialStateTimeout()
+			if (preparation.status === "error") {
+				sendInitError({
+					initializationId: connect.initializationId,
+					error: preparation.error,
+				})
+				return
+			}
+			initStatus = "waitingForInitResult"
+			const message: InitMessage = {
+				type: "init",
+				initializationId: connect.initializationId,
+				status: "success",
+				theme: preparation.initialState.theme,
+				contrastMode:
+					preparation.initialState.contrastMode ?? DEFAULT_CONTRAST_MODE,
+				blockId: preparation.initialState.blockId,
+				parent: preparation.initialState.parent,
+				page: preparation.initialState.page,
+				currentUser: preparation.initialState.currentUser,
+				manifest: preparation.initialState.manifest,
+				dataSources: preparation.initialState.dataSources,
+			}
+			sendInitMessage(message)
+			noInitResultTimeoutId = window.setTimeout(() => {
+				if (initStatus !== "waitingForInitResult") {
+					return
+				}
+				initStatus = "error"
+				const error = initErrorForFailureReason("no_init_result")
+				onFailure?.(error)
+				warn({
+					...error,
+					initializationId: connect.initializationId,
+				})
+			}, noInitResultTimeoutMs)
+		} catch (error) {
+			if (initStatus !== "preparingInit") {
+				return
+			}
+			warn({
+				message: "Failed to prepare custom block initialization",
+				error,
+			})
+			sendInitError({
+				initializationId: connect.initializationId,
+				error: initErrorForFailureReason("unknown_error"),
+			})
+		}
 	}
 
 	function handleConnect(message: ConnectMessage) {
@@ -227,9 +247,8 @@ export function createInitializationController(
 			return
 		}
 
-		if (prepareAndSendInit(message)) {
-			hasConnectedSandbox = true
-		}
+		hasConnectedSandbox = true
+		void prepareAndSendInit(message)
 	}
 
 	function handleInvalidConnect(args: {
@@ -327,11 +346,10 @@ export function createInitializationController(
 			return
 		}
 		clearNoInitResultTimeout()
+		initStatus = message.status === "success" ? "initialized" : "error"
 		if (message.status === "success") {
-			initStatus = "initialized"
 			flushPendingHostStateChanges()
 		} else {
-			initStatus = "error"
 			onFailure?.(message.error)
 		}
 		onInitResult?.(message)
@@ -340,6 +358,7 @@ export function createInitializationController(
 	function stop() {
 		initStatus = "stopped"
 		clearNoConnectTimeout()
+		clearInitialStateTimeout()
 		clearNoInitResultTimeout()
 	}
 

package/src/lifecycle/types.ts

@@ -3,6 +3,7 @@ import type { NotionDataSourceBindings } from "@notionhq/custom-blocks-protocol/
 import type { NotionBlockId } from "@notionhq/custom-blocks-protocol/ids.js"
 import type { CustomBlockManifest } from "@notionhq/custom-blocks-protocol/manifest.js"
 import type { ConnectMessage } from "@notionhq/custom-blocks-protocol/messages/connect.js"
+import type { CustomBlockInitErrorInfo } from "@notionhq/custom-blocks-protocol/messages/init.js"
 import type { CustomBlockPage } from "@notionhq/custom-blocks-protocol/pages/page.js"
 import type { NotionParent } from "@notionhq/custom-blocks-protocol/parent.js"
 import type { NotionTheme } from "@notionhq/custom-blocks-protocol/theme.js"
@@ -17,6 +18,8 @@ export type ConnectSuccessMessage = Extract<
 export type InitStatus =
 	/** The host is waiting for the sandbox's first `connect` message. */
 	| "waitingForConnect"
+	/** The host is waiting for `getInitialState` to prepare `init`. */
+	| "preparingInit"
 	/** The host is waiting for a matching `initResult` after it sends `init`. */
 	| "waitingForInitResult"
 	/** The host is initialized and can send live updates. */
@@ -30,10 +33,6 @@ export type CustomBlockHostDataSourcesPayload = {
 	bindings: NotionDataSourceBindings
 }
 
-export type CustomBlockHostInitialDataSources =
-	| CustomBlockHostDataSourcesPayload
-	| ((connect: ConnectSuccessMessage) => CustomBlockHostDataSourcesPayload)
-
 export type CustomBlockHostInitialState = {
 	theme: NotionTheme
 	/**
@@ -44,11 +43,21 @@ export type CustomBlockHostInitialState = {
 	blockId: NotionBlockId
 	parent: NotionParent
 	page: CustomBlockPage
-	/**
-	 * The host's persisted manifest, when one exists. If omitted, the host
-	 * requires the sandbox to provide a manifest in `connect`.
-	 */
-	manifest?: CustomBlockManifest
-	dataSources: CustomBlockHostInitialDataSources
+	manifest: CustomBlockManifest
+	dataSources: CustomBlockHostDataSourcesPayload
 	currentUser: NotionUser
 }
+
+export type CustomBlockHostInitialStateResult =
+	| {
+			status: "success"
+			initialState: CustomBlockHostInitialState
+	  }
+	| {
+			status: "error"
+			error: CustomBlockInitErrorInfo
+	  }
+
+export type CustomBlockHostGetInitialState = (
+	connect: ConnectSuccessMessage,
+) => Promise<CustomBlockHostInitialStateResult>