chapterjs 0.1.1 → 0.1.4

package/dist/components/button.js

@@ -0,0 +1,108 @@
+// `button()`, as the files of `src/components/buttons/` import it from
+// 'chapterjs': what the button looks like, what it carries, and what to do
+// when it is clicked.
+// https://docs.discord.com/developers/components/reference#button
+import { Limits } from '../discord/api.js';
+import { ButtonStyle, ComponentType, } from '../discord/types/component.js';
+import { isDynamic, resolveText } from './component.js';
+import { checkData, encodeCustomId, } from './custom-id.js';
+import { createFile } from './file.js';
+import { emojiOf } from './instance.js';
+export const BUTTON_STYLES = {
+    primary: ButtonStyle.Primary,
+    secondary: ButtonStyle.Secondary,
+    success: ButtonStyle.Success,
+    danger: ButtonStyle.Danger,
+};
+/**
+ * Declares a button. Export the result as the default export of a file of
+ * `src/components/buttons/`: the path of the file is what tells the
+ * button apart, so you never write an id.
+ *
+ * ```ts
+ * import { button } from 'chapterjs';
+ *
+ * export default button({
+ *   label: 'Confirm',
+ *   style: 'success',
+ *   async run({ interaction }) {
+ *     await interaction.update({ content: 'Confirmed!', components: [] });
+ *   },
+ * });
+ * ```
+ */
+export function button(config) {
+    return createFile('button', config, {
+        asPiece: true,
+        pieceKind: 'button',
+    });
+}
+const fail = (message) => {
+    throw new TypeError(message);
+};
+/** Checks what a message gives to change the look of a button. */
+export function readLook(what, look) {
+    if (look === undefined)
+        return {};
+    if (typeof look !== 'object' || look === null || Array.isArray(look)) {
+        fail(`The look of ${what} is an object like { disabled: true }.`);
+    }
+    const given = look;
+    for (const key of Object.keys(given)) {
+        if (!['label', 'emoji', 'style', 'disabled'].includes(key)) {
+            fail(`"${key}" is not something the look of ${what} has. It can have: label, emoji, style, disabled.`);
+        }
+    }
+    if (given.label !== undefined && !isDynamic(given.label)) {
+        if (typeof given.label !== 'string' ||
+            given.label.trim() === '' ||
+            given.label.length > Limits.ButtonLabel) {
+            fail(`The label of ${what} is a text of 1 to ${Limits.ButtonLabel} characters.`);
+        }
+    }
+    if (given.style !== undefined &&
+        !Object.hasOwn(BUTTON_STYLES, given.style)) {
+        fail(`The style of ${what} is 'primary', 'secondary', 'success' or 'danger', got ${JSON.stringify(given.style)}.`);
+    }
+    if (given.disabled !== undefined && typeof given.disabled !== 'boolean') {
+        fail(`"disabled" of ${what} is true or false.`);
+    }
+    if (given.emoji !== undefined)
+        emojiOf(given.emoji, what);
+    return given;
+}
+/** The button as Discord takes it, for the data and the look given. */
+export function renderButton(loaded, args) {
+    const hasData = Object.keys(loaded.data).length > 0;
+    const name = loaded.path.split('/').pop();
+    if (args.length > (hasData ? 2 : 1)) {
+        fail(`${name} takes ${hasData ? 'its data, then a look' : 'a look'} at most: ${hasData ? `${name}({ ... }, { disabled: true })` : `${name}({ disabled: true })`}.`);
+    }
+    const values = checkData(name, loaded.data, hasData ? args[0] : undefined);
+    const look = {
+        ...loaded.look,
+        ...readLook(name, hasData ? args[1] : args[0]),
+    };
+    const base = {
+        type: ComponentType.Button,
+        style: BUTTON_STYLES[look.style],
+        custom_id: encodeCustomId(loaded.path, loaded.data, values),
+    };
+    if (look.emoji !== undefined)
+        base.emoji = emojiOf(look.emoji, name);
+    if (look.disabled)
+        base.disabled = true;
+    const { label } = look;
+    if (label === undefined)
+        return { kind: 'button', raw: base };
+    if (!isDynamic(label))
+        return { kind: 'button', raw: { ...base, label } };
+    // The label is computed when the message is sent, for who will read it.
+    return {
+        kind: 'button',
+        raw: t => ({
+            ...base,
+            label: resolveText(`The label of ${name}`, label, { t, data: values }, { max: Limits.ButtonLabel }),
+        }),
+    };
+}

