baff.js 0.0.0-stage → 0.1.0

package/dist/cjs/builders/SlashCommandBuilder.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrefixCommandBuilder = exports.SlashCommandBuilder = exports.SubcommandGroupBuilder = exports.SubcommandBuilder = exports.RoleOption = exports.ChannelOption = exports.UserOption = exports.BooleanOption = exports.NumberOption = exports.IntegerOption = exports.StringOption = exports.OptionBuilder = void 0;
+const validate_js_1 = require("./validate.js");
+const code = 'INVALID_COMMAND';
+const NAME = /^[a-z0-9_-]{1,32}$/;
+const MAX_OPTIONS = 25;
+function checkName(path, name) {
+    if (typeof name !== 'string' || !NAME.test(name))
+        return (0, validate_js_1.fail)(code, `${path}.name`, 'must be 1-32 lowercase letters, numbers, - or _.');
+    return name;
+}
+class Named {
+    name;
+    description;
+    setName(name) {
+        this.name = name;
+        return this;
+    }
+    setDescription(description) {
+        this.description = description;
+        return this;
+    }
+    header(path) {
+        return { name: checkName(path, this.name), description: (0, validate_js_1.text)(code, `${path}.description`, this.description, 100) };
+    }
+}
+class OptionBuilder extends Named {
+    required = false;
+    setRequired(required = true) {
+        this.required = required;
+        return this;
+    }
+    toJSON(path = 'option') {
+        return { ...this.header(path), type: this.type, required: this.required };
+    }
+}
+exports.OptionBuilder = OptionBuilder;
+class StringOption extends OptionBuilder {
+    type = 'string';
+}
+exports.StringOption = StringOption;
+class IntegerOption extends OptionBuilder {
+    type = 'integer';
+}
+exports.IntegerOption = IntegerOption;
+class NumberOption extends OptionBuilder {
+    type = 'number';
+}
+exports.NumberOption = NumberOption;
+class BooleanOption extends OptionBuilder {
+    type = 'boolean';
+}
+exports.BooleanOption = BooleanOption;
+class UserOption extends OptionBuilder {
+    type = 'user';
+}
+exports.UserOption = UserOption;
+class ChannelOption extends OptionBuilder {
+    type = 'channel';
+}
+exports.ChannelOption = ChannelOption;
+class RoleOption extends OptionBuilder {
+    type = 'role';
+}
+exports.RoleOption = RoleOption;
+function build(input, make) {
+    return typeof input === 'function' ? input(make()) : input;
+}
+function checkPlain(path, options) {
+    if (options.length > MAX_OPTIONS)
+        (0, validate_js_1.fail)(code, path, `can have up to ${MAX_OPTIONS} options.`);
+    const names = new Set();
+    let optionalSeen = false;
+    return options.map((option, i) => {
+        const json = option.toJSON(`${path}.options[${i}]`);
+        if (names.has(json.name))
+            (0, validate_js_1.fail)(code, `${path}.options[${i}]`, `name "${json.name}" is used twice.`);
+        names.add(json.name);
+        if (json.required && optionalSeen)
+            (0, validate_js_1.fail)(code, `${path}.options[${i}]`, `is required, so it must come before the optional options.`);
+        optionalSeen ||= !json.required;
+        return json;
+    });
+}
+class OptionHolder extends Named {
+    plain = [];
+    addStringOption(option) {
+        this.plain.push(build(option, () => new StringOption()));
+        return this;
+    }
+    addIntegerOption(option) {
+        this.plain.push(build(option, () => new IntegerOption()));
+        return this;
+    }
+    addNumberOption(option) {
+        this.plain.push(build(option, () => new NumberOption()));
+        return this;
+    }
+    addBooleanOption(option) {
+        this.plain.push(build(option, () => new BooleanOption()));
+        return this;
+    }
+    addUserOption(option) {
+        this.plain.push(build(option, () => new UserOption()));
+        return this;
+    }
+    addChannelOption(option) {
+        this.plain.push(build(option, () => new ChannelOption()));
+        return this;
+    }
+    addRoleOption(option) {
+        this.plain.push(build(option, () => new RoleOption()));
+        return this;
+    }
+}
+class SubcommandBuilder extends OptionHolder {
+    toJSON(path = 'subcommand') {
+        const options = checkPlain(path, this.plain);
+        return { ...this.header(path), type: 'subcommand', options };
+    }
+}
+exports.SubcommandBuilder = SubcommandBuilder;
+class SubcommandGroupBuilder extends Named {
+    subcommands = [];
+    addSubcommand(sub) {
+        this.subcommands.push(build(sub, () => new SubcommandBuilder()));
+        return this;
+    }
+    toJSON(path = 'group') {
+        if (!this.subcommands.length)
+            (0, validate_js_1.fail)(code, path, 'needs at least one subcommand.');
+        return { ...this.header(path), type: 'subcommand_group', options: checkNested(path, this.subcommands) };
+    }
+}
+exports.SubcommandGroupBuilder = SubcommandGroupBuilder;
+function checkNested(path, list) {
+    if (list.length > MAX_OPTIONS)
+        (0, validate_js_1.fail)(code, path, `can have up to ${MAX_OPTIONS} options.`);
+    const names = new Set();
+    return list.map((item, i) => {
+        const json = item.toJSON(`${path}.options[${i}]`);
+        if (names.has(json.name))
+            (0, validate_js_1.fail)(code, `${path}.options[${i}]`, `name "${json.name}" is used twice.`);
+        names.add(json.name);
+        return json;
+    });
+}
+class SlashCommandBuilder extends OptionHolder {
+    nested = [];
+    addSubcommand(sub) {
+        this.nested.push(build(sub, () => new SubcommandBuilder()));
+        return this;
+    }
+    addSubcommandGroup(group) {
+        this.nested.push(build(group, () => new SubcommandGroupBuilder()));
+        return this;
+    }
+    toJSON() {
+        const path = `command "${this.name ?? ''}"`;
+        const header = this.header('command');
+        if (this.nested.length && this.plain.length)
+            (0, validate_js_1.fail)(code, path, 'has both subcommands and plain options: use one or the other.');
+        const options = this.nested.length ? checkNested(path, this.nested) : checkPlain(path, this.plain);
+        return { ...header, kind: 'slash', options };
+    }
+}
+exports.SlashCommandBuilder = SlashCommandBuilder;
+class PrefixCommandBuilder extends Named {
+    prefix;
+    setPrefix(prefix) {
+        this.prefix = prefix;
+        return this;
+    }
+    toJSON() {
+        const prefix = this.prefix;
+        if (!prefix || [...prefix].length > 5 || /\s/.test(prefix))
+            (0, validate_js_1.fail)(code, 'command.prefix', 'must be 1-5 characters with no spaces.');
+        if (!this.name || [...this.name].length > 32 || /\s/.test(this.name))
+            (0, validate_js_1.fail)(code, 'command.name', 'must be 1-32 characters with no spaces.');
+        const description = (0, validate_js_1.text)(code, 'command.description', this.description, 100, { optional: true }) ?? '';
+        return { kind: 'prefix', prefix, name: this.name, description };
+    }
+}
+exports.PrefixCommandBuilder = PrefixCommandBuilder;

