@seedcord/http 0.5.1 → 0.7.0

package/dist/{RouteManifest-DTxI4fS0.d.mts → RouteManifest-D7qXj8Ts.d.mts}

@@ -1,4 +1,4 @@
-import { SelectMenuKind, SubscriptionKey } from "@seedcord/core";
+import { InteractionKind, SubscriptionKey } from "@seedcord/core";
 import { ApplicationCommandType } from "discord-api-types/v10";
 import { EventFrequency } from "@seedcord/types";
 //#region src/manifest/RouteManifest.d.ts
@@ -27,7 +27,7 @@ interface CommandRoute extends RouteModule {
  * the receiver routes by (the routeKey minus its layout hash).
  */
 interface ComponentRoute extends RouteModule {
-  readonly kind: 'button' | `${SelectMenuKind}Select` | 'modal';
+  readonly kind: InteractionKind.Button | InteractionKind.Modal | InteractionKind.StringMenu | InteractionKind.UserMenu | InteractionKind.RoleMenu | InteractionKind.ChannelMenu | InteractionKind.MentionableMenu;
   readonly prefix: string;
 }
 /**
@@ -61,4 +61,4 @@ interface RouteManifest {
 }
 //#endregion
 export { RouteManifest as t };
-//# sourceMappingURL=RouteManifest-DTxI4fS0.d.mts.map
+//# sourceMappingURL=RouteManifest-D7qXj8Ts.d.mts.map

package/dist/{edge.index-B4x6VSJl.mjs → edge.index-CWUU_d_X.mjs}

@@ -4,13 +4,14 @@ import { SeedcordError, SeedcordTypeError, applicationIdFromToken, validateDisco
 import { Logger } from "@seedcord/logger";
 import { Converters, Envapter } from "envapt";
 import { DiscordAPIError, REST } from "@discordjs/rest";
-import { ArraySourceBase, BaseHandler, BaseReplySender, Bus, CursorSourceBase, DispatchContext, Fault, Notice, PaginatorBase, RepliableHandler, ResolvedEmoji, Silence, Subscriber, WebhookLog } from "@seedcord/core";
+import { ArraySourceBase, BaseHandler, BaseReplySender, Bus, CursorSourceBase, DispatchContext, Fault, InteractionKind, Notice, PaginatorBase, RepliableHandler, ResolvedEmoji, Silence, Subscriber, WebhookLog } from "@seedcord/core";
 import { SeedcordErrorCode, paint } from "@seedcord/errors";
 import { MemoryRateLimiter } from "@seedcord/rate-limiter";
 import { ApplicationCommandOptionType, ApplicationCommandType, ChannelType, ComponentType, InteractionResponseType, InteractionType, MessageFlags, RESTJSONErrorCodes, Routes } from "discord-api-types/v10";
 import { API } from "@discordjs/core/http-only";
 import { buildSlashRoute } from "@seedcord/utils/internal";
 import { prefixOf } from "@seedcord/custom-id";
+import { Collection } from "@discordjs/collection";
 
 //#region src/reply/ReplySender.ts
 function wireAllowedMentions(mentions) {
@@ -139,8 +140,8 @@ function apiFor(rest) {
 * Shared base the repliable HTTP interaction handlers extend.
 *
 * Not a public entry point. Extend {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
-* {@link SelectMenuHandler}, or {@link ContextMenuHandler} instead. This class binds the core reply base
-* to the http sender.
+* {@link ContextMenuHandler}, or one of the select menu bases instead. This class binds the core
+* reply base to the http sender.
 *
 * @typeParam Event - The repliable interaction type this handler processes
 */
@@ -348,8 +349,8 @@ async function handleRawFault(error, uuid, scope) {
 		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
 		return;
 	}
-	const override = core.config.errors?.defaultError;
-	const response = (override ? new override(uuid) : new Fault()).render(renderContext(core, uuid));
+	const Override = core.config.errors?.defaultError;
+	const response = (Override ? new Override(uuid) : new Fault()).render(renderContext(core, uuid));
 	await sendGuarded(scope.routeId, () => sender.send(response, { ephemeral: true }));
 }
 async function handleFault(caught, scope) {
@@ -429,14 +430,14 @@ async function loadHandlerCtor(match, payload, core, report) {
 async function dispatchInteraction(args) {
 	const { match, payload, core } = args;
 	const report = dispatchReporter(match, payload, core);
-	const ctor = await loadHandlerCtor(match, payload, core, report);
-	if (!ctor) return null;
+	const Handler = await loadHandlerCtor(match, payload, core, report);
+	if (!Handler) return null;
 	const routeId = unhandledRouteId(match);
-	logger().debug(`Processing ${paint.sky.bold(routeId)} with ${paint.mute(ctor.name)}`);
+	logger().debug(`Processing ${paint.sky.bold(routeId)} with ${paint.mute(Handler.name)}`);
 	const dispatch = new DispatchContext(routeId);
 	let handler;
 	try {
-		handler = new ctor(payload, core, dispatch);
+		handler = new Handler(payload, core, dispatch);
 	} catch (caught) {
 		await answer(caught, freshScope(match, payload, core), report);
 		return null;
@@ -447,7 +448,7 @@ async function dispatchInteraction(args) {
 		routeId,
 		sender: handler instanceof RepliableHandler$1 ? handler.sender : null
 	};
-	const refusal = await gateRefusal(ctor, match, payload, core);
+	const refusal = await gateRefusal(Handler, match, payload, core);
 	if (refusal) {
 		await answer(refusal.caught, scope, report);
 		return null;
@@ -673,8 +674,8 @@ var UnhandledAutocomplete = class extends AutocompleteHandler {
 * Shared base the repliable interaction handlers extend.
 *
 * Not a public entry point. Extend {@link SlashHandler}, {@link ContextMenuHandler}, {@link ButtonHandler},
-* {@link SelectMenuHandler}, or {@link ModalHandler} instead. This class adds `showModal` on top of the
-* reply members.
+* {@link ModalHandler}, or one of the select menu bases instead. This class adds `showModal` on top
+* of the reply members.
 *
 * @typeParam Event - The repliable interaction type this handler processes
 */
@@ -701,31 +702,22 @@ var UnhandledRepliable = class extends InteractionHandler {
 
 //#endregion
 //#region src/dispatch/resolve.ts
-const COMPONENT_KIND = {
-	button: "button",
-	stringSelect: "stringMenu",
-	userSelect: "userMenu",
-	roleSelect: "roleMenu",
-	channelSelect: "channelMenu",
-	mentionableSelect: "mentionableMenu",
-	modal: "modal"
-};
 function commandKind(type) {
 	switch (type) {
-		case ApplicationCommandType.ChatInput: return "slash";
-		case ApplicationCommandType.User: return "userContextMenu";
-		case ApplicationCommandType.Message: return "messageContextMenu";
+		case ApplicationCommandType.ChatInput: return InteractionKind.Slash;
+		case ApplicationCommandType.User: return InteractionKind.UserContextMenu;
+		case ApplicationCommandType.Message: return InteractionKind.MessageContextMenu;
 		default: return null;
 	}
 }
 function componentMapKey(type) {
 	switch (type) {
-		case ComponentType.Button: return "button";
-		case ComponentType.StringSelect: return "stringSelect";
-		case ComponentType.UserSelect: return "userSelect";
-		case ComponentType.RoleSelect: return "roleSelect";
-		case ComponentType.ChannelSelect: return "channelSelect";
-		case ComponentType.MentionableSelect: return "mentionableSelect";
+		case ComponentType.Button: return InteractionKind.Button;
+		case ComponentType.StringSelect: return InteractionKind.StringMenu;
+		case ComponentType.UserSelect: return InteractionKind.UserMenu;
+		case ComponentType.RoleSelect: return InteractionKind.RoleMenu;
+		case ComponentType.ChannelSelect: return InteractionKind.ChannelMenu;
+		case ComponentType.MentionableSelect: return InteractionKind.MentionableMenu;
 		default: return null;
 	}
 }
@@ -755,22 +747,20 @@ function describeRow(row) {
 */
 function buildRouteMaps(manifest) {
 	const maps = {
-		slash: /* @__PURE__ */ new Map(),
-		userContextMenu: /* @__PURE__ */ new Map(),
-		messageContextMenu: /* @__PURE__ */ new Map(),
-		autocomplete: /* @__PURE__ */ new Map(),
-		components: {
-			button: /* @__PURE__ */ new Map(),
-			stringSelect: /* @__PURE__ */ new Map(),
-			userSelect: /* @__PURE__ */ new Map(),
-			roleSelect: /* @__PURE__ */ new Map(),
-			channelSelect: /* @__PURE__ */ new Map(),
-			mentionableSelect: /* @__PURE__ */ new Map(),
-			modal: /* @__PURE__ */ new Map()
-		}
+		[InteractionKind.Slash]: /* @__PURE__ */ new Map(),
+		[InteractionKind.UserContextMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.MessageContextMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.Autocomplete]: /* @__PURE__ */ new Map(),
+		[InteractionKind.Button]: /* @__PURE__ */ new Map(),
+		[InteractionKind.StringMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.UserMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.RoleMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.ChannelMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.MentionableMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.Modal]: /* @__PURE__ */ new Map()
 	};
 	const owners = /* @__PURE__ */ new Map();
-	function set(map, kind, key, row) {
+	function set(kind, key, row) {
 		const routeId = `${kind}:${key}`;
 		const owner = owners.get(routeId);
 		if (owner) throw new SeedcordError(SeedcordErrorCode.InteractionDuplicateRoute, [
@@ -779,7 +769,7 @@ function buildRouteMaps(manifest) {
 			describeRow(row)
 		]);
 		owners.set(routeId, row);
-		map.set(key, {
+		maps[kind].set(key, {
 			kind,
 			routeId,
 			load: namedExport(routeId, row)
@@ -787,10 +777,10 @@ function buildRouteMaps(manifest) {
 	}
 	for (const row of manifest.commandRoutes) {
 		const kind = commandKind(row.type);
-		if (kind) set(maps[kind], kind, row.name, row);
+		if (kind) set(kind, row.name, row);
 	}
-	for (const row of manifest.autocompleteRoutes) set(maps.autocomplete, "autocomplete", row.name, row);
-	for (const row of manifest.componentRoutes) set(maps.components[row.kind], COMPONENT_KIND[row.kind], row.prefix, row);
+	for (const row of manifest.autocompleteRoutes) set(InteractionKind.Autocomplete, row.name, row);
+	for (const row of manifest.componentRoutes) set(row.kind, row.prefix, row);
 	return maps;
 }
 function unhandled(kind, attemptedKey) {
@@ -798,7 +788,7 @@ function unhandled(kind, attemptedKey) {
 		kind,
 		routeId: null,
 		attemptedKey,
-		load: () => Promise.resolve(kind === "autocomplete" ? UnhandledAutocomplete : UnhandledRepliable)
+		load: () => Promise.resolve(kind === InteractionKind.Autocomplete ? UnhandledAutocomplete : UnhandledRepliable)
 	};
 }
 /**
@@ -813,24 +803,24 @@ function resolve(maps, interaction) {
 		case InteractionType.ApplicationCommand: {
 			if (interaction.data.type === ApplicationCommandType.ChatInput) {
 				const route = slashRouteOf(interaction.data);
-				return maps.slash.get(route) ?? unhandled("slash", route);
+				return maps[InteractionKind.Slash].get(route) ?? unhandled(InteractionKind.Slash, route);
 			}
 			const kind = commandKind(interaction.data.type);
 			return kind ? maps[kind].get(interaction.data.name) ?? unhandled(kind, interaction.data.name) : null;
 		}
 		case InteractionType.ApplicationCommandAutocomplete: {
 			const route = slashRouteOf(interaction.data);
-			return maps.autocomplete.get(route) ?? unhandled("autocomplete", route);
+			return maps[InteractionKind.Autocomplete].get(route) ?? unhandled(InteractionKind.Autocomplete, route);
 		}
 		case InteractionType.MessageComponent: {
 			const key = componentMapKey(interaction.data.component_type);
 			if (!key) return null;
 			const prefix = prefixOf(interaction.data.custom_id);
-			return maps.components[key].get(prefix) ?? unhandled(COMPONENT_KIND[key], prefix);
+			return maps[key].get(prefix) ?? unhandled(key, prefix);
 		}
 		case InteractionType.ModalSubmit: {
 			const prefix = prefixOf(interaction.data.custom_id);
-			return maps.components.modal.get(prefix) ?? unhandled("modal", prefix);
+			return maps[InteractionKind.Modal].get(prefix) ?? unhandled(InteractionKind.Modal, prefix);
 		}
 		default: return null;
 	}
@@ -1006,7 +996,7 @@ function createSeedcord(config, manifest) {
 //#endregion
 //#region src/inputs/pick.ts
 function pick(ids, bucket) {
-	const found = /* @__PURE__ */ new Map();
+	const found = new Collection();
 	if (!ids || !bucket) return found;
 	for (const id of ids) if (Object.hasOwn(bucket, id)) found.set(id, bucket[id]);
 	return found;
@@ -1072,7 +1062,7 @@ function isKind(entry, kinds) {
 * kind that getter does not read. The message names the getter that does.
 *
 * A select getter resolves the ids its field picked against the interaction's `resolved` data and returns a
-* `Map` keyed by id. A field that picked nothing returns null. Pass `required` to throw there instead.
+* `Collection` keyed by id. A field that picked nothing returns null. Pass `required` to throw there instead.
 */
 var ModalFields = class {
 	entries = /* @__PURE__ */ new Map();
@@ -1402,9 +1392,9 @@ var MessageContextMenuHandler = class extends InteractionHandler {
 /**
 * Shared base the customId-routed component handlers extend on the HTTP transport.
 *
-* Not a public entry point. Extend {@link ButtonHandler}, {@link SelectMenuHandler}, or {@link ModalHandler}
-* instead. This class defines the customId decode, the route matching, and the source-message verbs
-* `update` and `deferUpdate`.
+* Not a public entry point. Extend {@link ButtonHandler}, {@link ModalHandler}, or one of the select menu
+* bases instead. This class defines the customId decode, the route matching, and the source-message
+* verbs `update` and `deferUpdate`.
 *
 * @typeParam Event - The component or modal interaction type this handler processes
 * @typeParam Defs - The customId route definitions registered on the concrete handler
@@ -1530,23 +1520,58 @@ var ModalHandler = class extends ComponentHandler {
 
 //#endregion
 //#region src/handlers/interaction/components/SelectMenuHandler.ts
+function resolvedOf(data) {
+	return data.resolved ?? {};
+}
+/**
+* Shared base the select menu handlers extend on the HTTP transport.
+*
+* Not a public entry point. Extend {@link StringMenuHandler}, {@link UserMenuHandler},
+* {@link RoleMenuHandler}, {@link ChannelMenuHandler}, or {@link MentionableMenuHandler} instead. This
+* class defines the `values` getter those bases share.
+*
+* @typeParam Event - The select menu interaction type this handler processes
+* @typeParam Defs - The customId route definitions registered on the concrete handler
+*/
+var SelectMenuHandler = class extends ComponentHandler {
+	/** The values this select picked. On every kind but the string menu they are snowflake ids. */
+	get values() {
+		return this.event.data.values ?? [];
+	}
+};
 /**
-* Base class for a select menu handler on the HTTP transport.
+* Base class for a string select menu handler on the HTTP transport.
+*
+* Register the customId definitions with `@StringMenuRoute`, list the same ones in the generic, then read
+* the chosen option values from `this.values`. Read `this.params` for a single route or `this.match` for
+* several. Reply through the handler members, or rewrite the source message with `this.update`.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof TopicsId]`.
 *
-* Pass the select kind first and the customId definitions second, the same order as `@SelectMenuRoute`.
-* Read the picked ids from `this.values`. The kind decides which of `this.users`, `this.members`,
-* `this.roles`, and `this.channels` this handler carries. The rest are `never`.
+* @example
+* ```ts
+* \@StringMenuRoute(TopicsId)
+* class Topics extends StringMenuHandler<[typeof TopicsId]> {
+*     async execute() {
+*         const { userId } = this.params;
+*         await this.update(`<@${userId}> now follows ${this.values.join(', ')}`);
+*     }
+* }
+* ```
+*/
+var StringMenuHandler = class extends SelectMenuHandler {};
+/**
+* Base class for a user select menu handler on the HTTP transport.
 *
-* Read `this.params` for a single route or `this.match` for several. Reply through the handler members, or
-* rewrite the source message with `this.update`.
+* Beside `this.values` this handler declares `this.users` and `this.members`. Register the customId
+* definitions with `@UserMenuRoute` and list the same ones in the generic.
 *
-* @typeParam Kind - The select kind from {@link SelectMenuKind}, e.g. `SelectMenuKind.User`.
 * @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
 *
 * @example
 * ```ts
-* \@SelectMenuRoute(SelectMenuKind.User, AssignId)
-* class AssignSelect extends SelectMenuHandler<SelectMenuKind.User, [typeof AssignId]> {
+* \@UserMenuRoute(AssignId)
+* class Assign extends UserMenuHandler<[typeof AssignId]> {
 *     async execute() {
 *         const { roleId } = this.params;
 *         await this.reply(`assigning ${this.users.size} member(s) to <@&${roleId}>`);
@@ -1554,32 +1579,94 @@ var ModalHandler = class extends ComponentHandler {
 * }
 * ```
 */
-var SelectMenuHandler = class extends ComponentHandler {
-	get selection() {
-		return this.event.data;
-	}
-	resolvedMap(bucket) {
-		return pick(this.selection.values, bucket);
-	}
-	/** The ids this select picked. */
-	get values() {
-		return this.selection.values ?? [];
-	}
+var UserMenuHandler = class extends SelectMenuHandler {
 	/** The users this select picked. */
 	get users() {
-		return this.resolvedMap(this.selection.resolved?.users);
+		return pick(this.values, resolvedOf(this.event.data).users);
 	}
 	/** The guild members behind the picked users. Discord resolves these only inside a guild. */
 	get members() {
-		return this.resolvedMap(this.selection.resolved?.members);
+		return pick(this.values, resolvedOf(this.event.data).members);
 	}
+};
+/**
+* Base class for a role select menu handler on the HTTP transport.
+*
+* Beside `this.values` this handler declares `this.roles`. Register the customId definitions with
+* `@RoleMenuRoute` and list the same ones in the generic.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof GrantId]`.
+*
+* @example
+* ```ts
+* \@RoleMenuRoute(GrantId)
+* class Grant extends RoleMenuHandler<[typeof GrantId]> {
+*     async execute() {
+*         await this.update(`granting ${this.roles.size} role(s)`);
+*     }
+* }
+* ```
+*/
+var RoleMenuHandler = class extends SelectMenuHandler {
 	/** The roles this select picked. */
 	get roles() {
-		return this.resolvedMap(this.selection.resolved?.roles);
+		return pick(this.values, resolvedOf(this.event.data).roles);
 	}
+};
+/**
+* Base class for a channel select menu handler on the HTTP transport.
+*
+* Beside `this.values` this handler declares `this.channels`. Register the customId definitions with
+* `@ChannelMenuRoute` and list the same ones in the generic.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof LogTargetId]`.
+*
+* @example
+* ```ts
+* \@ChannelMenuRoute(LogTargetId)
+* class LogTarget extends ChannelMenuHandler<[typeof LogTargetId]> {
+*     async execute() {
+*         await this.update(`logging to ${this.channels.size} channel(s)`);
+*     }
+* }
+* ```
+*/
+var ChannelMenuHandler = class extends SelectMenuHandler {
 	/** The channels this select picked. */
 	get channels() {
-		return this.resolvedMap(this.selection.resolved?.channels);
+		return pick(this.values, resolvedOf(this.event.data).channels);
+	}
+};
+/**
+* Base class for a mentionable select menu handler on the HTTP transport.
+*
+* A mentionable menu accepts users and roles together. `this.users`, `this.members`, and `this.roles`
+* can each come back empty.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof InviteId]`.
+*
+* @example
+* ```ts
+* \@MentionableMenuRoute(InviteId)
+* class Invite extends MentionableMenuHandler<[typeof InviteId]> {
+*     async execute() {
+*         await this.update(`inviting ${this.users.size} user(s) and ${this.roles.size} role(s)`);
+*     }
+* }
+* ```
+*/
+var MentionableMenuHandler = class extends SelectMenuHandler {
+	/** The users this select picked. */
+	get users() {
+		return pick(this.values, resolvedOf(this.event.data).users);
+	}
+	/** The guild members behind the picked users. Discord resolves these only inside a guild. */
+	get members() {
+		return pick(this.values, resolvedOf(this.event.data).members);
+	}
+	/** The roles this select picked. */
+	get roles() {
+		return pick(this.values, resolvedOf(this.event.data).roles);
 	}
 };
 
@@ -1726,8 +1813,8 @@ function Gated(...gates) {
 
 //#endregion
 //#region src/version.ts
-const version = "0.5.1";
+const version = "0.7.0";
 
 //#endregion
-export { RepliableHandler$1 as C, AutocompleteHandler as S, ModalFields as _, Paginator as a, buildRouteMaps as b, SelectMenuHandler as c, ComponentHandler as d, MessageContextMenuHandler as f, Emojis as g, EmojiInjector as h, CursorSource as i, ModalHandler as l, SlashHandler as m, Gated as n, Subscriber$1 as o, UserContextMenuHandler as p, ArraySource as r, WebhookLog$1 as s, version as t, ButtonHandler as u, createSeedcord as v, ReplySender as w, InteractionHandler as x, buildEngine as y };
-//# sourceMappingURL=edge.index-B4x6VSJl.mjs.map
+export { createSeedcord as C, AutocompleteHandler as D, InteractionHandler as E, RepliableHandler$1 as O, ModalFields as S, buildRouteMaps as T, MessageContextMenuHandler as _, Paginator as a, EmojiInjector as b, ChannelMenuHandler as c, SelectMenuHandler as d, StringMenuHandler as f, ComponentHandler as g, ButtonHandler as h, CursorSource as i, ReplySender as k, MentionableMenuHandler as l, ModalHandler as m, Gated as n, Subscriber$1 as o, UserMenuHandler as p, ArraySource as r, WebhookLog$1 as s, version as t, RoleMenuHandler as u, UserContextMenuHandler as v, buildEngine as w, Emojis as x, SlashHandler as y };
+//# sourceMappingURL=edge.index-CWUU_d_X.mjs.map