better-supabase 0.5.1 → 0.6.0

package/dist/blocks/notifications/index.js

@@ -0,0 +1,425 @@
+import { c as mapDbError, n as dbError } from "../../errors-B11Duf73.js";
+import { t as temporal } from "../../temporal-required-BVvW7SYJ.js";
+import { a as ok, r as err, s as toDbError, t as AsyncResult } from "../../result-DzUbqgdW.js";
+import { n as validate } from "../../standard-BK0cqJ7y.js";
+import { i as emitBlockEvent } from "../../block-events-CrT8r7Fe.js";
+import { n as rpcTransport, r as sqlTransport, t as rawError } from "../../block-transport-BLr-ZgLc.js";
+import { c as errorText, d as isRecord, g as pageOf, h as optionalText, i as blockCall, m as optionalInstant, n as applyTemporal } from "../../block-helpers-DWHxHsEQ.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BmjMyXTa.js";
+//#region src/blocks/notifications/notifications.ts
+const nullableText = (value) => optionalText(value) ?? null;
+const nullableInstant = (value) => optionalInstant(value) ?? null;
+function toItem(row) {
+	const type = nullableText(row["subject_type"]);
+	const id = nullableText(row["subject_id"]);
+	const label = nullableText(row["subject_label"]);
+	return {
+		id: String(row["id"]),
+		eventId: String(row["event_id"]),
+		type: String(row["type"]),
+		data: row["data"] ?? {},
+		tenant: nullableText(row["tenant"]),
+		actorId: nullableText(row["actor_id"]),
+		subject: type === null || id === null ? null : {
+			type,
+			id,
+			...label === null ? {} : { label }
+		},
+		summary: nullableText(row["summary"]),
+		actionPath: nullableText(row["action_path"]),
+		priority: nullableText(row["priority"]),
+		createdAt: nullableInstant(row["created_at"]) ?? temporal().Now.instant(),
+		readAt: nullableInstant(row["read_at"]),
+		resolvedAt: nullableInstant(row["resolved_at"])
+	};
+}
+function cursorOf(before) {
+	if (before === void 0) return {
+		before: null,
+		before_id: null
+	};
+	if ("epochNanoseconds" in before) return {
+		before: before.toString(),
+		before_id: null
+	};
+	return {
+		before: before.createdAt.toString(),
+		before_id: before.id
+	};
+}
+function publicObjectUrl(url, bucket, path) {
+	const object = path.replace(/^\/+/, "").split("/").map(encodeURIComponent).join("/");
+	return `${url.replace(/\/+$/, "")}/storage/v1/object/public/${encodeURIComponent(bucket)}/${object}`;
+}
+function filtersOf(filters) {
+	return {
+		tenant: filters.tenant ?? null,
+		status: filters.status ?? "all",
+		read: filters.read ?? null,
+		resolved: filters.resolved ?? null,
+		dismissed: filters.dismissed === void 0 ? false : filters.dismissed,
+		types: filters.types ?? null,
+		subject_types: filters.subjectTypes ?? null,
+		search: filters.search ?? null
+	};
+}
+const LEVELS = [
+	"participating",
+	"all",
+	"ignore"
+];
+function createNotifications(options) {
+	applyTemporal(options);
+	const { transport } = options;
+	const schema = options.schema ?? "better_supabase";
+	const mappers = options.mappers ?? [];
+	const run = blockCall(transport, schema, mappers);
+	const call = async (fn, args) => transport.call(schema, fn, args);
+	function emit(type, data, tenant) {
+		if (!options.events) return;
+		emitBlockEvent(options.events, type, data, {
+			subject: `notifications/${data.notificationId}`,
+			...tenant ? { tenant } : {},
+			...options.actorId ? { actorId: options.actorId } : {},
+			...options.context ? { context: options.context } : {}
+		});
+	}
+	const render = (item, locale, hydrated) => {
+		if (!options.render) return item;
+		return {
+			...item,
+			text: options.render(item, {
+				...locale === void 0 ? {} : { locale },
+				...hydrated === void 0 ? {} : { hydrated }
+			})
+		};
+	};
+	const withAvatarUrl = (actor) => {
+		const avatars = options.avatars;
+		const path = actor.avatarPath;
+		if (!avatars || typeof path !== "string" || path === "") return actor;
+		return {
+			...actor,
+			avatarUrl: typeof avatars === "function" ? avatars(path) : publicObjectUrl(avatars.url, avatars.bucket, path)
+		};
+	};
+	const actorsOf = async (items) => {
+		const ids = [...new Set(items.flatMap((item) => item.actorId ? [item.actorId] : []))];
+		if (ids.length === 0) return /* @__PURE__ */ new Map();
+		const value = await call("notification_actors", { ids });
+		return new Map(Object.entries(isRecord(value) ? value : {}).flatMap(([id, profile]) => isRecord(profile) ? [[id, withAvatarUrl({
+			...profile,
+			id
+		})]] : []));
+	};
+	const itemsOf = (value) => (Array.isArray(value) ? value : []).filter(isRecord).map(toItem);
+	const updateOf = (value) => ({
+		count: Number(isRecord(value) ? value["count"] ?? 0 : 0),
+		items: itemsOf(isRecord(value) ? value["items"] : [])
+	});
+	/** Parses each item's data with its type's schema, before `hydrate` and `render` see it. */
+	const parsed = async (items) => {
+		const out = [];
+		for (const item of items) {
+			const schemaOf = Object.hasOwn(options.types, item.type) ? options.types[item.type] : void 0;
+			if (schemaOf === void 0) {
+				out.push(item);
+				continue;
+			}
+			const data = await validate(schemaOf, item.data, `${item.type} data of notification ${item.id}`);
+			if (!data.ok) return err({
+				...data.error,
+				hint: "NOTIFICATION_DATA_INVALID"
+			});
+			out.push({
+				...item,
+				data: data.data
+			});
+		}
+		return ok(out);
+	};
+	const decorate = (items, listOptions) => AsyncResult.from(async () => {
+		const valid = await parsed(items);
+		if (!valid.ok) return valid;
+		return rendered(valid.data, listOptions);
+	});
+	const rendered = async (items, listOptions) => {
+		try {
+			const locale = listOptions.locale;
+			const context = locale === void 0 ? {} : { locale };
+			const [hydrated, actors] = await Promise.all([options.hydrate ? options.hydrate(items, context) : void 0, listOptions.include?.includes("actor") ? actorsOf(items) : void 0]);
+			const out = items.map((item) => {
+				const text = render(item, locale, hydrated);
+				return actors ? {
+					...text,
+					actor: item.actorId ? actors.get(item.actorId) ?? null : null
+				} : text;
+			});
+			return ok(out);
+		} catch (cause) {
+			const raw = rawError(cause);
+			return err(raw ? mapDbError(raw, mappers) : toDbError(cause));
+		}
+	};
+	async function deliverOne(channel, row, maxAttempts) {
+		const notification = isRecord(row["notification"]) ? toItem(row["notification"]) : void 0;
+		if (!notification) throw new TypeError("claim returned no notification");
+		const attempts = Number(row["attempts"] ?? 1);
+		const message = {
+			deliveryId: String(row["delivery_id"]),
+			channel: channel.name,
+			attempts,
+			userId: String(row["user_id"]),
+			email: nullableText(row["email"]),
+			notification,
+			...options.render ? { text: options.render(notification, {}) } : {}
+		};
+		try {
+			const result = await channel.send(message);
+			const status = result?.status ?? "sent";
+			await call("complete_notification_delivery", {
+				delivery: message.deliveryId,
+				status,
+				provider: result?.provider ?? null,
+				provider_message_id: result?.providerMessageId ?? null
+			});
+			if (status === "sent") emit("notification.delivered", {
+				notificationId: notification.eventId,
+				type: notification.type,
+				channel: channel.name
+			}, notification.tenant);
+			return status;
+		} catch (cause) {
+			const error = errorText(cause);
+			await call("complete_notification_delivery", {
+				delivery: message.deliveryId,
+				status: "pending",
+				error,
+				max_attempts: maxAttempts
+			});
+			emit("notification.failed", {
+				notificationId: notification.eventId,
+				type: notification.type,
+				channel: channel.name,
+				error
+			}, notification.tenant);
+			return "failed";
+		}
+	}
+	const hooked = withBlockHooks({
+		send(type, input) {
+			return AsyncResult.from(async () => {
+				const schemaOf = Object.hasOwn(options.types, type) ? options.types[type] : void 0;
+				if (schemaOf === void 0) return err(dbError("validation", `Unknown notification type "${type}"`, {
+					issues: [{
+						path: ["type"],
+						message: `Unknown type "${type}"`
+					}],
+					hint: "NOTIFICATION_TYPE_UNKNOWN"
+				}));
+				const data = await validate(schemaOf, input.data, `${type} data`);
+				if (!data.ok) return err(data.error);
+				const notification = {
+					type,
+					data: data.data,
+					recipients: input.recipients ?? [],
+					tenant: input.tenant,
+					subject_type: input.subject?.type,
+					subject_id: input.subject?.id,
+					subject_label: input.subject?.label,
+					summary: input.summary,
+					action_path: input.actionPath,
+					priority: input.priority,
+					key: input.key,
+					channels: input.channels,
+					include_actor: input.includeActor,
+					activity: input.activity,
+					resolved: input.resolved,
+					actor: input.actorId,
+					watchers: input.watchers,
+					exclude: input.exclude
+				};
+				const sent = await run("send_notification", { notification }, (value) => isRecord(value) && value["id"] !== null && value["id"] !== void 0 ? {
+					id: String(value["id"]),
+					recipients: (Array.isArray(value["recipients"]) ? value["recipients"] : []).map(String)
+				} : null);
+				if (!sent.ok || sent.data === null) return sent;
+				const { id, recipients } = sent.data;
+				emit("notification.created", {
+					notificationId: id,
+					type,
+					recipientIds: recipients
+				}, input.tenant ?? null);
+				if (options.onSent) try {
+					await options.onSent({
+						id,
+						type,
+						tenant: input.tenant ?? null,
+						recipients
+					});
+				} catch (cause) {
+					return err(toDbError(cause));
+				}
+				return sent;
+			});
+		},
+		get(id, getOptions = {}) {
+			return run("get_notification", { id }, (value) => isRecord(value) ? toItem(value) : null).andThen((item) => item === null ? AsyncResult.ok(null) : decorate([item], getOptions).map((items) => items[0] ?? null));
+		},
+		list(listOptions = {}) {
+			return run("list_notifications", {
+				...filtersOf(listOptions),
+				...cursorOf(pageOf(listOptions).cursor),
+				max_items: listOptions.limit ?? 50
+			}, itemsOf).andThen((items) => decorate(items, listOptions));
+		},
+		page(pageOptions = {}) {
+			return run("notification_page", {
+				...filtersOf(pageOptions),
+				max_items: pageOptions.limit ?? 50,
+				skip: pageOptions.offset ?? 0
+			}, (value) => ({
+				items: itemsOf(isRecord(value) ? value["items"] : []),
+				total: Number(isRecord(value) ? value["total"] ?? 0 : 0)
+			})).andThen((found) => decorate(found.items, pageOptions).map((items) => ({
+				items,
+				total: found.total
+			})));
+		},
+		counts(countOptions = {}) {
+			return run("notification_counts", {
+				tenant: countOptions.tenant ?? null,
+				actionable: options.actionable ?? []
+			}, (value) => ({
+				unread: Number(isRecord(value) ? value["unread"] ?? 0 : 0),
+				actionable: Number(isRecord(value) ? value["actionable"] ?? 0 : 0),
+				actionableSubjects: Number(isRecord(value) ? value["actionable_subjects"] ?? 0 : 0)
+			}));
+		},
+		markRead(readOptions = {}) {
+			return run("mark_notifications_read", {
+				ids: readOptions.ids ?? null,
+				tenant: readOptions.tenant ?? null
+			}, updateOf);
+		},
+		markUnread(unreadOptions) {
+			return run("mark_notifications_unread", {
+				ids: unreadOptions.ids,
+				tenant: unreadOptions.tenant ?? null
+			}, updateOf);
+		},
+		dismiss(ids) {
+			return run("dismiss_notifications", { ids }, updateOf);
+		},
+		resolve(input) {
+			return run("resolve_notifications", {
+				type: input.type,
+				subject_type: input.subject.type,
+				subject_id: input.subject.id,
+				tenant: input.tenant ?? null
+			}, updateOf);
+		},
+		subscribe(input) {
+			return run("set_notification_subscription", {
+				subject_type: input.subject.type,
+				subject_id: input.subject.id,
+				level: input.level,
+				tenant: input.tenant ?? null,
+				member: input.userId ?? null,
+				if_absent: input.ifAbsent
+			}, () => void 0);
+		},
+		subscriptions(subscriptionOptions = {}) {
+			return run("list_notification_subscriptions", {
+				tenant: subscriptionOptions.tenant ?? null,
+				subject_type: subscriptionOptions.subject?.type ?? null,
+				subject_id: subscriptionOptions.subject?.id ?? null
+			}, (value) => (Array.isArray(value) ? value : []).filter(isRecord).flatMap((row) => {
+				const level = LEVELS.find((entry) => entry === row["level"]);
+				return level === void 0 ? [] : [{
+					subject: {
+						type: String(row["subject_type"]),
+						id: String(row["subject_id"])
+					},
+					level,
+					tenant: nullableText(row["tenant"]),
+					createdAt: nullableInstant(row["created_at"])
+				}];
+			}));
+		},
+		preferences(preferenceOptions = {}) {
+			return run("list_notification_preferences", { tenant: preferenceOptions.tenant ?? null }, (value) => (Array.isArray(value) ? value : []).filter(isRecord).map((row) => ({
+				type: String(row["type"]),
+				channel: String(row["channel"]),
+				enabled: row["enabled"] === true,
+				tenant: nullableText(row["tenant"])
+			})));
+		},
+		setPreference(input) {
+			return run("set_notification_preference", {
+				type: input.type,
+				channel: input.channel,
+				enabled: input.enabled,
+				tenant: input.tenant ?? null
+			}, () => void 0);
+		},
+		async deliver(deliverOptions = {}) {
+			const wanted = deliverOptions.channels;
+			const channels = (options.channels ?? []).filter((channel) => !wanted || wanted.includes(channel.name));
+			const deadline = deliverOptions.budgetMs === void 0 ? Number.POSITIVE_INFINITY : Date.now() + deliverOptions.budgetMs;
+			const batch = deliverOptions.batch ?? 50;
+			const counts = {
+				sent: 0,
+				skipped: 0,
+				failed: 0
+			};
+			await Promise.all(channels.map(async (channel) => {
+				while (Date.now() < deadline) {
+					const claimed = await call("claim_notification_deliveries", {
+						channel: channel.name,
+						max_items: batch,
+						lease: deliverOptions.lease ?? "5 minutes",
+						max_attempts: deliverOptions.maxAttempts ?? 5
+					});
+					const rows = (Array.isArray(claimed) ? claimed : []).filter(isRecord);
+					for (const row of rows) counts[await deliverOne(channel, row, deliverOptions.maxAttempts ?? 5)] += 1;
+					if (rows.length < batch) break;
+				}
+			}));
+			return counts;
+		},
+		purge(olderThan, batch) {
+			return run("purge_notifications", {
+				older_than: olderThan ?? null,
+				batch: batch ?? null
+			}, Number);
+		},
+		sink(sinkOptions) {
+			const prefix = sinkOptions.typePrefix ?? "dev.better-supabase.";
+			return { async send(events) {
+				for (const event of events) {
+					const type = event.type.startsWith(prefix) ? event.type.slice(prefix.length) : event.type;
+					const mapped = await sinkOptions.map({
+						...event,
+						type
+					});
+					if (mapped === null) continue;
+					const { type: notificationType, ...rest } = mapped;
+					const input = rest;
+					const tenant = typeof event["partitionkey"] === "string" ? event["partitionkey"] : void 0;
+					await hooked.send(notificationType, {
+						...input,
+						key: input.key ?? event.id,
+						...input.tenant === void 0 && tenant !== void 0 ? { tenant } : {}
+					}).orThrow();
+				}
+			} };
+		}
+	}, options.hooks, {
+		block: "notifications",
+		...options.events ? { logger: options.events.logger } : {}
+	});
+	return hooked;
+}
+//#endregion
+export { createNotifications, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/notifications/react/index.d.ts

@@ -0,0 +1,44 @@
+import { x as SubscriptionStatus } from "../../../index-DunNRdnT.js";
+//#region src/blocks/notifications/react/index.d.ts
+/** Loads one list of items, e.g. a server action that calls `notifications.list()`. */
+export type NotificationSource<T> = () => Promise<readonly T[]>;
+export interface UseNotificationsOptions<T> {
+  /**
+   * The private topic the `notifications` module broadcasts to, e.g.
+   * `notifications:${userId}` (`sql.modules.notifications.options.topic`). `null`
+   * loads once without realtime.
+   */
+  readonly topic: string | null;
+  /** The notifications, newest first. */
+  readonly load: NotificationSource<T>;
+  /** More items merged in, such as running jobs or pending approvals. */
+  readonly sources?: readonly NotificationSource<T>[];
+  /** Orders the merged list. Defaults to the order the sources return. */
+  readonly sort?: (a: T, b: T) => number;
+  /** The badge number. Defaults to the items without a `readAt`. */
+  readonly count?: (items: readonly T[]) => number;
+  /** Runs for each broadcast, e.g. to show a toast for `notification_created`. */
+  readonly onMessage?: (event: string, payload: unknown) => void;
+}
+export interface NotificationsState<T> {
+  /** `undefined` until the first load. */
+  readonly items: readonly T[] | undefined;
+  readonly count: number;
+  readonly status: SubscriptionStatus;
+  readonly error: unknown;
+  /** Loads again, e.g. after marking items read. */
+  readonly refresh: () => Promise<void>;
+}
+/**
+ * The signed-in user's notifications, kept current: loads them, then loads
+ * again after each broadcast on `topic` and after the channel rejoins.
+ *
+ * ```tsx
+ * const { items, count } = useNotifications({
+ *   topic: `organization:${organizationId}:notifications:${userId}`,
+ *   load: () => listNotifications(organizationId),
+ * });
+ * ```
+ */
+export declare function useNotifications<T>(options: UseNotificationsOptions<T>): NotificationsState<T>;
+//#endregion

package/dist/blocks/notifications/react/index.js

@@ -0,0 +1,67 @@
+"use client";
+import { i as useAuth, l as useSupabase } from "../../../hooks-1BTCJsiw.js";
+import { t as watchTopic } from "../../../react-topic-seAWjL3_.js";
+import { useCallback, useEffect, useRef, useState } from "react";
+//#region src/blocks/notifications/react/index.ts
+const unread = (items) => items.filter((item) => typeof item === "object" && item !== null && "readAt" in item && item.readAt === null).length;
+/**
+* The signed-in user's notifications, kept current: loads them, then loads
+* again after each broadcast on `topic` and after the channel rejoins.
+*
+* ```tsx
+* const { items, count } = useNotifications({
+*   topic: `organization:${organizationId}:notifications:${userId}`,
+*   load: () => listNotifications(organizationId),
+* });
+* ```
+*/
+function useNotifications(options) {
+	const supabase = useSupabase();
+	const auth = useAuth();
+	const [items, setItems] = useState(void 0);
+	const [error, setError] = useState(void 0);
+	const [status, setStatus] = useState("closed");
+	const latest = useRef(options);
+	latest.current = options;
+	const userId = auth.user?.id ?? null;
+	const refresh = useCallback(async () => {
+		const current = latest.current;
+		try {
+			const merged = (await Promise.all([current.load, ...current.sources ?? []].map((source) => source()))).flat();
+			setItems(current.sort ? [...merged].sort(current.sort) : merged);
+			setError(void 0);
+		} catch (cause) {
+			setError(cause);
+		}
+	}, []);
+	const topic = options.topic;
+	useEffect(() => {
+		if (auth.status !== "signed-in") return;
+		refresh();
+		if (!topic) return;
+		return watchTopic(supabase, topic, {
+			onMessage: (event, payload) => {
+				latest.current.onMessage?.(event, payload);
+				refresh();
+			},
+			onRejoin: () => void refresh(),
+			onStatus: setStatus
+		});
+	}, [
+		supabase,
+		topic,
+		userId,
+		auth.status,
+		refresh
+	]);
+	const list = items ?? [];
+	return {
+		items,
+		count: (options.count ?? unread)(list),
+		status,
+		error,
+		refresh
+	};
+}
+//#endregion
+export { useNotifications };

package/dist/blocks/notifications/react/server.d.ts

@@ -0,0 +1,6 @@
+import { NotificationSource, NotificationsState, UseNotificationsOptions } from "./index.js";
+//#region src/blocks/notifications/react/server.d.ts
+/** The `react-server` build of `useNotifications`: call `notifications.list()` instead. */
+export declare const useNotifications: <T>(options: UseNotificationsOptions<T>) => NotificationsState<T>;
+//#endregion
+export type { NotificationSource, NotificationsState, UseNotificationsOptions };

package/dist/blocks/notifications/react/server.js

@@ -0,0 +1,7 @@
+//#region src/blocks/notifications/react/server.ts
+/** The `react-server` build of `useNotifications`: call `notifications.list()` instead. */
+const useNotifications = () => {
+	throw new Error("better-supabase: useNotifications() runs in Client Components only. In Server Components call `notifications.list()` instead.");
+};
+//#endregion
+export { useNotifications };

package/dist/blocks/onboarding/index.d.ts

@@ -0,0 +1,3 @@
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { a as ChecklistScope, c as ChecklistSubject, i as ChecklistProgress, l as StepProgress, n as ChecklistClient, o as ChecklistSpec, r as ChecklistConnectOptions, s as ChecklistStep, t as Checklist, u as defineChecklist } from "../../onboarding-BZGHYJks.js";
+export { type BlockTransport, type Checklist, type ChecklistClient, type ChecklistConnectOptions, type ChecklistProgress, type ChecklistScope, type ChecklistSpec, type ChecklistStep, type ChecklistSubject, type StepProgress, defineChecklist, rpcTransport, sqlTransport };

package/dist/blocks/onboarding/index.js

@@ -0,0 +1,64 @@
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { O as textOf, h as optionalText, i as blockCall, m as optionalInstant, n as applyTemporal, x as recordsOf } from "../../block-helpers-DWHxHsEQ.js";
+//#region src/blocks/onboarding/onboarding.ts
+const ID = /^[a-z][a-z0-9_.-]{0,63}$/;
+/**
+* Declares an onboarding checklist. Pass the result to
+* `sql.modules.onboarding.options.checklists` so the database knows its
+* steps, and `connect` it to read and complete them.
+*/
+function defineChecklist(spec) {
+	if (!ID.test(spec.id)) throw new TypeError(`defineChecklist: "${spec.id}" is not a checklist id`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const step of spec.steps) {
+		if (!ID.test(step.id) || seen.has(step.id)) throw new TypeError(`defineChecklist(${spec.id}): step "${step.id}" is not a unique step id`);
+		seen.add(step.id);
+	}
+	return {
+		...spec,
+		connect: (options) => connectChecklist(spec, options)
+	};
+}
+function connectChecklist(spec, options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const tenantOf = (subject) => ({ tenant: subject[0] ?? null });
+	return {
+		progress: (...subject) => call("onboarding_progress", {
+			checklist: spec.id,
+			...tenantOf(subject)
+		}, (value) => progressOf(spec.steps, value)),
+		complete: (step, ...subject) => call("complete_onboarding_step", {
+			checklist: spec.id,
+			step,
+			...tenantOf(subject)
+		}, (value) => value === true),
+		reset: (step, ...subject) => call("reset_onboarding_step", {
+			checklist: spec.id,
+			step,
+			...tenantOf(subject)
+		}, (value) => value === true)
+	};
+}
+function progressOf(steps, value) {
+	const rows = new Map(recordsOf(value, "onboarding_progress").map((row) => [textOf(row["step"]), row]));
+	const list = steps.map((step) => {
+		const row = rows.get(step.id);
+		return {
+			...step,
+			completed: row !== void 0,
+			completedAt: optionalInstant(row?.["completedAt"]),
+			completedBy: optionalText(row?.["completedBy"])
+		};
+	});
+	const completed = list.filter((step) => step.completed).length;
+	return {
+		steps: list,
+		completed,
+		total: list.length,
+		done: completed === list.length,
+		next: list.find((step) => !step.completed)
+	};
+}
+//#endregion
+export { defineChecklist, rpcTransport, sqlTransport };

package/dist/blocks/onboarding/react/index.d.ts

@@ -0,0 +1,28 @@
+import { b as DbError } from "../../../result-D7y2fT87.js";
+import { a as ChecklistScope, i as ChecklistProgress, t as Checklist } from "../../../onboarding-BZGHYJks.js";
+//#region src/blocks/onboarding/react/index.d.ts
+export interface UseOnboardingOptions {
+  /** The organization, for an organization checklist. */
+  readonly organizationId?: string | null;
+  /** The schema the calls go to: the module schema (default `better_supabase`), or the API schema from `sql.modules.<module>.api`. */
+  readonly schema?: string;
+}
+export interface OnboardingState<Id extends string> {
+  /** `undefined` until the first load. */
+  readonly progress: ChecklistProgress<Id> | undefined;
+  readonly error: DbError | undefined;
+  /** Marks a step done, then loads the progress again. */
+  readonly complete: (step: Id) => Promise<void>;
+  readonly reset: (step: Id) => Promise<void>;
+  readonly refresh: () => Promise<void>;
+}
+/**
+ * A checklist's progress for the signed-in user, or for an organization
+ * with `organizationId`, through the browser client.
+ *
+ * ```tsx
+ * const { progress, complete } = useOnboarding(gettingStarted, { organizationId });
+ * ```
+ */
+export declare function useOnboarding<Id extends string, Scope extends ChecklistScope>(checklist: Checklist<Id, Scope>, options?: UseOnboardingOptions): OnboardingState<Id>;
+//#endregion