@vercel/board 0.16.0 → 0.17.0

package/dist/exports-DLiE7fLY.d.mts

@@ -1,4 +0,0 @@
-import "./auth-CU56Q2Xh.mjs";
-import "./schemas-CWxs3ECJ.mjs";
-import "./provider-BGjz-mDa.mjs";
-import "./a2-D24cvwpN.mjs";

package/dist/provider-CuewcDNZ.mjs

@@ -1,205 +0,0 @@
-import { d as LabelKey, p as Labels } from "./schemas-Be08nyfW.mjs";
-import { i as ExternalLocation, r as ExternalEvent } from "./contract-CuJmlrhw.mjs";
-import { z } from "zod";
-//#region src/sync/events.ts
-const EventBase = z.object({
-	id: z.string().min(1),
-	platform: z.string().min(1),
-	key: z.string().min(1),
-	...ExternalLocation.shape,
-	raw: z.unknown()
-});
-const eventTypes = {
-	message: "message",
-	edited: "message.edited",
-	deleted: "message.deleted",
-	reaction: "reaction.added",
-	lifecycle: "lifecycle"
-};
-function envelope(platform, key, event, raw, id) {
-	return {
-		...event,
-		...EventBase.parse({
-			id,
-			platform,
-			key,
-			channel: event.channel,
-			thread: event.thread,
-			subthread: "subthread" in event ? event.subthread : null,
-			raw
-		}),
-		type: event.kind === "lifecycle" ? event.type : event.kind === "reaction" && !event.added ? "reaction.removed" : eventTypes[event.kind]
-	};
-}
-function eventSchema(platform, messageType) {
-	const [message, edited, deleted, reaction, lifecycle] = ExternalEvent.options;
-	const common = {
-		...EventBase.shape,
-		platform: z.literal(platform)
-	};
-	return z.discriminatedUnion("kind", [
-		message.extend({
-			...common,
-			type: z.literal(messageType)
-		}),
-		edited.extend({
-			...common,
-			type: z.literal("message.edited")
-		}),
-		deleted.extend({
-			...common,
-			type: z.literal("message.deleted")
-		}),
-		reaction.extend({
-			...common,
-			type: z.enum(["reaction.added", "reaction.removed"])
-		}),
-		lifecycle.extend(common)
-	]);
-}
-const SyncOverrides = z.object({
-	root: z.custom((value) => typeof value === "function").optional(),
-	text: z.string().optional(),
-	labels: Labels.optional(),
-	unset: z.array(LabelKey).optional(),
-	noSync: z.boolean().optional()
-}).strict();
-function immutable(value) {
-	if (value && typeof value === "object") {
-		for (const item of Object.values(value)) immutable(item);
-		Object.freeze(value);
-	}
-	return value;
-}
-//#endregion
-//#region src/sync/provider.ts
-const ResolvedTarget = z.object({
-	target: z.string().min(1),
-	channel: z.string().min(1),
-	kind: z.enum(["channel", "thread"])
-}).strict();
-/** Why a platform wouldn't read a channel or thread on demand. Its message is shown as is. */
-var UnreadableError = class extends Error {
-	code;
-	constructor(code, message) {
-		super(message);
-		this.code = code;
-	}
-};
-const ReceivedEvent = z.object({
-	event: ExternalEvent,
-	raw: z.unknown(),
-	dedupe: z.string().min(1)
-});
-var SyncProvider = class {
-	platform;
-	canStartThreads;
-	singleReaction;
-	uploadsFiles;
-	mappings = {};
-	/** People's tokens, when the adapter has them: messages they write post as them. */
-	users;
-	options;
-	constructor(options) {
-		this.options = options;
-		this.users = options.users ?? null;
-		this.platform = options.platform;
-		this.canStartThreads = options.canStartThreads ?? false;
-		this.singleReaction = options.singleReaction ?? false;
-		this.uploadsFiles = options.uploadsFiles ?? false;
-	}
-	/** The platform account a person's token belongs to. */
-	async whoAmI(_token) {
-		throw new Error(`${this.platform} can't post as a person`);
-	}
-	/** `post`, as the person whose token this is. */
-	async postAs(_token, _target, _kind, _body) {
-		throw new Error(`${this.platform} can't post as a person`);
-	}
-	async editAs(_token, _thread, _message, _body) {}
-	async deleteAs(_token, _thread, _message) {}
-	async findByEmail(_email) {
-		return null;
-	}
-	mention(_actor) {
-		return null;
-	}
-	async fetchRoot(_thread) {
-		return null;
-	}
-	async fetchFile(_file) {
-		return null;
-	}
-	/** The platform's own link to an event's message, or null when it has none. */
-	async permalink(_event) {
-		return null;
-	}
-	/** A linked message the platform didn't describe, read from the platform. */
-	async fetchLink(_link) {
-		return {
-			snapshot: null,
-			unavailable: `${this.platform} can't read it`
-		};
-	}
-	/**
-	* A channel or thread, read on demand for whoever asked: nothing is synced,
-	* stored, or joined. Throws `UnreadableError` for what it won't read.
-	*/
-	async read(_target, _options) {
-		throw new UnreadableError("unsupported", `${this.platform} can't be read on demand`);
-	}
-	async edit(_thread, _message, _body) {}
-	async delete(_thread, _message) {}
-	async react(_thread, _message, _emoji, _added) {}
-	async startTyping(_thread, _latest, _status) {}
-	/**
-	* The channel whose inbox a thread's events land in (`slack:C0123ABC` for `slack:C0123ABC:1727.1234`),
-	* worked out without calling the platform. Null when the provider can't tell: a key's inbox then
-	* lists only the mapped channels'.
-	*/
-	inboxChannel(_key, _thread) {
-		return null;
-	}
-	async deleteFiles(_ids) {}
-	refusesFiles(_error) {
-		return false;
-	}
-	async uploadFiles(_thread, _files) {
-		throw new Error(`${this.platform} does not support file uploads`);
-	}
-	sync(context, channel, overrides) {
-		return context.apply(channel, overrides);
-	}
-	render(input) {
-		return this.options.render?.(input) ?? `**${input.label}**: ${input.message.text}`;
-	}
-	map(key, value) {
-		if (typeof value === "string") {
-			this.mappings[key] = { channel: value };
-			return;
-		}
-		const handler = typeof value === "function" ? value : value.run;
-		this.mappings[key] = {
-			...typeof value === "object" ? { channel: value.channel } : {},
-			run: (context) => {
-				const event = immutable(this.event(context));
-				let link;
-				const permalink = () => {
-					const promise = link ?? this.permalink(event);
-					link = promise;
-					promise.catch(() => {
-						if (link === promise) link = void 0;
-					});
-					return promise;
-				};
-				return handler({
-					event,
-					board: context.client(event),
-					permalink
-				});
-			}
-		};
-	}
-};
-//#endregion
-export { EventBase as a, eventSchema as c, UnreadableError as i, immutable as l, ResolvedTarget as n, SyncOverrides as o, SyncProvider as r, envelope as s, ReceivedEvent as t };