package/dist/components/component.d.ts

@@ -0,0 +1,140 @@
+import type { DMChannel, GuildTextBasedChannel } from '../structures/channel.js';
+import type { Guild } from '../structures/guild.js';
+import type { Interaction } from '../structures/interaction.js';
+import type { GuildMember } from '../structures/member.js';
+import type { Message } from '../structures/message.js';
+import type { User } from '../structures/user.js';
+import type { DataShape, DataValuesOf } from './custom-id.js';
+import type { Translator } from '../messages/messages.js';
+/**
+ * What a text of a component is computed from when it is a function: `t`
+ * in the language of who will read the message, and the data the
+ * component carries.
+ */
+export interface TextContext<Data extends DataShape = DataShape> {
+    /** The texts of `src/messages/`, in the language of who will read the message. */
+    t: Translator;
+    /** What the component carries, as declared in `data`. */
+    data: [DataShape] extends [Data] ? Record<string, string | number | boolean> : DataValuesOf<Data>;
+}
+/**
+ * A text shown by a component: written as is, or computed when the
+ * message is sent, from `t` and the data of the component.
+ */
+export type DynamicText<Data extends DataShape = DataShape> = string | ((context: TextContext<Data>) => string);
+/** Whether a text is computed when the message is sent. */
+export declare const isDynamic: (value: unknown) => value is (context: TextContext) => string;
+/**
+ * Checks a text of a component, now when it is written, or when the
+ * message is sent when it is a function: `resolve` is then what to check.
+ * Returns the text, or `undefined` when there is none and none is needed.
+ */
+export declare function checkDynamicText(what: string, value: unknown, { min, max, required, }: {
+    min?: number;
+    max: number;
+    required?: boolean;
+}): void;
+/** A text given by a file or computed, within the limits of Discord. */
+export declare function checkTextValue(what: string, value: unknown, { min, max }: {
+    min?: number;
+    max: number;
+}): string;
+/** The text of a component when the message is sent. */
+export declare function resolveText(what: string, value: DynamicText | undefined, context: TextContext, limits: {
+    min?: number;
+    max: number;
+}): string | undefined;
+/**
+ * Where a component can be used: in messages of servers (`'guild'`), in
+ * private messages with the bot (`'dm'`), or in both. A component is where
+ * the message that holds it is: this says where your code expects it.
+ */
+export type ComponentWhere = 'guild' | 'dm' | 'both';
+/**
+ * Who may use a component: `'everyone'` who sees the message (the
+ * default), or only the `'author'`, the person who used the command the
+ * message answers. Anyone else gets a private refusal.
+ */
+export type ComponentWho = 'everyone' | 'author';
+/** What every interactive component declares, besides what it looks like. */
+export interface InteractiveConfig<Data extends DataShape, Where extends ComponentWhere> {
+    /**
+     * What the component carries from the message that shows it to the code
+     * that runs when it is used: a name and a kind for each value
+     * (`{ userId: 'string', page: 'number' }`). Given when the component is
+     * put in a message, received typed in `run`. Discord keeps it in the
+     * component itself, so it survives restarts.
+     */
+    data?: Data;
+    /**
+     * Where the component can be used: `'guild'` (in servers, the default),
+     * `'dm'` (in private messages with the bot) or `'both'`. What `run`
+     * receives follows it.
+     */
+    where?: Where;
+    /**
+     * Who may use it: `'everyone'` (the default) or only the `'author'` of
+     * the command the message answers.
+     */
+    who?: ComponentWho;
+    /**
+     * Make the answers of the component only visible to who used it. On a
+     * message only the person sees (an ephemeral answer), they already are.
+     */
+    ephemeral?: boolean;
+}
+/** A server, as an interaction used in one sees it. */
+export type InGuild<I extends Interaction> = I & {
+    readonly guildId: string;
+    readonly guild: Guild;
+    readonly member: GuildMember;
+    readonly channel: GuildTextBasedChannel;
+};
+/** A private message, for something that also works in servers. */
+export type InPrivate<I extends Interaction> = I & {
+    readonly guildId: null;
+    readonly guild: null;
+    readonly member: null;
+    readonly channel: DMChannel;
+};
+/** A private message, for something that only works there: no server at all. */
+export type InDm<I extends Interaction> = Omit<I, 'guildId' | 'guild' | 'member' | 'channel'> & {
+    readonly channel: DMChannel;
+};
+/** What `run` receives about the place, in a server. */
+export interface PlaceInGuild<I extends Interaction> {
+    interaction: InGuild<I>;
+    /** The server it was used in. */
+    guild: Guild;
+    /** Who used it, as a member of the server. */
+    member: GuildMember;
+    /** The channel it was used in. */
+    channel: GuildTextBasedChannel;
+}
+/** What `run` receives about the place, in a private message, when it also works in servers. */
+export interface PlaceInPrivate<I extends Interaction> {
+    interaction: InPrivate<I>;
+    /** No server: it was used in a private message. */
+    guild: null;
+    /** No member: the person is `user`. */
+    member: null;
+    /** The private conversation it was used in. */
+    channel: DMChannel;
+}
+/** What `run` receives about the place, when it only works in private messages. */
+export interface PlaceInDm<I extends Interaction> {
+    interaction: InDm<I>;
+    /** The private conversation it was used in. */
+    channel: DMChannel;
+}
+/** What `run` receives about where it was used, following `where`. */
+export type PlaceOf<Where extends ComponentWhere, I extends Interaction> = Where extends 'guild' ? PlaceInGuild<I> : Where extends 'dm' ? PlaceInDm<I> : PlaceInGuild<I> | PlaceInPrivate<I>;
+/** What every interactive component gives to its `run`, besides the place. */
+export interface InteractiveContext<Data extends DataShape> {
+    /** Who used it. */
+    user: User;
+    /** The message the component is on. */
+    message: Message;
+    /** What the component carries, as declared in `data`. */
+    data: DataValuesOf<Data>;
+}

