ncblock 0.0.1

package/dist/notion.js

@@ -0,0 +1,773 @@
+import * as v from "valibot";
+import { readIncomingType } from "./bridge/incomingType";
+import { manifestSchema } from "./bridge/manifest";
+import { hostToSandboxMessageSchema } from "./bridge/messages/hostToSandbox";
+import { notionPagePropertyValueSchema } from "./bridge/pages/page";
+import { PendingRequests } from "./bridge/pendingRequests";
+import { unreachable } from "./utils";
+/**
+ * Used to ensure that the host and client are using the same version of the bridge protocol. A
+ * single host needs to support multiple custom blocks built with different versions of the bridge
+ * protocol. Increment this number any time a breaking change is made to the bridge protocol.
+ */
+const CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION = 1;
+const MANIFEST_URL = "custom_blocks.json";
+/**
+ * Resolves a public SDK property write map into the ID-keyed bridge shape.
+ */
+function resolvePropertyWriteMapForDataSource(args) {
+    const { dataSource, properties, operationName } = args;
+    const resolvedProperties = {};
+    for (const [identifier, value] of Object.entries(properties)) {
+        const propertyIdResult = resolvePropertyIdentifierForDataSource({
+            dataSource,
+            identifier,
+            operationName,
+        });
+        if (propertyIdResult.status === "error") {
+            return propertyIdResult;
+        }
+        const propertyId = propertyIdResult.propertyId;
+        if (value.id !== undefined &&
+            value.id !== identifier &&
+            value.id !== propertyId) {
+            return {
+                status: "error",
+                error: `Property ${identifier} resolved to ${propertyId} but value id was ${value.id}.`,
+            };
+        }
+        if (resolvedProperties[propertyId] !== undefined) {
+            return {
+                status: "error",
+                error: `Cannot set property ${propertyId} more than once.`,
+            };
+        }
+        const parsedValue = v.safeParse(notionPagePropertyValueSchema, {
+            ...value,
+            id: propertyId,
+        });
+        if (!parsedValue.success) {
+            return {
+                status: "error",
+                error: `Invalid value for property ${identifier}.`,
+            };
+        }
+        resolvedProperties[propertyId] = parsedValue.output;
+    }
+    return { status: "success", properties: resolvedProperties };
+}
+/**
+ * Treats matching data-source keys as aliases for property IDs; all other identifiers are raw IDs.
+ */
+function resolvePropertyIdentifierForDataSource(args) {
+    const { dataSource, identifier, operationName } = args;
+    if (dataSource !== undefined && identifier in dataSource.propertyIdsByKey) {
+        const propertyId = dataSource.propertyIdsByKey[identifier];
+        if (propertyId === undefined) {
+            return {
+                status: "error",
+                error: `${operationName} cannot resolve property key "${identifier}" because it is not bound to a Notion property.`,
+            };
+        }
+        return { status: "success", propertyId };
+    }
+    return { status: "success", propertyId: identifier };
+}
+function createEmptyDataSourceQueryState() {
+    return {
+        items: [],
+        isLoading: false,
+        hasMore: false,
+    };
+}
+class NotionCustomBlockBridge {
+    constructor() {
+        this.hostState = {
+            status: "uninitialized",
+            theme: "light",
+        };
+        this.listeners = new Set();
+        this.nextRequestId = 1;
+        this.pendingCreatePage = new PendingRequests("custom-block-create-page");
+        this.pendingGetPage = new PendingRequests("custom-block-get-page");
+        this.pendingUpdatePage = new PendingRequests("custom-block-update-page");
+        this.initMessage = new Promise(resolve => {
+            this.resolveInit = resolve;
+        });
+        this.manifest = null;
+        this.notify = () => {
+            for (const listener of this.listeners) {
+                listener();
+            }
+        };
+        this.handleMessage = (event) => {
+            console.debug("[notion-custom-sdk] incoming postMessage", {
+                data: event.data,
+                fromParent: event.source === window.parent,
+            });
+            if (event.source !== window.parent) {
+                return;
+            }
+            const parsed = v.safeParse(hostToSandboxMessageSchema, event.data);
+            if (!parsed.success) {
+                console.warn("[notion-custom-sdk] ignoring malformed host message", parsed.issues);
+                const incomingType = readIncomingType(event.data);
+                // Loop guard: never NACK a NACK. Excludes both directions —
+                // `invalidSandboxMessage` is what the host normally sends, but
+                // a buggy host that echoes our own `invalidHostMessage` back
+                // would otherwise spin a NACK feedback loop.
+                if (incomingType !== "invalidSandboxMessage" &&
+                    incomingType !== "invalidHostMessage") {
+                    const nack = {
+                        type: "invalidHostMessage",
+                        reason: formatInvalidHostReason(incomingType, parsed.issues),
+                    };
+                    console.debug("[notion-custom-sdk] outbound postMessage", nack);
+                    window.parent.postMessage(nack, "*");
+                }
+                return;
+            }
+            const message = parsed.output;
+            // If the host couldn't parse one of our outbound sandbox-to-host messages, it sends back
+            // an `invalidSandboxMessage` NACK with a human-readable `reason`. Log it for developer
+            // visibility and stop. We don't retry as the sandbox can't recover from a host-side parse
+            // failure on its own.
+            if (message.type === "invalidSandboxMessage") {
+                console.warn("[notion-custom-sdk] host reported invalid sandbox message:", message.reason);
+                return;
+            }
+            // `init` is the only message valid before initialization. Handle it up
+            // front so every later case can assume `status === "initialized"`.
+            if (message.type === "init") {
+                this.applyInit(message);
+                return;
+            }
+            // Alias to keep TS's narrowed `InitializedHostState` across the switch
+            // below. Reading `this.hostState` repeatedly would re-widen it.
+            const hostState = this.hostState;
+            if (hostState.status !== "initialized") {
+                console.warn(`[notion-custom-sdk] ignoring ${message.type} before init`);
+                return;
+            }
+            switch (message.type) {
+                case "themeChanged": {
+                    this.hostState = {
+                        ...hostState,
+                        theme: message.theme,
+                    };
+                    this.notify();
+                    return;
+                }
+                case "contextChanged": {
+                    this.hostState = {
+                        ...hostState,
+                        context: message.context,
+                    };
+                    this.notify();
+                    return;
+                }
+                case "dataSourcesChanged": {
+                    const dataSources = resolveDataSources({
+                        manifest: this.manifest,
+                        dataSourceBindings: message.dataSources.bindings,
+                    });
+                    // Drop cached query state for keys that no longer exist in the mapping.
+                    const nextKeys = new Set(dataSources.map(s => s.key));
+                    const prunedState = {};
+                    for (const [key, state] of Object.entries(hostState.dataSourceState)) {
+                        if (nextKeys.has(key)) {
+                            prunedState[key] = state;
+                        }
+                    }
+                    this.hostState = {
+                        ...hostState,
+                        dataSources,
+                        dataSourceState: prunedState,
+                    };
+                    this.notify();
+                    return;
+                }
+                case "createPageResult": {
+                    const result = message.status === "success"
+                        ? { status: "success", page: message.page }
+                        : { status: "error", error: message.error };
+                    if (!this.pendingCreatePage.resolve(message.requestId, result)) {
+                        console.warn(`[notion-custom-sdk] createPageResult for unknown requestId ${message.requestId}`);
+                    }
+                    return;
+                }
+                case "getPageResult": {
+                    const result = message.status === "success"
+                        ? { status: "success", page: message.page }
+                        : { status: "error", error: message.error };
+                    if (!this.pendingGetPage.resolve(message.requestId, result)) {
+                        console.warn(`[notion-custom-sdk] getPageResult for unknown requestId ${message.requestId}`);
+                    }
+                    return;
+                }
+                case "updatePageResult": {
+                    const result = message.status === "success"
+                        ? { status: "success", page: message.page }
+                        : { status: "error", error: message.error };
+                    if (!this.pendingUpdatePage.resolve(message.requestId, result)) {
+                        console.warn(`[notion-custom-sdk] updatePageResult for unknown requestId ${message.requestId}`);
+                    }
+                    return;
+                }
+                case "queryDataSourceResult": {
+                    const currentState = hostState.dataSourceState[message.key] ??
+                        createEmptyDataSourceQueryState();
+                    if (currentState.latestRequestId !== message.requestId) {
+                        return;
+                    }
+                    this.hostState = {
+                        ...hostState,
+                        dataSourceState: {
+                            ...hostState.dataSourceState,
+                            [message.key]: {
+                                items: message.items,
+                                isLoading: false,
+                                hasMore: message.hasMore,
+                                error: message.error,
+                                // Keep the request ID so later host-pushed refreshes for the
+                                // same subscription still match.
+                                latestRequestId: message.requestId,
+                            },
+                        },
+                    };
+                    this.notify();
+                    return;
+                }
+                default: {
+                    unreachable(message);
+                }
+            }
+        };
+        // `ready` is sent later by `initCustomBlock` (after the manifest fetch
+        // resolves). Top-level / no-iframe rejection is handled there too, so
+        // the constructor just attaches the listener.
+        if (typeof window !== "undefined") {
+            window.addEventListener("message", this.handleMessage);
+        }
+    }
+    awaitInit(signal) {
+        if (!signal) {
+            return this.initMessage;
+        }
+        return new Promise((resolve, reject) => {
+            if (signal.aborted) {
+                reject(signal.reason);
+                return;
+            }
+            const onAbort = () => reject(signal.reason);
+            signal.addEventListener("abort", onAbort, { once: true });
+            this.initMessage.then(message => {
+                signal.removeEventListener("abort", onAbort);
+                resolve(message);
+            }, err => {
+                signal.removeEventListener("abort", onAbort);
+                reject(err);
+            });
+        });
+    }
+    async sendReady(manifest) {
+        if (typeof window === "undefined") {
+            return;
+        }
+        this.manifest = manifest;
+        const readyMessage = {
+            type: "ready",
+            bridgeProtocolVersion: CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION,
+            manifest,
+        };
+        console.debug("[notion-custom-sdk] outbound postMessage", readyMessage);
+        window.parent.postMessage(readyMessage, "*");
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    getHostState() {
+        return this.hostState;
+    }
+    /**
+     * Apply an `init` payload as if it had arrived from the host. Lets callers
+     * seed the bridge directly (e.g. the React provider's standalone preview
+     * fallback) without going through `postMessage`. The bridge stays unaware
+     * of why it's being seeded.
+     */
+    setMockState(message) {
+        this.applyInit(message);
+    }
+    applyInit(message) {
+        const dataSources = resolveDataSources({
+            manifest: this.manifest,
+            dataSourceBindings: message.dataSources.bindings,
+        });
+        this.hostState = {
+            status: "initialized",
+            theme: message.theme,
+            context: message.context,
+            dataSources,
+            dataSourceState: {},
+        };
+        this.notify();
+        // Resolve the awaitInit promise once. Subsequent `init` messages
+        // (the host shouldn't send these, but be tolerant) update state but
+        // don't re-resolve.
+        if (this.resolveInit) {
+            this.resolveInit(message);
+            this.resolveInit = undefined;
+        }
+    }
+    queryDataSource(key, limit) {
+        if (this.hostState.status !== "initialized") {
+            return;
+        }
+        const currentState = this.hostState.dataSourceState[key] ?? createEmptyDataSourceQueryState();
+        if (currentState.isLoading) {
+            return;
+        }
+        const requestId = `custom-block-query-${this.nextRequestId}`;
+        this.nextRequestId += 1;
+        this.hostState = {
+            ...this.hostState,
+            dataSourceState: {
+                ...this.hostState.dataSourceState,
+                [key]: {
+                    ...currentState,
+                    isLoading: true,
+                    error: undefined,
+                    latestRequestId: requestId,
+                },
+            },
+        };
+        this.notify();
+        const outbound = {
+            type: "queryDataSource",
+            requestId,
+            key,
+            limit,
+        };
+        console.debug("[notion-custom-sdk] outbound postMessage", outbound);
+        window.parent.postMessage(outbound, "*");
+    }
+    postResize(height) {
+        if (typeof window === "undefined") {
+            return;
+        }
+        const safeHeight = Number.isFinite(height) && height >= 0 ? Math.ceil(height) : 0;
+        const outbound = {
+            type: "resize",
+            height: safeHeight,
+        };
+        console.debug("[notion-custom-sdk] outbound postMessage", outbound);
+        window.parent.postMessage(outbound, "*");
+    }
+    createPage(input) {
+        return new Promise(resolve => {
+            const resolvedParent = this.resolveCreatePageParent(input.parent);
+            if (resolvedParent.status === "error") {
+                resolve(resolvedParent);
+                return;
+            }
+            const resolvedProperties = resolvePropertyWriteMapForDataSource({
+                dataSource: resolvedParent.dataSource,
+                properties: input.properties,
+                operationName: "createPage",
+            });
+            if (resolvedProperties.status === "error") {
+                resolve(resolvedProperties);
+                return;
+            }
+            const requestId = this.pendingCreatePage.allocate(resolve);
+            const outbound = {
+                type: "createPage",
+                requestId,
+                parent: resolvedParent.parent,
+                properties: resolvedProperties.properties,
+            };
+            if (input.icon !== undefined) {
+                outbound.icon = input.icon;
+            }
+            if (input.cover !== undefined) {
+                outbound.cover = input.cover;
+            }
+            if (input.position !== undefined) {
+                outbound.position = input.position;
+            }
+            console.debug("[notion-custom-sdk] outbound postMessage", outbound);
+            window.parent.postMessage(outbound, "*");
+        });
+    }
+    getPage(pageId) {
+        return new Promise(resolve => {
+            const requestId = this.pendingGetPage.allocate(resolve);
+            const outbound = {
+                type: "getPage",
+                requestId,
+                pageId,
+            };
+            console.debug("[notion-custom-sdk] outbound postMessage", outbound);
+            window.parent.postMessage(outbound, "*");
+        });
+    }
+    updatePage(input) {
+        return new Promise(resolve => {
+            if ((input.properties === undefined ||
+                Object.keys(input.properties).length === 0) &&
+                input.icon === undefined &&
+                input.cover === undefined &&
+                input.archived === undefined) {
+                resolve({
+                    status: "error",
+                    error: "updatePage requires at least one of: properties, icon, cover, archived.",
+                });
+                return;
+            }
+            const requestId = this.pendingUpdatePage.allocate(resolve);
+            const outbound = {
+                type: "updatePage",
+                requestId,
+                pageId: input.pageId,
+            };
+            if (input.properties !== undefined) {
+                outbound.properties = input.properties;
+            }
+            if (input.icon !== undefined) {
+                outbound.icon = input.icon;
+            }
+            if (input.cover !== undefined) {
+                outbound.cover = input.cover;
+            }
+            if (input.archived !== undefined) {
+                outbound.archived = input.archived;
+            }
+            console.debug("[notion-custom-sdk] outbound postMessage", outbound);
+            window.parent.postMessage(outbound, "*");
+        });
+    }
+    /**
+     * Translates the public `CreatePageInput["parent"]` into the bridge-native
+     * `CreatePageMessageParent`. The `data_source_key` variant is resolved sandbox-side against
+     * the data source mapping the host delivered in `init` / `dataSourcesChanged`.
+     */
+    resolveCreatePageParent(parent) {
+        switch (parent.type) {
+            case "page_id":
+                return { status: "ok", parent, dataSource: undefined };
+            case "data_source_id": {
+                const dataSource = this.hostState.status === "initialized"
+                    ? this.hostState.dataSources.find(entry => entry.collectionPointer?.id === parent.data_source_id)
+                    : undefined;
+                return { status: "ok", parent, dataSource };
+            }
+            case "data_source_key": {
+                if (this.hostState.status !== "initialized") {
+                    return {
+                        status: "error",
+                        error: `Cannot resolve data source key "${parent.key}" before the host has initialized the SDK.`,
+                    };
+                }
+                const dataSource = this.hostState.dataSources.find(entry => entry.key === parent.key);
+                if (dataSource === undefined) {
+                    return {
+                        status: "error",
+                        error: `Unknown data source key "${parent.key}". Known keys: [${this.hostState.dataSources.map(entry => entry.key).join(", ")}].`,
+                    };
+                }
+                if (dataSource.collectionPointer === undefined) {
+                    return {
+                        status: "error",
+                        error: `Data source "${parent.key}" has not been mapped to a database yet.`,
+                    };
+                }
+                return {
+                    status: "ok",
+                    parent: {
+                        type: "data_source_id",
+                        data_source_id: dataSource.collectionPointer.id,
+                    },
+                    dataSource,
+                };
+            }
+            default:
+                unreachable(parent);
+        }
+    }
+}
+function resolveDataSources(args) {
+    if (args.manifest === null) {
+        return Object.entries(args.dataSourceBindings).map(([key, binding]) => ({
+            key,
+            collectionPointer: binding.collectionPointer,
+            collectionSchema: binding.collectionSchema,
+            propertyIdsByKey: { ...(binding.propertyIdsByKey ?? {}) },
+            propertySchemasById: binding.collectionSchema?.propertiesById ?? {},
+        }));
+    }
+    return Object.entries(args.manifest.dataSources).flatMap(([key, manifestDataSource]) => {
+        const binding = args.dataSourceBindings[key];
+        const propertySchemasById = binding?.collectionSchema?.propertiesById ?? {};
+        const bindingPropertyIdsByKey = binding?.propertyIdsByKey ?? {};
+        const propertyIdsByKey = {};
+        const manifestProperties = Object.entries(manifestDataSource.properties ?? {});
+        for (const [propertyKey, manifestProperty] of manifestProperties) {
+            const propertyId = propertyKey in bindingPropertyIdsByKey
+                ? bindingPropertyIdsByKey[propertyKey]
+                : findPropertyIdByManifestProperty(propertySchemasById, {
+                    key: propertyKey,
+                    type: manifestProperty.type,
+                });
+            const propertySchema = propertyId === undefined ? undefined : propertySchemasById[propertyId];
+            propertyIdsByKey[propertyKey] =
+                propertySchema?.type === manifestProperty.type
+                    ? propertyId
+                    : undefined;
+        }
+        return [
+            {
+                key,
+                collectionPointer: binding?.collectionPointer,
+                collectionSchema: binding?.collectionSchema,
+                propertyIdsByKey,
+                propertySchemasById,
+            },
+        ];
+    });
+}
+function findPropertyIdByManifestProperty(propertySchemasById, manifestProperty) {
+    // `ManifestProperty.name` is display copy for setup UI. Binding fallback is based
+    // on the stable semantic key so copy changes don't affect property resolution.
+    const propertySchemaForKey = propertySchemasById[manifestProperty.key];
+    if (propertySchemaForKey?.type === manifestProperty.type) {
+        return manifestProperty.key;
+    }
+    const normalizedKey = normalizePropertyName(manifestProperty.key);
+    for (const [propertyId, propertySchema] of Object.entries(propertySchemasById)) {
+        if (propertySchema.type === manifestProperty.type &&
+            normalizePropertyName(propertySchema.name) === normalizedKey) {
+            return propertyId;
+        }
+    }
+    return undefined;
+}
+function normalizePropertyName(value) {
+    return value.trim().toLowerCase();
+}
+function formatInvalidHostReason(incomingType, issues) {
+    const labelled = incomingType
+        ? `host message of type "${incomingType}"`
+        : "host message";
+    const first = issues[0];
+    if (!first) {
+        return `Could not parse ${labelled}: unknown error`;
+    }
+    const path = first.path
+        ?.map(p => String(p.key ?? ""))
+        .filter(Boolean)
+        .join(".") ?? "";
+    const detail = path ? `${path}: ${first.message}` : first.message;
+    const extra = issues.length > 1 ? ` (+${issues.length - 1} more)` : "";
+    return `Could not parse ${labelled}: ${detail}${extra}`;
+}
+/**
+ * Attempts to load a `custom_blocks.json` manifest co-located with the bundle. Treats
+ * any non-200 response as "no manifest".
+ */
+async function tryFetchManifest() {
+    if (typeof fetch !== "function") {
+        console.warn(`[notion-custom-sdk] no \`fetch\` available; cannot load ${MANIFEST_URL}`);
+        return null;
+    }
+    let response;
+    try {
+        response = await fetch(MANIFEST_URL, { credentials: "omit" });
+    }
+    catch (error) {
+        console.warn(`[notion-custom-sdk] no manifest fetched from ${MANIFEST_URL}`, error);
+        return null;
+    }
+    if (!response.ok) {
+        console.warn(`[notion-custom-sdk] no manifest at ${MANIFEST_URL} (status ${response.status})`);
+        return null;
+    }
+    let json;
+    try {
+        json = await response.json();
+    }
+    catch (error) {
+        console.warn(`[notion-custom-sdk] manifest at ${MANIFEST_URL} was not valid JSON`, error);
+        return null;
+    }
+    const parsed = v.safeParse(manifestSchema, json);
+    if (!parsed.success) {
+        console.warn(`[notion-custom-sdk] manifest at ${MANIFEST_URL} did not match schema`, parsed.issues);
+        return null;
+    }
+    return parsed.output;
+}
+const bridge = new NotionCustomBlockBridge();
+export function subscribeToCustomBlockHost(listener) {
+    return bridge.subscribe(listener);
+}
+export function getCustomBlockHostState() {
+    return bridge.getHostState();
+}
+export function queryCustomBlockDataSource(key, limit) {
+    bridge.queryDataSource(key, limit);
+}
+/**
+ * Apply an `init` payload to the bridge directly, bypassing the postMessage
+ * handshake. Used by the React provider when it needs to seed placeholder
+ * state (e.g. the standalone preview fallback when not embedded in Notion).
+ * The bridge applies the payload through the same code path as a real host.
+ */
+export function setMockCustomBlockState(message) {
+    bridge.setMockState(message);
+}
+/**
+ * Thrown by {@link initCustomBlock} when the SDK is loaded in a top-level
+ * window (no parent frame) — `postMessage` would just hit the same window and
+ * the handshake can never complete. `<NotionCustomBlock>` catches this
+ * specifically and falls back to a standalone preview with a warning banner;
+ * direct callers can `instanceof` it to apply their own policy.
+ */
+export class NotInIframeError extends Error {
+    constructor(message = NOT_IN_IFRAME_MESSAGE) {
+        super(message);
+        this.name = "NotInIframeError";
+    }
+}
+const DEFAULT_INIT_TIMEOUT_MS = 2000;
+const NOT_IN_IFRAME_MESSAGE = "<NotionCustomBlock> only works inside an iframe — use the dev shell or deploy to Notion.";
+let initPromise;
+/**
+ * Performs the SDK ↔ host handshake: loads `custom_blocks.json`, posts
+ * `ready`, then awaits the host's first `init` message. Resolves with that
+ * payload; rejects with a
+ * `TimeoutError` if the host doesn't respond inside `timeoutMs`.
+ *
+ * Idempotent: subsequent calls return the same promise as the first and
+ * ignore any new options. Mount your React tree (or call any SDK hook /
+ * `subscribeToCustomBlockHost`) only after the returned promise resolves.
+ *
+ * @example
+ * // src/index.tsx
+ * const initial = await initCustomBlock()
+ * console.log(initial.theme, initial.context.customBlockId)
+ * ReactDOM.createRoot(root).render(<App />)
+ */
+export function initCustomBlock(opts = {}) {
+    initPromise ?? (initPromise = (async () => {
+        // Standalone tab (no parent frame) — fail fast with a typed error
+        // rather than letting `awaitInit` time out, since `postMessage` to
+        // `window.parent` would just hit the same window and never arrive.
+        // `<NotionCustomBlock>` catches this specifically to render a warning
+        // banner + children for dev-time previews.
+        if (typeof window !== "undefined" && window.parent === window) {
+            throw new NotInIframeError();
+        }
+        const manifest = await tryFetchManifest();
+        await bridge.sendReady(manifest);
+        const timeoutMs = opts.timeoutMs ?? DEFAULT_INIT_TIMEOUT_MS;
+        const message = await bridge.awaitInit(AbortSignal.timeout(timeoutMs));
+        const hostState = bridge.getHostState();
+        return {
+            theme: message.theme,
+            context: message.context,
+            dataSources: hostState.status === "initialized" ? hostState.dataSources : [],
+        };
+    })());
+    return initPromise;
+}
+const EMPTY_QUERY_VIEW = {
+    items: [],
+    propertySchemasById: {},
+    propertySchemasByKey: {},
+    isLoading: false,
+    hasMore: false,
+};
+export function getDataSourceQueryView(hostState, key) {
+    if (hostState.status !== "initialized") {
+        return EMPTY_QUERY_VIEW;
+    }
+    const dataSource = hostState.dataSources.find(entry => entry.key === key);
+    const queryState = hostState.dataSourceState[key] ?? createEmptyDataSourceQueryState();
+    if (dataSource === undefined) {
+        return {
+            items: [],
+            collectionSchema: undefined,
+            propertySchemasById: {},
+            propertySchemasByKey: {},
+            isLoading: queryState.isLoading,
+            hasMore: queryState.hasMore,
+            error: queryState.error,
+        };
+    }
+    const propertyIdsByKey = dataSource.propertyIdsByKey;
+    const propertySchemasById = dataSource.propertySchemasById;
+    const resolvedItems = queryState.items.map(entry => {
+        const propertiesByKey = {};
+        for (const [key, propertyId] of Object.entries(propertyIdsByKey)) {
+            propertiesByKey[key] =
+                propertyId === undefined ? undefined : entry.propertiesById[propertyId];
+        }
+        return {
+            id: entry.id,
+            propertiesById: entry.propertiesById,
+            propertiesByKey,
+            update: input => updateDataSourcePage({
+                dataSource,
+                pageId: entry.id,
+                input,
+            }),
+        };
+    });
+    const propertySchemasByKey = {};
+    for (const [key, propertyId] of Object.entries(propertyIdsByKey)) {
+        propertySchemasByKey[key] =
+            propertyId === undefined ? undefined : propertySchemasById[propertyId];
+    }
+    return {
+        items: resolvedItems,
+        collectionSchema: dataSource.collectionSchema,
+        propertySchemasById,
+        propertySchemasByKey,
+        isLoading: queryState.isLoading,
+        hasMore: queryState.hasMore,
+        error: queryState.error,
+    };
+}
+function updateDataSourcePage(args) {
+    const { dataSource, pageId, input } = args;
+    const resolvedProperties = input.properties === undefined
+        ? undefined
+        : resolvePropertyWriteMapForDataSource({
+            dataSource,
+            properties: input.properties,
+            operationName: "dataSourcePage.update",
+        });
+    if (resolvedProperties?.status === "error") {
+        return Promise.resolve(resolvedProperties);
+    }
+    return bridge.updatePage({
+        pageId,
+        properties: resolvedProperties?.properties,
+        icon: input.icon,
+        cover: input.cover,
+        archived: input.archived,
+    });
+}
+export function createPage(input) {
+    return bridge.createPage(input);
+}
+export function getPage(pageId) {
+    return bridge.getPage(pageId);
+}
+export function updatePage(input) {
+    return bridge.updatePage(input);
+}
+export function postCustomBlockResize(height) {
+    bridge.postResize(height);
+}