package/dist/cjs/builders/components/ActionRowBuilder.d.ts

@@ -0,0 +1,14 @@
+import type { APIComponent } from '../../types.js';
+import { type Serializable } from '../validate.js';
+import { ComponentBuilder } from './shared.js';
+export declare class ActionRowBuilder<T extends Serializable = Serializable> extends ComponentBuilder {
+    components: (T | APIComponent)[];
+    constructor(data?: {
+        components?: (T | APIComponent)[];
+    });
+    addComponents(...components: (T | APIComponent)[]): this;
+    setComponents(...components: (T | APIComponent)[]): this;
+    toJSON(): APIComponent;
+    toModalJSON(): APIComponent;
+    private render;
+}

package/dist/cjs/builders/components/ActionRowBuilder.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionRowBuilder = void 0;
+const constants_js_1 = require("../../util/constants.js");
+const validate_js_1 = require("../validate.js");
+const shared_js_1 = require("./shared.js");
+class ActionRowBuilder extends shared_js_1.ComponentBuilder {
+    components;
+    constructor(data = {}) {
+        super();
+        this.components = [...(data.components ?? [])];
+    }
+    addComponents(...components) {
+        this.components.push(...components);
+        return this;
+    }
+    setComponents(...components) {
+        this.components = [...components];
+        return this;
+    }
+    toJSON() {
+        return this.render(false);
+    }
+    toModalJSON() {
+        return this.render(true);
+    }
+    render(modal) {
+        const children = this.components.map((c) => (0, validate_js_1.resolveJSON)(c));
+        const kinds = children.map((c) => c.type);
+        const code = 'INVALID_COMPONENT';
+        if (modal) {
+            if (kinds.length !== 1 || kinds[0] !== constants_js_1.ComponentType.TextInput)
+                (0, validate_js_1.fail)(code, 'modal row', 'needs exactly one text input.');
+        }
+        else if (kinds[0] === constants_js_1.ComponentType.Button) {
+            if (kinds.length > 5 || kinds.some((k) => k !== constants_js_1.ComponentType.Button))
+                (0, validate_js_1.fail)(code, 'action row', 'can hold up to 5 buttons, all buttons.');
+        }
+        else if (kinds.length !== 1 || kinds[0] === constants_js_1.ComponentType.TextInput || kinds[0] === undefined) {
+            (0, validate_js_1.fail)(code, 'action row', 'needs 1-5 buttons, or exactly one select menu.');
+        }
+        return { ...this.base(constants_js_1.ComponentType.ActionRow), components: children };
+    }
+}
+exports.ActionRowBuilder = ActionRowBuilder;