package/dist/components/component.js

@@ -0,0 +1,39 @@
+// What every interactive component of `src/components/` shares: where it
+// works, who may use it, what it carries, and what its `run` receives
+// about the place it was used in.
+/** Whether a text is computed when the message is sent. */
+export const isDynamic = (value) => typeof value === 'function';
+/**
+ * Checks a text of a component, now when it is written, or when the
+ * message is sent when it is a function: `resolve` is then what to check.
+ * Returns the text, or `undefined` when there is none and none is needed.
+ */
+export function checkDynamicText(what, value, { min = 1, max, required = false, }) {
+    if (value === undefined) {
+        if (required)
+            throw new TypeError(`${what} is missing.`);
+        return;
+    }
+    if (isDynamic(value))
+        return;
+    checkTextValue(what, value, { min, max });
+}
+/** A text given by a file or computed, within the limits of Discord. */
+export function checkTextValue(what, value, { min = 1, max }) {
+    if (typeof value !== 'string') {
+        throw new TypeError(`${what} is a text${min === 1 ? ` of 1 to ${max} characters` : ''}, got ${typeof value}.`);
+    }
+    if (value.length < min ||
+        value.length > max ||
+        (min > 0 && value.trim() === '')) {
+        throw new RangeError(`${what} is ${value.length} characters long: Discord accepts between ${min} and ${max}.`);
+    }
+    return value;
+}
+/** The text of a component when the message is sent. */
+export function resolveText(what, value, context, limits) {
+    if (value === undefined)
+        return undefined;
+    const text = isDynamic(value) ? value(context) : value;
+    return checkTextValue(isDynamic(value) ? `${what}, as its function returned it,` : what, text, limits);
+}

