@vercel/board 0.0.0-stage → 0.15.0

package/dist/client-DGDPaN7U.mjs

@@ -0,0 +1,380 @@
+import { a as typeOf, n as DIRECT_UPLOAD_BYTES_MAX, t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
+import { r as normalizeEmoji } from "./emoji-CTLpvH-A.mjs";
+//#region src/client/sse.ts
+/** Parses a text/event-stream body into messages. */
+async function* parseSse(body, signal) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	const onAbort = () => void reader.cancel().catch(() => {});
+	signal?.addEventListener("abort", onAbort, { once: true });
+	try {
+		while (true) {
+			const { value, done } = await reader.read();
+			if (done) return;
+			buffer += decoder.decode(value, { stream: true });
+			let boundary;
+			while ((boundary = buffer.search(/\r?\n\r?\n/)) !== -1) {
+				const block = buffer.slice(0, boundary);
+				buffer = buffer.slice(boundary).replace(/^\r?\n\r?\n/, "");
+				const message = {};
+				const data = [];
+				for (const line of block.split(/\r?\n/)) {
+					if (line === "" || line.startsWith(":")) continue;
+					const colon = line.indexOf(":");
+					const field = colon === -1 ? line : line.slice(0, colon);
+					const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+					if (field === "data") data.push(value);
+					else if (field === "id") message.id = value;
+					else if (field === "event") message.event = value;
+				}
+				if (data.length > 0) message.data = data.join("\n");
+				if (message.id !== void 0 || message.data !== void 0) yield message;
+			}
+		}
+	} finally {
+		signal?.removeEventListener("abort", onAbort);
+		reader.releaseLock();
+	}
+}
+//#endregion
+//#region src/client/client.ts
+var BoardError = class extends Error {
+	code;
+	status;
+	constructor(code, message, status) {
+		super(message);
+		this.name = "BoardError";
+		this.code = code;
+		this.status = status;
+	}
+};
+const resolve = async (value) => typeof value === "function" ? await value() : value;
+const scheduleBody = (input) => {
+	const { at, until, ...rest } = messageBody(input);
+	return {
+		...rest,
+		...at !== void 0 ? { at: at instanceof Date ? at.toISOString() : at } : {},
+		...until !== void 0 ? { until: until instanceof Date ? until.toISOString() : until } : {}
+	};
+};
+const messageBody = (input) => {
+	if (typeof input === "string") return { text: input };
+	const { attachments, ...rest } = input;
+	return attachments?.length ? {
+		...rest,
+		attachments: attachments.map((a) => typeof a === "string" ? a : a.id)
+	} : rest;
+};
+const UNITS = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5
+};
+function duration(value) {
+	if (typeof value === "number") return value;
+	const match = value.trim().match(/^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/);
+	if (!match) throw new BoardError("invalid_duration", `invalid duration: ${value}`, 0);
+	return Number(match[1]) * UNITS[match[2] ?? "ms"];
+}
+/** A ref as a path segment: opaque, so it's encoded as it is. */
+const path = (id) => encodeURIComponent(id);
+function queryString(query) {
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0 || value === null) continue;
+		if (key === "label") {
+			const labels = Array.isArray(value) ? value : typeof value === "object" ? Object.entries(value).map(([k, v]) => `${k}=${String(v)}`) : [value];
+			for (const label of labels) params.append("label", String(label));
+		} else params.set(key, String(value));
+	}
+	const text = params.toString();
+	return text ? `?${text}` : "";
+}
+const written = (value, unknownMentions) => unknownMentions?.length ? {
+	...value,
+	unknownMentions
+} : value;
+function createBoardClient(options) {
+	const base = options.url.replace(/\/+$/, "");
+	const doFetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+	const storeFetch = options.storeFetch ?? ((input, init) => globalThis.fetch(input, init));
+	async function headers(auth, as) {
+		const out = { ...options.headers ? await resolve(options.headers) : {} };
+		if (!auth) return out;
+		if (options.token !== void 0) out.authorization = `Bearer ${await resolve(options.token)}`;
+		const profile = as !== void 0 ? as : options.profile === void 0 ? null : await resolve(options.profile);
+		if (profile !== null) {
+			const { name, avatar } = typeof profile === "string" ? {
+				name: profile,
+				avatar: void 0
+			} : profile;
+			out["x-board-profile"] = name;
+			if (avatar) out["x-board-avatar"] = avatar;
+		} else {
+			const person = options.person === void 0 ? null : await resolve(options.person);
+			if (person?.name) out["x-board-name"] = encodeURIComponent(person.name);
+			if (person?.avatar) out["x-board-avatar"] = person.avatar;
+		}
+		const session = as !== void 0 ? null : options.session === void 0 ? null : await resolve(options.session);
+		if (session) out["x-board-session"] = session;
+		const handle = options.handle === void 0 ? null : await resolve(options.handle);
+		if (handle) out["x-board-handle"] = handle;
+		return out;
+	}
+	async function raw(method, path, init = {}) {
+		const response = await doFetch(`${base}${path}`, {
+			method,
+			headers: {
+				...await headers(init.auth ?? true),
+				...init.body === void 0 ? {} : { "content-type": "application/json" },
+				...init.headers
+			},
+			...init.body === void 0 ? {} : { body: JSON.stringify(init.body) },
+			...init.signal ? { signal: init.signal } : {}
+		});
+		if (!response.ok) throw await toError(response);
+		return response;
+	}
+	async function call(method, path, init) {
+		return await (await raw(method, path, init)).json();
+	}
+	const filtersQuery = (filters = {}) => filters;
+	async function poll(query = {}, signal) {
+		return call("GET", `/events${queryString(query)}`, signal ? { signal } : {});
+	}
+	return {
+		url: base,
+		/**
+		* The board's HTTP API with this client's credentials, and the response as
+		* the board sent it, errors included: for proxies like `vb inspect`.
+		*/
+		request: async (path, init = {}) => doFetch(`${base}${path}`, {
+			method: init.method ?? "GET",
+			headers: {
+				...init.headers,
+				...await headers(true, init.as)
+			},
+			...init.body ? { body: init.body } : {},
+			...init.signal ? { signal: init.signal } : {}
+		}),
+		discovery: () => call("GET", "/", { auth: false }),
+		me: () => call("GET", "/me"),
+		channels: async () => (await call("GET", "/channels")).channels,
+		actors: async () => (await call("GET", "/actors")).actors,
+		/** Your linked platform accounts, and the sync entries you haven't linked (`unlinked`). */
+		identity: () => call("GET", "/identity"),
+		/** Unlinks one of your accounts, by actor ID or handle. History keeps its messages as they were. */
+		unlinkAccount: (account) => call("POST", "/identity/unlink", { body: { actor: account } }),
+		messages: (query = {}) => call("GET", `/messages${queryString(query)}`),
+		thread: (id) => call("GET", `/messages/${path(id)}`),
+		/** Your own post with the client ID you gave it, as posting it answered: 404 `post_not_found` when there's none. */
+		posted: async (id) => (await call("GET", `/posts/${path(id)}`)).message,
+		/** Threads with a matching message, one summary each (root, reply count, latest reply), by latest activity. `limit` counts threads. */
+		threads: (query = {}) => call("GET", `/threads${queryString(query)}`),
+		/** `unknownMentions` lists the handles that matched nobody: they posted as plain text. */
+		async post(channel, input) {
+			const { message, unknownMentions } = await call("POST", "/messages", { body: {
+				channel,
+				...messageBody(input)
+			} });
+			return written(message, unknownMentions);
+		},
+		async reply(id, input) {
+			const { message, unknownMentions } = await call("POST", "/messages", { body: {
+				re: id,
+				...messageBody(input)
+			} });
+			return written(message, unknownMentions);
+		},
+		/**
+		* Posts later, as you: a new thread when `target` is a channel, a reply when it's
+		* `{ re }`, any message's ID in the thread. Each message it posts carries
+		* `schedule: { id, n }`. Needs a board with a scheduler.
+		*/
+		async schedule(target, input) {
+			const { schedule, unknownMentions } = await call("POST", "/schedules", { body: {
+				...typeof target === "string" ? { channel: target } : { re: target.re },
+				...scheduleBody(input)
+			} });
+			return written(schedule, unknownMentions);
+		},
+		/** Pending schedules (`all` for done and canceled too), oldest first. `re` is any message in a thread. */
+		schedules: async (query = {}) => (await call("GET", `/schedules${queryString(query)}`)).schedules,
+		/** Stops a schedule: yours, or any with manage in its channel. `canceled` is false when it was already done or canceled. */
+		cancelSchedule: (id) => call("POST", `/schedules/${path(id)}/cancel`, { body: {} }),
+		/**
+		* Stores a file on the board, for a post or reply's `attachments`. Up to 4 MB goes in one
+		* request; bigger, up to 100 MB, goes straight to the board's blob store on a URL the board
+		* signs, where its store can (`no_direct_uploads` where it can't).
+		*/
+		async upload(input) {
+			const type = input.type || (input.data instanceof Blob ? input.data.type : "") || typeOf(input.name);
+			const size = input.data instanceof Blob ? input.data.size : input.data.byteLength;
+			if (size > 4194304) {
+				if (size > 104857600) throw new BoardError("too_large", `attachments are at most ${DIRECT_UPLOAD_BYTES_MAX / 1024 / 1024} MB`, 413);
+				const ticket = await call("POST", "/attachments/uploads", { body: {
+					name: input.name,
+					type,
+					size
+				} }).catch((error) => {
+					if (error instanceof BoardError && error.status === 404 && error.code === "not_found") throw new BoardError("too_large", `this board takes files of at most ${ATTACHMENT_BYTES_MAX / 1024 / 1024} MB`, 413);
+					throw error;
+				});
+				const put = await storeFetch(ticket.url, {
+					method: "PUT",
+					headers: ticket.headers,
+					body: input.data
+				});
+				if (!put.ok) throw new BoardError("upload_failed", `the blob store refused the file: ${put.status} ${(await put.text().catch(() => "")).slice(0, 300) || put.statusText}`, put.status);
+				return (await call("POST", `/attachments/uploads/${encodeURIComponent(ticket.id)}`, { body: {} })).attachment;
+			}
+			const response = await doFetch(`${base}/attachments`, {
+				method: "POST",
+				headers: {
+					...await headers(true),
+					"content-type": type,
+					"x-board-filename": encodeURIComponent(input.name)
+				},
+				body: input.data
+			});
+			if (!response.ok) throw await toError(response);
+			return (await response.json()).attachment;
+		},
+		/** An attachment's bytes, as the board serves them: `content-type` is the file's type. */
+		download: (id, opts = {}) => raw("GET", `/attachments/${encodeURIComponent(id)}`, opts.signal ? { signal: opts.signal } : {}),
+		edit: (id, text) => call("POST", `/messages/${path(id)}/edit`, { body: { text } }),
+		delete: (id) => call("POST", `/messages/${path(id)}/delete`, { body: {} }),
+		/** `emoji` is a short name, `:name:`, or the character itself. */
+		react: (id, emoji, opts = {}) => call("POST", `/messages/${path(id)}/reactions`, { body: {
+			emoji: normalizeEmoji(emoji),
+			...opts
+		} }),
+		label: (id, change) => call("POST", `/messages/${path(id)}/labels`, { body: change }),
+		/**
+		* Shows typing in the platform threads the message's thread is synced to
+		* (on WhatsApp, also marking the latest inbound message read). Ephemeral:
+		* nothing goes in the log. Answers the external threads that took it.
+		* `status` replaces "Typing…" on Slack ("running tests…").
+		*/
+		typing: async (id, status) => (await call("POST", `/messages/${path(id)}/typing`, { body: status ? { status } : {} })).targets,
+		/** Attaches the message's thread to an external target, backfilling it. Attaching twice is a no-op. */
+		sync: (id, target) => call("POST", `/messages/${path(id)}/sync`, { body: { target } }),
+		/** Raw platform events for a sync entry, newest first. */
+		inbox: async (key, opts = {}) => (await call("GET", `/inbox/${key}${queryString(opts)}`)).events,
+		/** Registers the caller's watchers, replacing its last registration: what a board on `http()` does. */
+		register: (input) => call("POST", "/watchers", { body: input }),
+		/** Registered watchers: every one to `manage` everywhere, the caller's own to anyone else. */
+		watchers: async () => (await call("GET", "/watchers")).watchers,
+		/** The caller's matches it can run now, each leased to it until it acks. `wait` holds the request up to that many seconds for one. */
+		matches: async (opts = {}) => {
+			const { signal, ...query } = opts;
+			return (await call("GET", `/watchers/matches${queryString(query)}`, signal ? { signal } : {})).matches;
+		},
+		/** How a pulled match went: done, an error to try again, or `skip` to drop it. */
+		ack: (id, body) => call("POST", `/watchers/matches/${encodeURIComponent(id)}/ack`, { body }),
+		/**
+		* Reads a platform channel (`#name`, an ID), thread (`C0123:1727000000.123456`),
+		* or message permalink on demand, without syncing or storing it. Full access only.
+		*/
+		readSource: (key, target, opts = {}) => call("GET", `/sources/${key}/read${queryString({
+			target,
+			...opts
+		})}`),
+		poll,
+		/** A platform's write, as its platform author: idempotent per platform event for a post, found from its origin otherwise. */
+		syncImport: (body) => call("POST", "/sync/imports", { body }),
+		/** What sync did on a platform: a delivery, its files, a failure, or a thread's new target. */
+		syncReceipt: (body) => call("POST", "/sync/receipts", { body }),
+		/** A board thread's sync, by its key. */
+		syncThread: (thread) => call("GET", `/sync/threads/${path(thread)}`),
+		/** What platform IDs are on the board: a thread, a message, who an account is, a person's accounts. */
+		syncFind: (query, opts = {}) => call("GET", `/sync/find${queryString(query)}`, opts.signal ? { signal: opts.signal } : {}),
+		/** Messages' copies on platforms, by message and target. */
+		syncCopies: async (messages) => (await call("GET", `/sync/copies?${messages.map((id) => `message=${encodeURIComponent(id)}`).join("&")}`)).copies,
+		/** A person's roots since `since`. */
+		syncRoots: async (by, since) => (await call("GET", `/sync/roots${queryString({
+			by,
+			since: since instanceof Date ? since.getTime() : since
+		})}`)).roots,
+		/** Pushes platform events into your inbox for sync key `key`; each platform ID lands once. */
+		inboxPush: (key, events) => call("POST", `/inbox/${path(key)}`, { body: { events } }),
+		/** Your next inbox events for `key`, leased to you until you ack them, one platform thread at a time. */
+		inboxNext: async (key, opts = {}) => (await call("GET", `/inbox/${path(key)}/next${queryString(opts)}`)).items,
+		/** How an inbox event went: done, or an error to try it again. */
+		inboxAck: (key, id, body) => call("POST", `/inbox/${path(key)}/${path(id)}/ack`, { body }),
+		/**
+		* A one-time code for linking your account on sync entry `sync`, to post from that account where
+		* the board syncs, and `signIn` when the entry signs people in: open it (only you) and approve.
+		* Only people get one, each for themselves. `identity()` shows the link once it's made.
+		*/
+		syncCode: (sync) => call("POST", "/sync/codes", { body: { sync } }),
+		/** Links a platform account to whoever a code was issued to: one posted from it, or carried through its sign-in. */
+		syncAccount: (body) => call("POST", "/sync/accounts", { body }),
+		/** Unlinks a platform account: your own, or anyone's with `sync`. */
+		syncUnlink: (account) => call("POST", "/sync/accounts/unlink", { body: { account } }),
+		/** Live events. Reconnects from the last seen index whenever the stream closes. */
+		async *events(query = {}, opts = {}) {
+			let after = query.after;
+			let failures = 0;
+			while (!opts.signal?.aborted) {
+				let response;
+				try {
+					response = await raw("GET", `/events${queryString({
+						...filtersQuery(query),
+						after
+					})}`, {
+						headers: { accept: "text/event-stream" },
+						...opts.signal ? { signal: opts.signal } : {}
+					});
+				} catch (error) {
+					if (opts.signal?.aborted) return;
+					if (error instanceof BoardError && error.status >= 400 && error.status < 500) throw error;
+					await new Promise((r) => setTimeout(r, Math.min(3e4, 500 * 2 ** failures++)));
+					continue;
+				}
+				failures = 0;
+				try {
+					for await (const message of parseSse(response.body, opts.signal)) {
+						if (message.id !== void 0) after = message.id;
+						if (message.event === "board" && message.data) yield JSON.parse(message.data);
+					}
+				} catch (error) {
+					if (opts.signal?.aborted) return;
+					await new Promise((r) => setTimeout(r, Math.min(3e4, 500 * 2 ** failures++)));
+				}
+			}
+		},
+		/** The next matching event after `after` (default: now), or null on timeout. */
+		async wait(query = {}, opts = {}) {
+			const deadline = Date.now() + duration(opts.timeout ?? "30m");
+			let after = query.after ?? (await poll({
+				...query,
+				after: void 0,
+				wait: 0
+			}, opts.signal)).cursor;
+			while (Date.now() < deadline && !opts.signal?.aborted) {
+				const wait = Math.max(0, Math.min(25, Math.ceil((deadline - Date.now()) / 1e3)));
+				const page = await poll({
+					...query,
+					after,
+					wait
+				}, opts.signal);
+				if (page.events.length > 0) return page.events[0];
+				after = page.cursor;
+			}
+			return null;
+		}
+	};
+}
+async function toError(response) {
+	try {
+		const body = await response.json();
+		if (body.error?.message) return new BoardError(body.error.code ?? "error", body.error.message, response.status);
+	} catch {}
+	return new BoardError("http_error", `${response.status} ${response.statusText}`, response.status);
+}
+//#endregion
+export { createBoardClient as n, duration as r, BoardError as t };