@notionhq/custom-blocks 0.0.58

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

@@ -0,0 +1,191 @@
+import * as v from "valibot";
+/**
+ * Hex-token identifiers for Notion's named colors. Mirrors the public API's
+ * `select.options[].color` enum
+ * (https://developers.notion.com/reference/property-object#select).
+ */
+export declare const notionPropertyColorSchema: v.PicklistSchema<["default", "gray", "brown", "orange", "yellow", "green", "blue", "purple", "pink", "red", "gray_background", "brown_background", "orange_background", "yellow_background", "green_background", "blue_background", "purple_background", "pink_background", "red_background", "default_background"], undefined>;
+export type NotionPropertyColor = v.InferOutput<typeof notionPropertyColorSchema>;
+export declare const notionPropertyOptionSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly color: v.OptionalSchema<v.PicklistSchema<["default", "gray", "brown", "orange", "yellow", "green", "blue", "purple", "pink", "red", "gray_background", "brown_background", "orange_background", "yellow_background", "green_background", "blue_background", "purple_background", "pink_background", "red_background", "default_background"], undefined>, undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type NotionPropertyOption = v.InferOutput<typeof notionPropertyOptionSchema>;
+export declare const notionStatusGroupSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly color: v.OptionalSchema<v.PicklistSchema<["default", "gray", "brown", "orange", "yellow", "green", "blue", "purple", "pink", "red", "gray_background", "brown_background", "orange_background", "yellow_background", "green_background", "blue_background", "purple_background", "pink_background", "red_background", "default_background"], undefined>, undefined>;
+    readonly option_ids: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type NotionStatusGroup = v.InferOutput<typeof notionStatusGroupSchema>;
+export declare const notionDualPropertySchema: v.ObjectSchema<{
+    readonly synced_property_id: v.StringSchema<undefined>;
+    readonly synced_property_name: v.StringSchema<undefined>;
+}, undefined>;
+export type NotionDualProperty = v.InferOutput<typeof notionDualPropertySchema>;
+/**
+ * Every Notion property type the bridge speaks, in a single readable list.
+ * Mirrors the Notion public API
+ * [property object](https://developers.notion.com/reference/property-object)
+ * type field. Internal-only types (`button`, `verification`,
+ * `last_visited_time`, `location`) and the four built-ins (`created_time`,
+ * `last_edited_time`, `created_by`, `last_edited_by`) are included under their
+ * bridge-native names.
+ */
+export declare const NOTION_PROPERTY_TYPES: readonly ["title", "rich_text", "number", "checkbox", "url", "email", "phone_number", "select", "multi_select", "status", "date", "people", "files", "unique_id", "relation", "place", "formula", "rollup", "button", "verification", "last_visited_time", "location", "created_time", "last_edited_time", "created_by", "last_edited_by"];
+export declare const notionPropertyTypeSchema: v.PicklistSchema<readonly ["title", "rich_text", "number", "checkbox", "url", "email", "phone_number", "select", "multi_select", "status", "date", "people", "files", "unique_id", "relation", "place", "formula", "rollup", "button", "verification", "last_visited_time", "location", "created_time", "last_edited_time", "created_by", "last_edited_by"], undefined>;
+/**
+ * String literal union of every supported Notion property type. Same set as
+ * the discriminator in `NotionPropertySchema` — split out so the manifest
+ * can declare expected property types without dragging in the per-type
+ * payload shapes.
+ */
+export type NotionPropertyType = v.InferOutput<typeof notionPropertyTypeSchema>;
+/**
+ * Per-property schema as exposed by the host over the custom-block bridge.
+ * The `type` discriminator must be one of {@link NOTION_PROPERTY_TYPES}.
+ */
+export declare const notionPropertySchemaSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"title", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"rich_text", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"number", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"checkbox", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"url", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"email", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"phone_number", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"select", undefined>;
+    readonly options: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly color: v.OptionalSchema<v.PicklistSchema<["default", "gray", "brown", "orange", "yellow", "green", "blue", "purple", "pink", "red", "gray_background", "brown_background", "orange_background", "yellow_background", "green_background", "blue_background", "purple_background", "pink_background", "red_background", "default_background"], undefined>, undefined>;
+        readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"multi_select", undefined>;
+    readonly options: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly color: v.OptionalSchema<v.PicklistSchema<["default", "gray", "brown", "orange", "yellow", "green", "blue", "purple", "pink", "red", "gray_background", "brown_background", "orange_background", "yellow_background", "green_background", "blue_background", "purple_background", "pink_background", "red_background", "default_background"], undefined>, undefined>;
+        readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"status", undefined>;
+    readonly options: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly color: v.OptionalSchema<v.PicklistSchema<["default", "gray", "brown", "orange", "yellow", "green", "blue", "purple", "pink", "red", "gray_background", "brown_background", "orange_background", "yellow_background", "green_background", "blue_background", "purple_background", "pink_background", "red_background", "default_background"], undefined>, undefined>;
+        readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly groups: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+        readonly color: v.OptionalSchema<v.PicklistSchema<["default", "gray", "brown", "orange", "yellow", "green", "blue", "purple", "pink", "red", "gray_background", "brown_background", "orange_background", "yellow_background", "green_background", "blue_background", "purple_background", "pink_background", "red_background", "default_background"], undefined>, undefined>;
+        readonly option_ids: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"date", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"people", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"files", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"unique_id", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"relation", undefined>;
+    readonly data_source_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly dual_property: v.OptionalSchema<v.ObjectSchema<{
+        readonly synced_property_id: v.StringSchema<undefined>;
+        readonly synced_property_name: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"place", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"formula", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"rollup", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"button", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"verification", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"last_visited_time", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"location", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"created_time", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"last_edited_time", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"created_by", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"last_edited_by", undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>], undefined>;
+export type NotionPropertySchema = v.InferOutput<typeof notionPropertySchemaSchema>;
+/**
+ * The four synthetic built-in property IDs the host always includes in every
+ * data source's `propertySchemasById` and every row's `propertiesById`.
+ */
+export declare const NOTION_BUILTIN_PROPERTY_IDS: readonly ["created_time", "last_edited_time", "created_by", "last_edited_by"];
+export type NotionBuiltinPropertyId = (typeof NOTION_BUILTIN_PROPERTY_IDS)[number];
+//# sourceMappingURL=propertySchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"propertySchema.d.ts","sourceRoot":"","sources":["../../../../../../../../../Users/nsarkar/work/custom-blocks/sdk/src/bridge/dataSources/propertySchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,iUAqBpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,WAAW,CAC9C,OAAO,yBAAyB,CAChC,CAAA;AAED,eAAO,MAAM,0BAA0B;;;;;aAKrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,WAAW,CAC/C,OAAO,0BAA0B,CACjC,CAAA;AAED,eAAO,MAAM,uBAAuB;;;;;aAKlC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E,eAAO,MAAM,wBAAwB;;;aAGnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAO/E;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,4UA2BxB,CAAA;AAEV,eAAO,MAAM,wBAAwB,yWAAoC,CAAA;AAEzE;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAiDrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,WAAW,CAC/C,OAAO,0BAA0B,CACjC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,2BAA2B,+EAK9B,CAAA;AAEV,MAAM,MAAM,uBAAuB,GAClC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/bridge/dataSources/propertySchema.js

