ncblock 0.0.2 → 0.0.4

package/dist/{notion.js → bridge/SandboxBridge.js}

@@ -1,86 +1,18 @@
 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";
+import { unreachable } from "../utils";
+import { resolveDataSources } from "./dataSources/resolve";
+import { resolvePropertyWriteMapForDataSource } from "./dataSources/resolveProperty";
+import { createEmptyDataSourceQueryState, } from "./hostState";
+import { readIncomingType } from "./incomingType";
+import { hostToSandboxMessageSchema } from "./messages/hostToSandbox";
+import { PendingRequests } from "./pendingRequests";
 /**
  * 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 {
+export const CUSTOM_BLOCK_BRIDGE_PROTOCOL_VERSION = 1;
+export class SandboxBridge {
     constructor() {
         this.hostState = {
             status: "uninitialized",
@@ -90,6 +22,8 @@ class NotionCustomBlockBridge {
         this.nextRequestId = 1;
         this.pendingCreatePage = new PendingRequests("custom-block-create-page");
         this.pendingGetPage = new PendingRequests("custom-block-get-page");
+        this.pendingGetUser = new PendingRequests("custom-block-get-user");
+        this.pendingListUsers = new PendingRequests("custom-block-list-users");
         this.pendingUpdatePage = new PendingRequests("custom-block-update-page");
         this.initMessage = new Promise(resolve => {
             this.resolveInit = resolve;
@@ -205,6 +139,24 @@ class NotionCustomBlockBridge {
                     }
                     return;
                 }
+                case "getUserResult": {
+                    const result = message.status === "success"
+                        ? { status: "success", user: message.user }
+                        : { status: "error", error: message.error };
+                    if (!this.pendingGetUser.resolve(message.requestId, result)) {
+                        console.warn(`[notion-custom-sdk] getUserResult for unknown requestId ${message.requestId}`);
+                    }
+                    return;
+                }
+                case "listUsersResult": {
+                    const result = message.status === "success"
+                        ? { status: "success", list: message.list }
+                        : { status: "error", error: message.error };
+                    if (!this.pendingListUsers.resolve(message.requestId, result)) {
+                        console.warn(`[notion-custom-sdk] listUsersResult for unknown requestId ${message.requestId}`);
+                    }
+                    return;
+                }
                 case "updatePageResult": {
                     const result = message.status === "success"
                         ? { status: "success", page: message.page }
@@ -270,7 +222,7 @@ class NotionCustomBlockBridge {
             });
         });
     }
-    async sendReady(manifest) {
+    sendReady(manifest) {
         if (typeof window === "undefined") {
             return;
         }
@@ -412,6 +364,31 @@ class NotionCustomBlockBridge {
             window.parent.postMessage(outbound, "*");
         });
     }
+    getUser(userId) {
+        return new Promise(resolve => {
+            const requestId = this.pendingGetUser.allocate(resolve);
+            const outbound = {
+                type: "getUser",
+                requestId,
+                userId,
+            };
+            console.debug("[notion-custom-sdk] outbound postMessage", outbound);
+            window.parent.postMessage(outbound, "*");
+        });
+    }
+    listUsers(input = {}) {
+        return new Promise(resolve => {
+            const requestId = this.pendingListUsers.allocate(resolve);
+            const outbound = {
+                type: "listUsers",
+                requestId,
+                startCursor: input.startCursor,
+                pageSize: input.pageSize,
+            };
+            console.debug("[notion-custom-sdk] outbound postMessage", outbound);
+            window.parent.postMessage(outbound, "*");
+        });
+    }
     updatePage(input) {
         return new Promise(resolve => {
             if ((input.properties === undefined ||
@@ -447,6 +424,31 @@ class NotionCustomBlockBridge {
             window.parent.postMessage(outbound, "*");
         });
     }
+    /**
+     * Updates a page on a known data source, resolving any property keys against the data source's
+     * `propertyIdsByKey` before sending the bridge message. Used by the per-row `update` callback
+     * returned from {@link getDataSourceQueryView}.
+     */
+    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 this.updatePage({
+            pageId,
+            properties: resolvedProperties?.properties,
+            icon: input.icon,
+            cover: input.cover,
+            archived: input.archived,
+        });
+    }
     /**
      * Translates the public `CreatePageInput["parent"]` into the bridge-native
      * `CreatePageMessageParent`. The `data_source_key` variant is resolved sandbox-side against
@@ -496,65 +498,6 @@ class NotionCustomBlockBridge {
         }
     }
 }
-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}"`
@@ -571,203 +514,3 @@ function formatInvalidHostReason(incomingType, issues) {
     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);
-}

package/dist/bridge/dataSources/resolve.d.ts

@@ -0,0 +1,22 @@
+import type { CustomBlockManifest } from "../manifest";
+import type { NotionDataSource, NotionDataSourceBindings } from "./dataSource";
+import type { NotionPropertySchema } from "./propertySchema";
+type ResolveDataSourcesArgs = {
+    manifest: CustomBlockManifest | null;
+    dataSourceBindings: NotionDataSourceBindings;
+};
+/**
+ * Builds the public {@link NotionDataSource} list the SDK exposes to consumers.
+ *
+ * Combines the host-supplied bindings (collection pointers + schemas) with the
+ * manifest's declared data-source keys. When the manifest names a property
+ * that isn't in `propertyIdsByKey`, falls back to {@link findPropertyIdByManifestProperty}
+ * so renames in Notion still resolve as long as the schema name matches.
+ */
+export declare function resolveDataSources(args: ResolveDataSourcesArgs): NotionDataSource[];
+export declare function findPropertyIdByManifestProperty(propertySchemasById: Record<string, NotionPropertySchema>, manifestProperty: {
+    key: string;
+    type: NotionPropertySchema["type"];
+}): string | undefined;
+export {};
+//# sourceMappingURL=resolve.d.ts.map