package/dist/components/convention.d.ts

@@ -0,0 +1,35 @@
+import type { Convention } from '../loader/loader.js';
+import { type LoadedButton } from './button.js';
+import { isEmbedFile } from './embed.js';
+import { type LoadedModal } from './modal.js';
+import { type LoadedSelect } from './select.js';
+/** An embed file, checked (when it is static). */
+export interface LoadedEmbed {
+    readonly kind: 'embed';
+    readonly path: string;
+}
+/** A component file, checked: what the router works with. */
+export type LoadedComponent = LoadedButton | LoadedSelect | LoadedModal | LoadedEmbed;
+/**
+ * `src/components/`: one folder per kind of component (`buttons/`,
+ * `selects/`, `modals/`, `embeds/`), and in it one file per component,
+ * whose path is its id. The file exports by default what `button()`,
+ * `select()`, `modal()` or `embed()` returns.
+ */
+export declare const componentsConvention: Convention<LoadedComponent>;
+/** The files that are the same component (through `(group)` folders): the later one is left out. */
+export declare function findDuplicates<T extends {
+    file: string;
+    component: {
+        path: string;
+    };
+}>(entries: readonly T[]): {
+    valid: T[];
+    conflicts: {
+        file: string;
+        message: string;
+    }[];
+};
+/** Whether a file holds an embed: nothing to route. */
+export declare const isEmbedLoaded: (component: LoadedComponent) => component is LoadedEmbed;
+export { isEmbedFile };

package/dist/components/convention.js