package/dist/cjs/builders/components/ButtonBuilder.d.ts

@@ -0,0 +1,19 @@
+import type { APIComponent } from '../../types.js';
+import { ComponentBuilder, type EmojiInput } from './shared.js';
+type StyleName = 'primary' | 'secondary' | 'success' | 'danger' | 'link';
+export declare class ButtonBuilder extends ComponentBuilder {
+    private customId?;
+    private label?;
+    private style?;
+    private emoji?;
+    private link?;
+    private disabled;
+    setCustomId(customId: string): this;
+    setLabel(label: string): this;
+    setStyle(style: number | StyleName): this;
+    setEmoji(emoji: EmojiInput): this;
+    setURL(link: string): this;
+    setDisabled(disabled?: boolean): this;
+    toJSON(): APIComponent;
+}
+export {};

package/dist/cjs/builders/components/ButtonBuilder.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ButtonBuilder = void 0;
+const constants_js_1 = require("../../util/constants.js");
+const validate_js_1 = require("../validate.js");
+const shared_js_1 = require("./shared.js");
+const STYLE_NUMBERS = { primary: 1, secondary: 2, success: 3, danger: 4, link: 5 };
+class ButtonBuilder extends shared_js_1.ComponentBuilder {
+    customId;
+    label;
+    style;
+    emoji;
+    link;
+    disabled = false;
+    setCustomId(customId) {
+        this.customId = customId;
+        return this;
+    }
+    setLabel(label) {
+        this.label = label;
+        return this;
+    }
+    setStyle(style) {
+        const value = typeof style === 'string' ? STYLE_NUMBERS[style] : style;
+        if (!Number.isInteger(value) || value < 1 || value > 5)
+            (0, validate_js_1.fail)('INVALID_COMPONENT', 'button.style', 'must be 1 (primary), 2 (secondary), 3 (success), 4 (danger) or 5 (link).');
+        this.style = value;
+        return this;
+    }
+    setEmoji(emoji) {
+        this.emoji = emoji;
+        return this;
+    }
+    setURL(link) {
+        this.link = link;
+        return this;
+    }
+    setDisabled(disabled = true) {
+        this.disabled = disabled;
+        return this;
+    }
+    toJSON() {
+        const code = 'INVALID_COMPONENT';
+        const style = this.style ?? (this.link ? constants_js_1.ButtonStyle.Link : constants_js_1.ButtonStyle.Primary);
+        const out = this.base(constants_js_1.ComponentType.Button);
+        out.style = style;
+        const label = (0, validate_js_1.text)(code, 'button.label', this.label, 80, { optional: true });
+        const emoji = (0, shared_js_1.emojiJSON)('button.emoji', this.emoji);
+        if (label !== undefined)
+            out.label = label;
+        if (emoji)
+            out.emoji = emoji;
+        if (label === undefined && !emoji)
+            (0, validate_js_1.fail)(code, 'button', 'needs a label (1-80 characters) or an emoji.');
+        if (style === constants_js_1.ButtonStyle.Link) {
+            if (this.customId !== undefined)
+                (0, validate_js_1.fail)(code, 'button', 'is a link button: it has a url and no custom id.');
+            out.url = (0, validate_js_1.url)(code, 'button.url', this.link, false);
+        }
+        else {
+            if (this.link !== undefined)
+                (0, validate_js_1.fail)(code, 'button', 'has a url, so its style must be Link.');
+            out.custom_id = (0, validate_js_1.text)(code, 'button.customId', this.customId, 100);
+        }
+        out.disabled = this.disabled;
+        return out;
+    }
+}
+exports.ButtonBuilder = ButtonBuilder;