@@ -0,0 +1,148 @@
+import * as v from "valibot";
+/**
+ * Hex-token identifiers for Notion's named colors. Mirrors the public API's
+ * `select.options[].color` enum
+ * (https://developers.notion.com/reference/property-object#select).
+ */
+export const notionPropertyColorSchema = v.picklist([
+    "default",
+    "gray",
+    "brown",
+    "orange",
+    "yellow",
+    "green",
+    "blue",
+    "purple",
+    "pink",
+    "red",
+    "gray_background",
+    "brown_background",
+    "orange_background",
+    "yellow_background",
+    "green_background",
+    "blue_background",
+    "purple_background",
+    "pink_background",
+    "red_background",
+    "default_background",
+]);
+export const notionPropertyOptionSchema = v.object({
+    id: v.string(),
+    name: v.string(),
+    color: v.optional(notionPropertyColorSchema),
+    description: v.optional(v.string()),
+});
+export const notionStatusGroupSchema = v.object({
+    id: v.string(),
+    name: v.string(),
+    color: v.optional(notionPropertyColorSchema),
+    option_ids: v.array(v.string()),
+});
+export const notionDualPropertySchema = v.object({
+    synced_property_id: v.string(),
+    synced_property_name: v.string(),
+});
+const baseProp = v.object({
+    name: v.string(),
+    description: v.optional(v.string()),
+});
+/**
+ * Every Notion property type the bridge speaks, in a single readable list.
+ * Mirrors the Notion public API
+ * [property object](https://developers.notion.com/reference/property-object)
+ * type field. Internal-only types (`button`, `verification`,
+ * `last_visited_time`, `location`) and the four built-ins (`created_time`,
+ * `last_edited_time`, `created_by`, `last_edited_by`) are included under their
+ * bridge-native names.
+ */
+export const NOTION_PROPERTY_TYPES = [
+    "title",
+    "rich_text",
+    "number",
+    "checkbox",
+    "url",
+    "email",
+    "phone_number",
+    "select",
+    "multi_select",
+    "status",
+    "date",
+    "people",
+    "files",
+    "unique_id",
+    "relation",
+    "place",
+    "formula",
+    "rollup",
+    "button",
+    "verification",
+    "last_visited_time",
+    "location",
+    "created_time",
+    "last_edited_time",
+    "created_by",
+    "last_edited_by",
+];
+export const notionPropertyTypeSchema = v.picklist(NOTION_PROPERTY_TYPES);
+/**
+ * Per-property schema as exposed by the host over the custom-block bridge.
+ * The `type` discriminator must be one of {@link NOTION_PROPERTY_TYPES}.
+ */
+export const notionPropertySchemaSchema = v.variant("type", [
+    v.object({ ...baseProp.entries, type: v.literal("title") }),
+    v.object({ ...baseProp.entries, type: v.literal("rich_text") }),
+    v.object({ ...baseProp.entries, type: v.literal("number") }),
+    v.object({ ...baseProp.entries, type: v.literal("checkbox") }),
+    v.object({ ...baseProp.entries, type: v.literal("url") }),
+    v.object({ ...baseProp.entries, type: v.literal("email") }),
+    v.object({ ...baseProp.entries, type: v.literal("phone_number") }),
+    v.object({
+        ...baseProp.entries,
+        type: v.literal("select"),
+        options: v.array(notionPropertyOptionSchema),
+    }),
+    v.object({
+        ...baseProp.entries,
+        type: v.literal("multi_select"),
+        options: v.array(notionPropertyOptionSchema),
+    }),
+    v.object({
+        ...baseProp.entries,
+        type: v.literal("status"),
+        options: v.array(notionPropertyOptionSchema),
+        groups: v.array(notionStatusGroupSchema),
+    }),
+    v.object({ ...baseProp.entries, type: v.literal("date") }),
+    v.object({ ...baseProp.entries, type: v.literal("people") }),
+    v.object({ ...baseProp.entries, type: v.literal("files") }),
+    v.object({ ...baseProp.entries, type: v.literal("unique_id") }),
+    v.object({
+        ...baseProp.entries,
+        type: v.literal("relation"),
+        data_source_id: v.optional(v.string()),
+        dual_property: v.optional(notionDualPropertySchema),
+    }),
+    v.object({ ...baseProp.entries, type: v.literal("place") }),
+    v.object({ ...baseProp.entries, type: v.literal("formula") }),
+    v.object({ ...baseProp.entries, type: v.literal("rollup") }),
+    // Internal-only types passed through under their bridge-native names.
+    v.object({ ...baseProp.entries, type: v.literal("button") }),
+    v.object({ ...baseProp.entries, type: v.literal("verification") }),
+    v.object({ ...baseProp.entries, type: v.literal("last_visited_time") }),
+    v.object({ ...baseProp.entries, type: v.literal("location") }),
+    // Synthetic built-ins. The host always emits one of each per data source.
+    v.object({ ...baseProp.entries, type: v.literal("created_time") }),
+    v.object({ ...baseProp.entries, type: v.literal("last_edited_time") }),
+    v.object({ ...baseProp.entries, type: v.literal("created_by") }),
+    v.object({ ...baseProp.entries, type: v.literal("last_edited_by") }),
+]);
+/**
+ * The four synthetic built-in property IDs the host always includes in every
+ * data source's `propertySchemasById` and every row's `propertiesById`.
+ */
+export const NOTION_BUILTIN_PROPERTY_IDS = [
+    "created_time",
+    "last_edited_time",
+    "created_by",
+    "last_edited_by",
+];

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