package/dist/bridge/dataSources/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../bridge/dataSources/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAA;AAC9E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAE5D,KAAK,sBAAsB,GAAG;IAC7B,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAAA;IACpC,kBAAkB,EAAE,wBAAwB,CAAA;CAC5C,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,sBAAsB,GAC1B,gBAAgB,EAAE,CA+CpB;AAED,wBAAgB,gCAAgC,CAC/C,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EACzD,gBAAgB,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAC,CAAA;CAAE,GACnE,MAAM,GAAG,SAAS,CAoBpB"}

package/dist/bridge/dataSources/resolve.js

@@ -0,0 +1,65 @@
+/**
+ * Builds the public {@link NotionDataSource} list the SDK exposes to consumers.
+ *
+ * Combines the host-supplied bindings (collection pointers + schemas) with the
+ * manifest's declared data-source keys. When the manifest names a property
+ * that isn't in `propertyIdsByKey`, falls back to {@link findPropertyIdByManifestProperty}
+ * so renames in Notion still resolve as long as the schema name matches.
+ */
+export 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).map(([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,
+        };
+    });
+}
+export 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();
+}

package/dist/bridge/dataSources/resolveProperty.d.ts

@@ -0,0 +1,36 @@
+import type { NotionPagePropertyInputMap, NotionPagePropertyWriteMap } from "../pages/page";
+import type { NotionDataSource } from "./dataSource";
+export type PropertyWriteMapResolutionResult = {
+    status: "success";
+    properties: NotionPagePropertyWriteMap;
+} | {
+    status: "error";
+    error: string;
+};
+/**
+ * Resolves a public SDK property write map into the ID-keyed bridge shape.
+ *
+ * Identifiers in `properties` may be raw property IDs or data-source property keys; the latter
+ * are looked up in the `dataSource`'s `propertyIdsByKey`. Each value is re-parsed through
+ * `notionPagePropertyValueSchema` with its `id` rewritten to the resolved property ID.
+ */
+export declare function resolvePropertyWriteMapForDataSource(args: {
+    dataSource: NotionDataSource | undefined;
+    properties: NotionPagePropertyInputMap;
+    operationName: string;
+}): PropertyWriteMapResolutionResult;
+/**
+ * Treats matching data-source keys as aliases for property IDs; all other identifiers are raw IDs.
+ */
+export declare function resolvePropertyIdentifierForDataSource(args: {
+    dataSource: NotionDataSource | undefined;
+    identifier: string;
+    operationName: string;
+}): {
+    status: "success";
+    propertyId: string;
+} | {
+    status: "error";
+    error: string;
+};
+//# sourceMappingURL=resolveProperty.d.ts.map

package/dist/bridge/dataSources/resolveProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveProperty.d.ts","sourceRoot":"","sources":["../../../bridge/dataSources/resolveProperty.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,0BAA0B,EAC1B,0BAA0B,EAC1B,MAAM,eAAe,CAAA;AAEtB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAEpD,MAAM,MAAM,gCAAgC,GACzC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,UAAU,EAAE,0BAA0B,CAAA;CAAE,GAC7D;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAErC;;;;;;GAMG;AACH,wBAAgB,oCAAoC,CAAC,IAAI,EAAE;IAC1D,UAAU,EAAE,gBAAgB,GAAG,SAAS,CAAA;IACxC,UAAU,EAAE,0BAA0B,CAAA;IACtC,aAAa,EAAE,MAAM,CAAA;CACrB,GAAG,gCAAgC,CA+CnC;AAED;;GAEG;AACH,wBAAgB,sCAAsC,CAAC,IAAI,EAAE;IAC5D,UAAU,EAAE,gBAAgB,GAAG,SAAS,CAAA;IACxC,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,EAAE,MAAM,CAAA;CACrB,GACE;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAcpC"}

package/dist/bridge/dataSources/resolveProperty.js

@@ -0,0 +1,67 @@
+import * as v from "valibot";
+import { notionPagePropertyValueSchema } from "../pages/page";
+/**
+ * Resolves a public SDK property write map into the ID-keyed bridge shape.
+ *
+ * Identifiers in `properties` may be raw property IDs or data-source property keys; the latter
+ * are looked up in the `dataSource`'s `propertyIdsByKey`. Each value is re-parsed through
+ * `notionPagePropertyValueSchema` with its `id` rewritten to the resolved property ID.
+ */
+export 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.
+ */
+export 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 };
+}