package/dist/cjs/builders/components/LayoutBuilders.d.ts

@@ -0,0 +1,63 @@
+import type { APIComponent } from '../../types.js';
+import { type ColorResolvable } from '../EmbedBuilder.js';
+import { ButtonBuilder } from './ButtonBuilder.js';
+import { ComponentBuilder, type ComponentInput } from './shared.js';
+export declare class TextDisplayBuilder extends ComponentBuilder {
+    private content?;
+    constructor(content?: string);
+    setContent(content: string): this;
+    toJSON(): APIComponent;
+}
+export declare class ThumbnailBuilder extends ComponentBuilder {
+    private media?;
+    private description?;
+    private spoiler;
+    setURL(mediaUrl: string): this;
+    setDescription(description: string): this;
+    setSpoiler(spoiler?: boolean): this;
+    toJSON(): APIComponent;
+}
+export declare class MediaGalleryItemBuilder {
+    private media?;
+    private description?;
+    private spoiler;
+    setURL(mediaUrl: string): this;
+    setDescription(description: string): this;
+    setSpoiler(spoiler?: boolean): this;
+    toJSON(path?: string): Record<string, unknown>;
+}
+export declare class MediaGalleryBuilder extends ComponentBuilder {
+    private items;
+    addItems(...items: (MediaGalleryItemBuilder | {
+        media: {
+            url: string;
+        };
+        description?: string;
+        spoiler?: boolean;
+    })[]): this;
+    toJSON(): APIComponent;
+}
+export declare class SeparatorBuilder extends ComponentBuilder {
+    private divider;
+    private spacing;
+    setDivider(divider?: boolean): this;
+    setSpacing(spacing: number): this;
+    toJSON(): APIComponent;
+}
+export declare class SectionBuilder extends ComponentBuilder {
+    private texts;
+    private accessory?;
+    addTextDisplayComponents(...texts: (TextDisplayBuilder | string)[]): this;
+    setThumbnailAccessory(thumbnail: ThumbnailBuilder): this;
+    setButtonAccessory(button: ButtonBuilder): this;
+    toJSON(): APIComponent;
+}
+export declare class ContainerBuilder extends ComponentBuilder {
+    private children;
+    private accent?;
+    private spoiler;
+    addComponents(...components: ComponentInput[]): this;
+    setAccentColor(color: ColorResolvable | null): this;
+    setSpoiler(spoiler?: boolean): this;
+    toJSON(): APIComponent;
+}