@@ -0,0 +1,339 @@
+// `src/components/`: the folder is the kind of component, the path of the
+// file is its id. Everything a file declares is checked when it loads,
+// against the limits of Discord, so a mistake is explained before Discord
+// refuses it; the file is then bound to its path, which is what makes its
+// instances.
+import { Limits } from '../discord/api.js';
+import { checkEmbed } from '../structures/payload.js';
+import { isDynamic } from './component.js';
+import { readLook, renderButton, } from './button.js';
+import { DATA_KINDS } from './custom-id.js';
+import { isEmbedFile } from './embed.js';
+import { bindFile, COMPONENT_FOLDERS, fileStateOf, } from './file.js';
+import { readField, renderModal } from './modal.js';
+import { readOptions } from './options.js';
+import { readChannelTypes, readPlaceholder, readRange, renderSelect, SELECT_TYPES, } from './select.js';
+const fail = (message) => {
+    throw new TypeError(message);
+};
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** The names of the folders and files: what a path and an id can hold. */
+const NAME = /^[A-Za-z0-9_-]+$/;
+const FOLDERS = Object.keys(COMPONENT_FOLDERS);
+function checkKeys(what, value, allowed) {
+    for (const key of Object.keys(value)) {
+        if (!allowed.includes(key)) {
+            fail(`"${key}" is not something ${what} has. It can have: ${allowed.join(', ')}.`);
+        }
+    }
+}
+function checkBoolean(what, value) {
+    if (value === undefined)
+        return false;
+    if (typeof value !== 'boolean')
+        return fail(`${what} is true or false, got ${JSON.stringify(value) ?? typeof value}.`);
+    return value;
+}
+const PLACES = ['guild', 'dm', 'both'];
+function checkWhere(what, value) {
+    if (value === undefined)
+        return 'guild';
+    if (!PLACES.includes(value)) {
+        return fail(`"where" says where ${what} can be used: 'guild' (in servers, which is the default), 'dm' (in private messages with the bot) or 'both'. Got ${JSON.stringify(value) ?? typeof value}.`);
+    }
+    return value;
+}
+function checkWho(what, value) {
+    if (value === undefined)
+        return 'everyone';
+    if (value !== 'everyone' && value !== 'author') {
+        return fail(`"who" says who may use ${what}: 'everyone' (the default) or 'author' (only who used the command the message answers). Got ${JSON.stringify(value) ?? typeof value}.`);
+    }
+    return value;
+}
+function checkDataShape(what, value) {
+    if (value === undefined)
+        return Object.freeze({});
+    if (!isRecord(value)) {
+        return fail(`"data" of ${what} is an object from a name to a kind: data: { userId: 'string', page: 'number' }.`);
+    }
+    const kinds = DATA_KINDS.map(one => `'${one}'`).join(', ');
+    for (const [name, field] of Object.entries(value)) {
+        if (!/^[A-Za-z_$][\w$]*$/.test(name)) {
+            fail(`"${name}" can't be the name of a data of ${what}: it is how your code reads it (data.${name}), so use letters, digits and _ only.`);
+        }
+        // A kind, or a kind with a default value.
+        if (isRecord(field)) {
+            for (const key of Object.keys(field)) {
+                if (key !== 'type' && key !== 'default') {
+                    fail(`"${key}" is not something the data "${name}" of ${what} has. It can have: type, default.`);
+                }
+            }
+            if (!DATA_KINDS.includes(field.type)) {
+                fail(`The data "${name}" of ${what} has the type ${JSON.stringify(field.type) ?? typeof field.type}, which does not exist. Kinds are: ${kinds}.`);
+            }
+            if (field.default !== undefined &&
+                (typeof field.default !== field.type ||
+                    (field.type === 'number' && !Number.isFinite(field.default)))) {
+                fail(`The default value of the data "${name}" of ${what} must be a ${field.type}, got ${JSON.stringify(field.default) ?? typeof field.default}.`);
+            }
+            continue;
+        }
+        if (!DATA_KINDS.includes(field)) {
+            fail(`The data "${name}" of ${what} has the kind ${JSON.stringify(field) ?? typeof field}, which does not exist. Kinds are: ${kinds}, or { type: 'number', default: 1 } for a value with a default.`);
+        }
+    }
+    return Object.freeze({ ...value });
+}
+function checkRun(what, value, example) {
+    if (typeof value !== 'function') {
+        fail(`${what} has no "run": the function to run when someone uses it, like ${example}`);
+    }
+}
+function readButton(path, config) {
+    if (!isRecord(config)) {
+        return fail(`button() needs an object: button({ label: '...', run({ interaction }) { ... } })`);
+    }
+    const what = 'this button';
+    checkKeys('a button', config, [
+        'label',
+        'emoji',
+        'style',
+        'disabled',
+        'data',
+        'where',
+        'who',
+        'ephemeral',
+        'run',
+    ]);
+    const look = readLook(what, {
+        ...(config.label !== undefined ? { label: config.label } : {}),
+        ...(config.emoji !== undefined ? { emoji: config.emoji } : {}),
+        ...(config.style !== undefined ? { style: config.style } : {}),
+        ...(config.disabled !== undefined ? { disabled: config.disabled } : {}),
+    });
+    if (look.label === undefined && look.emoji === undefined) {
+        fail('A button needs a label or an emoji.');
+    }
+    checkRun(what, config.run, `async run({ interaction }) { await interaction.update('Done!'); }`);
+    return Object.freeze({
+        kind: 'button',
+        path,
+        look: {
+            style: look.style ?? 'primary',
+            disabled: look.disabled ?? false,
+            ...(look.label !== undefined ? { label: look.label } : {}),
+            ...(look.emoji !== undefined ? { emoji: look.emoji } : {}),
+        },
+        data: checkDataShape(what, config.data),
+        where: checkWhere(what, config.where),
+        who: checkWho(what, config.who),
+        ephemeral: checkBoolean('"ephemeral"', config.ephemeral),
+        run: config.run,
+    });
+}
+function readSelect(path, config) {
+    if (!isRecord(config)) {
+        return fail(`select() needs an object: select({ options: ['a', 'b'], run({ interaction, value }) { ... } })`);
+    }
+    const what = 'this select menu';
+    const type = (config.type ?? 'string');
+    if (!Object.hasOwn(SELECT_TYPES, type)) {
+        fail(`The type of ${what} is ${JSON.stringify(config.type)}, which does not exist. Types are: ${Object.keys(SELECT_TYPES)
+            .map(one => `'${one}'`)
+            .join(', ')}.`);
+    }
+    checkKeys('a select menu', config, [
+        'type',
+        'options',
+        'placeholder',
+        'min',
+        'max',
+        'disabled',
+        'channelTypes',
+        'data',
+        'where',
+        'who',
+        'ephemeral',
+        'run',
+    ]);
+    if (type !== 'string' && config.options !== undefined) {
+        fail(`${what} lists ${type}s: Discord fills it, so it takes no "options".`);
+    }
+    if (type !== 'channel' && config.channelTypes !== undefined) {
+        fail(`"channelTypes" is only for a menu of channels (type: 'channel').`);
+    }
+    const options = type === 'string' ? readOptions(what, config.options) : [];
+    const placeholder = readPlaceholder(what, config.placeholder);
+    checkRun(what, config.run, `async run({ interaction, values }) { ... }`);
+    return Object.freeze({
+        kind: 'select',
+        path,
+        type: type,
+        options: Object.freeze(options),
+        channelTypes: readChannelTypes(what, config.channelTypes),
+        look: {
+            ...(placeholder !== undefined ? { placeholder } : {}),
+            ...(checkBoolean('"disabled"', config.disabled)
+                ? { disabled: true }
+                : {}),
+        },
+        ...readRange(what, config, Limits.SelectValues, { min: 1, max: 1 }),
+        data: checkDataShape(what, config.data),
+        where: checkWhere(what, config.where),
+        who: checkWho(what, config.who),
+        ephemeral: checkBoolean('"ephemeral"', config.ephemeral),
+        run: config.run,
+    });
+}
+function readModal(path, config) {
+    if (!isRecord(config)) {
+        return fail(`modal() needs an object: modal({ title: '...', fields: { ... }, run({ interaction, fields }) { ... } })`);
+    }
+    const what = 'this form';
+    checkKeys('a form', config, [
+        'title',
+        'fields',
+        'data',
+        'where',
+        'ephemeral',
+        'run',
+    ]);
+    if (!isDynamic(config.title) &&
+        (typeof config.title !== 'string' ||
+            config.title.trim() === '' ||
+            config.title.length > Limits.ModalTitle)) {
+        fail(`The title of ${what} is a text of 1 to ${Limits.ModalTitle} characters.`);
+    }
+    if (!isRecord(config.fields)) {
+        fail(`"fields" of ${what} is an object whose keys are the names of the fields: fields: { reason: { type: 'text', label: 'Reason' } }`);
+    }
+    const fields = Object.entries(config.fields).map(([name, field]) => readField(name, field));
+    const inputs = fields.filter(field => field.field.type !== 'note');
+    if (fields.length === 0 || fields.length > Limits.ModalFields) {
+        fail(`${what} has ${fields.length} fields: Discord accepts between 1 and ${Limits.ModalFields}.`);
+    }
+    if (inputs.length === 0) {
+        fail(`${what} has nothing to fill in: add a field like { type: 'text', label: '...' }.`);
+    }
+    checkRun(what, config.run, `async run({ interaction, fields }) { ... }`);
+    return Object.freeze({
+        kind: 'modal',
+        path,
+        title: config.title,
+        fields: Object.freeze(fields),
+        data: checkDataShape(what, config.data),
+        where: checkWhere(what, config.where),
+        ephemeral: checkBoolean('"ephemeral"', config.ephemeral),
+        run: config.run,
+    });
+}
+/** A file of `src/components/`, by the kind its folder says. */
+function readOne(kind, path, exports) {
+    const file = exports.default;
+    const state = fileStateOf(file);
+    const example = `import { ${kind} } from 'chapterjs'; export default ${kind}({ ... })`;
+    if (!state) {
+        return fail('default' in exports
+            ? `The default export of this file must be what ${kind}() returns: ${example}`
+            : `This file has no default export. It should look like: ${example}`);
+    }
+    if (state.kind !== kind) {
+        const folder = FOLDERS.find(one => COMPONENT_FOLDERS[one] === state.kind);
+        return fail(`This file exports a ${state.kind}, but it is in src/components/${FOLDERS.find(one => COMPONENT_FOLDERS[one] === kind)}/. Move it to src/components/${folder}/.`);
+    }
+    switch (kind) {
+        case 'button': {
+            const loaded = readButton(path, state.config);
+            bindFile(file, { path, render: args => renderButton(loaded, args) });
+            return loaded;
+        }
+        case 'select': {
+            const loaded = readSelect(path, state.config);
+            bindFile(file, { path, render: args => renderSelect(loaded, args) });
+            return loaded;
+        }
+        case 'modal': {
+            const loaded = readModal(path, state.config);
+            bindFile(file, { path, render: args => renderModal(loaded, args) });
+            return loaded;
+        }
+        default: {
+            const { config } = state;
+            if (typeof config !== 'function') {
+                if (!isRecord(config)) {
+                    fail(`embed() takes the embed itself ({ title: '...' }) or a function that returns one.`);
+                }
+                checkEmbed(config, 'this embed');
+            }
+            bindFile(file, {
+                path,
+                render: args => {
+                    if (typeof config === 'function')
+                        return config(...args);
+                    if (args.length > 0)
+                        fail(`${path.split('/').pop()} always looks the same: it takes no arguments.`);
+                    return config;
+                },
+            });
+            return Object.freeze({ kind: 'embed', path });
+        }
+    }
+}
+/**
+ * `src/components/`: one folder per kind of component (`buttons/`,
+ * `selects/`, `modals/`, `embeds/`), and in it one file per component,
+ * whose path is its id. The file exports by default what `button()`,
+ * `select()`, `modal()` or `embed()` returns.
+ */
+export const componentsConvention = {
+    folder: 'components',
+    one: 'component',
+    many: 'components',
+    check(path) {
+        const parts = path.replace(/\.[^./]+$/, '').split('/');
+        if (parts.length < 2) {
+            fail(`This file is directly in src/components/. Put it in the folder of its kind: ${FOLDERS.map(one => `src/components/${one}/`).join(', ')}.`);
+        }
+        const folder = parts[0];
+        if (!Object.hasOwn(COMPONENT_FOLDERS, folder)) {
+            fail(`The folder src/components/${folder} is not a kind of component. Kinds are: ${FOLDERS.join(', ')}.`);
+        }
+        for (const part of parts) {
+            if (!NAME.test(part)) {
+                fail(`"${part}" can't be in the path of a component: use letters, digits, - and _ only. The path of the file is the id of the component.`);
+            }
+        }
+        if (path.replace(/\.[^./]+$/, '').length > Limits.CustomId - 20) {
+            fail(`The path of this file is ${path.length} characters long: Discord gives ${Limits.CustomId} characters to the id of a component and its data together. Shorten the names.`);
+        }
+    },
+    read(exports, path) {
+        const id = path.replace(/\.[^./]+$/, '');
+        const kind = COMPONENT_FOLDERS[id.split('/')[0]];
+        return readOne(kind, id, exports);
+    },
+};
+/** The files that are the same component (through `(group)` folders): the later one is left out. */
+export function findDuplicates(entries) {
+    const seen = new Map();
+    const conflicts = [];
+    const valid = [...entries]
+        .sort((a, b) => (a.file < b.file ? -1 : 1))
+        .filter(entry => {
+        const first = seen.get(entry.component.path);
+        if (!first) {
+            seen.set(entry.component.path, entry);
+            return true;
+        }
+        conflicts.push({
+            file: entry.file,
+            message: `${entry.component.path} is already ${first.file}: two files can't be the same component. A folder in parentheses only groups files, it is not part of the id.`,
+        });
+        return false;
+    });
+    return { valid, conflicts };
+}
+/** Whether a file holds an embed: nothing to route. */
+export const isEmbedLoaded = (component) => component.kind === 'embed';
+export { isEmbedFile };