@@ -0,0 +1,10 @@
+import * as v from "valibot";
+/**
+ * A pointer to a record in a database.
+ */
+export declare const notionRecordPointerSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly table: v.StringSchema<undefined>;
+}, undefined>;
+export type NotionRecordPointer = v.InferOutput<typeof notionRecordPointerSchema>;
+//# sourceMappingURL=recordPointer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recordPointer.d.ts","sourceRoot":"","sources":["../../../../../../../../../Users/nsarkar/work/custom-blocks/sdk/src/bridge/dataSources/recordPointer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;aAGpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,WAAW,CAC9C,OAAO,yBAAyB,CAChC,CAAA"}

package/dist/bridge/dataSources/recordPointer.js

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+/**
+ * A pointer to a record in a database.
+ */
+export const notionRecordPointerSchema = v.object({
+    id: v.string(),
+    table: v.string(),
+});

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

@@ -0,0 +1,22 @@
+import type { CustomBlockManifest } from "../manifest.js";
+import type { NotionDataSource, NotionDataSourceBindings } from "./dataSource.js";
+import type { NotionPropertySchema } from "./propertySchema.js";
+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":["../../../../../../../../../Users/nsarkar/work/custom-blocks/sdk/src/bridge/dataSources/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AACzD,OAAO,KAAK,EACX,gBAAgB,EAChB,wBAAwB,EACxB,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAE/D,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,41 @@
+import * as v from "valibot";
+import type { CustomBlockErrorInfo } from "../errors";
+import type { NotionPagePropertyInputMap, NotionPagePropertyWriteMap } from "../pages/page.js";
+import type { NotionDataSource } from "./dataSource.js";
+export declare const customBlockPropertyErrorCodeSchema: v.StringSchema<undefined>;
+export type CustomBlockPropertyErrorCode = "unmapped_property" | "property_id_mismatch" | "duplicate_property" | "invalid_property_value" | (string & {});
+export type CustomBlockPropertyErrorInfo = CustomBlockErrorInfo<CustomBlockPropertyErrorCode>;
+export type PropertyWriteMapResolutionResult = {
+    status: "success";
+    properties: NotionPagePropertyWriteMap;
+} | {
+    status: "error";
+    error: CustomBlockPropertyErrorInfo;
+};
+/**
+ * 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: CustomBlockPropertyErrorInfo;
+};
+//# sourceMappingURL=resolveProperty.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveProperty.d.ts","sourceRoot":"","sources":["../../../../../../../../../Users/nsarkar/work/custom-blocks/sdk/src/bridge/dataSources/resolveProperty.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AACrD,OAAO,KAAK,EACX,0BAA0B,EAC1B,0BAA0B,EAC1B,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAIvD,eAAO,MAAM,kCAAkC,2BAAa,CAAA;AAE5D,MAAM,MAAM,4BAA4B,GACrC,mBAAmB,GACnB,sBAAsB,GACtB,oBAAoB,GACpB,wBAAwB,GACxB,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;AAEhB,MAAM,MAAM,4BAA4B,GACvC,oBAAoB,CAAC,4BAA4B,CAAC,CAAA;AAEnD,MAAM,MAAM,gCAAgC,GACzC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,UAAU,EAAE,0BAA0B,CAAA;CAAE,GAC7D;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,4BAA4B,CAAA;CAAE,CAAA;AAS3D;;;;;;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,CAwDnC;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,4BAA4B,CAAA;CAAE,CAiB1D"}

package/dist/bridge/dataSources/resolveProperty.js

@@ -0,0 +1,73 @@
+import * as v from "valibot";
+import { notionPagePropertyValueSchema } from "../pages/page.js";
+// The schema accepts any string code. The type lists known codes for
+// autocomplete, with an open string fallback for newer senders.
+export const customBlockPropertyErrorCodeSchema = v.string();
+function makePropertyError(code, message) {
+    return { code, message, isRetryable: false };
+}
+/**
+ * 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: makePropertyError("property_id_mismatch", `Property ${identifier} resolved to ${propertyId} but value id was ${value.id}.`),
+            };
+        }
+        if (resolvedProperties[propertyId] !== undefined) {
+            return {
+                status: "error",
+                error: makePropertyError("duplicate_property", `Cannot set property ${propertyId} more than once.`),
+            };
+        }
+        const parsedValue = v.safeParse(notionPagePropertyValueSchema, {
+            ...value,
+            id: propertyId,
+        });
+        if (!parsedValue.success) {
+            return {
+                status: "error",
+                error: makePropertyError("invalid_property_value", `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: makePropertyError("unmapped_property", `${operationName} cannot resolve property key "${identifier}" because it is not bound to a Notion property.`),
+            };
+        }
+        return { status: "success", propertyId };
+    }
+    return { status: "success", propertyId: identifier };
+}

package/dist/bridge/errors.d.ts

@@ -0,0 +1,12 @@
+import * as v from "valibot";
+export type CustomBlockErrorInfo<TCode extends string = string> = {
+    code: TCode;
+    message: string;
+    isRetryable: boolean;
+};
+export declare const customBlockErrorInfoSchema: v.ObjectSchema<{
+    readonly code: v.StringSchema<undefined>;
+    readonly message: v.StringSchema<undefined>;
+    readonly isRetryable: v.BooleanSchema<undefined>;
+}, undefined>;
+//# sourceMappingURL=errors.d.ts.map

package/dist/bridge/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../../../../../Users/nsarkar/work/custom-blocks/sdk/src/bridge/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,oBAAoB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,IAAI;IACjE,IAAI,EAAE,KAAK,CAAA;IACX,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,eAAO,MAAM,0BAA0B;;;;aAIrC,CAAA"}

package/dist/bridge/errors.js

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+export const customBlockErrorInfoSchema = v.object({
+    code: v.string(),
+    message: v.string(),
+    isRetryable: v.boolean(),
+});