package/dist/cjs/builders/components/LayoutBuilders.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerBuilder = exports.SectionBuilder = exports.SeparatorBuilder = exports.MediaGalleryBuilder = exports.MediaGalleryItemBuilder = exports.ThumbnailBuilder = exports.TextDisplayBuilder = void 0;
+const constants_js_1 = require("../../util/constants.js");
+const EmbedBuilder_js_1 = require("../EmbedBuilder.js");
+const validate_js_1 = require("../validate.js");
+const shared_js_1 = require("./shared.js");
+const code = 'INVALID_COMPONENT';
+class TextDisplayBuilder extends shared_js_1.ComponentBuilder {
+    content;
+    constructor(content) {
+        super();
+        this.content = content;
+    }
+    setContent(content) {
+        this.content = content;
+        return this;
+    }
+    toJSON() {
+        return { ...this.base(constants_js_1.ComponentType.TextDisplay), content: (0, validate_js_1.text)(code, 'textDisplay.content', this.content, 4000) };
+    }
+}
+exports.TextDisplayBuilder = TextDisplayBuilder;
+class ThumbnailBuilder extends shared_js_1.ComponentBuilder {
+    media;
+    description;
+    spoiler = false;
+    setURL(mediaUrl) {
+        this.media = mediaUrl;
+        return this;
+    }
+    setDescription(description) {
+        this.description = description;
+        return this;
+    }
+    setSpoiler(spoiler = true) {
+        this.spoiler = spoiler;
+        return this;
+    }
+    toJSON() {
+        const out = this.base(constants_js_1.ComponentType.Thumbnail);
+        out.media = { url: (0, validate_js_1.url)(code, 'thumbnail.url', this.media, false) };
+        const description = (0, validate_js_1.text)(code, 'thumbnail.description', this.description, 1024, { optional: true });
+        if (description !== undefined)
+            out.description = description;
+        out.spoiler = this.spoiler;
+        return out;
+    }
+}
+exports.ThumbnailBuilder = ThumbnailBuilder;
+class MediaGalleryItemBuilder {
+    media;
+    description;
+    spoiler = false;
+    setURL(mediaUrl) {
+        this.media = mediaUrl;
+        return this;
+    }
+    setDescription(description) {
+        this.description = description;
+        return this;
+    }
+    setSpoiler(spoiler = true) {
+        this.spoiler = spoiler;
+        return this;
+    }
+    toJSON(path = 'mediaGallery.items[0]') {
+        const out = { media: { url: (0, validate_js_1.url)(code, `${path}.url`, this.media, false) } };
+        const description = (0, validate_js_1.text)(code, `${path}.description`, this.description, 1024, { optional: true });
+        if (description !== undefined)
+            out.description = description;
+        out.spoiler = this.spoiler;
+        return out;
+    }
+}
+exports.MediaGalleryItemBuilder = MediaGalleryItemBuilder;
+class MediaGalleryBuilder extends shared_js_1.ComponentBuilder {
+    items = [];
+    addItems(...items) {
+        this.items.push(...items);
+        return this;
+    }
+    toJSON() {
+        if (!this.items.length || this.items.length > 10)
+            (0, validate_js_1.fail)(code, 'mediaGallery.items', 'needs 1-10 items.');
+        const items = this.items.map((item, i) => {
+            const path = `mediaGallery.items[${i}]`;
+            if (item instanceof MediaGalleryItemBuilder)
+                return item.toJSON(path);
+            const built = new MediaGalleryItemBuilder().setURL(item.media.url);
+            if (item.description)
+                built.setDescription(item.description);
+            if (item.spoiler)
+                built.setSpoiler();
+            return built.toJSON(path);
+        });
+        return { ...this.base(constants_js_1.ComponentType.MediaGallery), items };
+    }
+}
+exports.MediaGalleryBuilder = MediaGalleryBuilder;
+class SeparatorBuilder extends shared_js_1.ComponentBuilder {
+    divider = true;
+    spacing = constants_js_1.SeparatorSpacing.Small;
+    setDivider(divider = true) {
+        this.divider = divider;
+        return this;
+    }
+    setSpacing(spacing) {
+        this.spacing = spacing;
+        return this;
+    }
+    toJSON() {
+        if (this.spacing !== 1 && this.spacing !== 2)
+            (0, validate_js_1.fail)(code, 'separator.spacing', 'must be Small (1) or Large (2).');
+        return { ...this.base(constants_js_1.ComponentType.Separator), divider: this.divider, spacing: this.spacing };
+    }
+}
+exports.SeparatorBuilder = SeparatorBuilder;
+class SectionBuilder extends shared_js_1.ComponentBuilder {
+    texts = [];
+    accessory;
+    addTextDisplayComponents(...texts) {
+        this.texts.push(...texts);
+        return this;
+    }
+    setThumbnailAccessory(thumbnail) {
+        this.accessory = thumbnail;
+        return this;
+    }
+    setButtonAccessory(button) {
+        this.accessory = button;
+        return this;
+    }
+    toJSON() {
+        if (!this.texts.length || this.texts.length > 3)
+            (0, validate_js_1.fail)(code, 'section.components', 'needs 1-3 text displays.');
+        if (!this.accessory)
+            (0, validate_js_1.fail)(code, 'section.accessory', 'is required: a thumbnail or a button.');
+        return {
+            ...this.base(constants_js_1.ComponentType.Section),
+            components: this.texts.map((t) => (typeof t === 'string' ? new TextDisplayBuilder(t) : t).toJSON()),
+            accessory: this.accessory.toJSON()
+        };
+    }
+}
+exports.SectionBuilder = SectionBuilder;
+class ContainerBuilder extends shared_js_1.ComponentBuilder {
+    children = [];
+    accent;
+    spoiler = false;
+    addComponents(...components) {
+        this.children.push(...components);
+        return this;
+    }
+    setAccentColor(color) {
+        this.accent = color === null ? undefined : (0, EmbedBuilder_js_1.resolveColor)(color);
+        return this;
+    }
+    setSpoiler(spoiler = true) {
+        this.spoiler = spoiler;
+        return this;
+    }
+    toJSON() {
+        if (!this.children.length)
+            (0, validate_js_1.fail)(code, 'container.components', 'needs at least one component.');
+        const allowed = [constants_js_1.ComponentType.ActionRow, constants_js_1.ComponentType.Section, constants_js_1.ComponentType.TextDisplay, constants_js_1.ComponentType.MediaGallery, constants_js_1.ComponentType.Separator];
+        const components = this.children.map((child, i) => {
+            const json = (0, validate_js_1.resolveJSON)(child);
+            if (!allowed.includes(json.type))
+                (0, validate_js_1.fail)(code, `container.components[${i}]`, 'can be an action row, section, text display, media gallery or separator.');
+            return json;
+        });
+        const out = { ...this.base(constants_js_1.ComponentType.Container), components, spoiler: this.spoiler };
+        if (this.accent !== undefined)
+            out.accent_color = (0, validate_js_1.range)(code, 'container.accentColor', this.accent, 0, 0xffffff);
+        return out;
+    }
+}
+exports.ContainerBuilder = ContainerBuilder;

package/dist/cjs/builders/components/ModalBuilder.d.ts

@@ -0,0 +1,36 @@
+import type { APIComponent } from '../../types.js';
+import { ActionRowBuilder } from './ActionRowBuilder.js';
+import { ComponentBuilder } from './shared.js';
+export declare class TextInputBuilder extends ComponentBuilder {
+    private customId?;
+    private label?;
+    private style;
+    private placeholder?;
+    private minLength;
+    private maxLength;
+    private required;
+    private value?;
+    setCustomId(customId: string): this;
+    setLabel(label: string): this;
+    setStyle(style: number | 'short' | 'paragraph'): this;
+    setPlaceholder(placeholder: string): this;
+    setMinLength(length: number): this;
+    setMaxLength(length: number): this;
+    setRequired(required?: boolean): this;
+    setValue(value: string): this;
+    toJSON(): APIComponent;
+}
+export declare class ModalBuilder {
+    private customId?;
+    private title?;
+    private rows;
+    setCustomId(customId: string): this;
+    setTitle(title: string): this;
+    addComponents(...rows: (ActionRowBuilder | TextInputBuilder)[]): this;
+    setComponents(...rows: (ActionRowBuilder | TextInputBuilder)[]): this;
+    toJSON(): {
+        title: string;
+        custom_id: string;
+        components: APIComponent[];
+    };
+}