baff.js 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModalBuilder = exports.TextInputBuilder = void 0;
+const constants_js_1 = require("../../util/constants.js");
+const validate_js_1 = require("../validate.js");
+const ActionRowBuilder_js_1 = require("./ActionRowBuilder.js");
+const shared_js_1 = require("./shared.js");
+class TextInputBuilder extends shared_js_1.ComponentBuilder {
+    customId;
+    label;
+    style = constants_js_1.TextInputStyle.Short;
+    placeholder;
+    minLength = 0;
+    maxLength = 4000;
+    required = true;
+    value;
+    setCustomId(customId) {
+        this.customId = customId;
+        return this;
+    }
+    setLabel(label) {
+        this.label = label;
+        return this;
+    }
+    setStyle(style) {
+        this.style = style === 'short' ? 1 : style === 'paragraph' ? 2 : style;
+        return this;
+    }
+    setPlaceholder(placeholder) {
+        this.placeholder = placeholder;
+        return this;
+    }
+    setMinLength(length) {
+        this.minLength = length;
+        return this;
+    }
+    setMaxLength(length) {
+        this.maxLength = length;
+        return this;
+    }
+    setRequired(required = true) {
+        this.required = required;
+        return this;
+    }
+    setValue(value) {
+        this.value = value;
+        return this;
+    }
+    toJSON() {
+        const code = 'INVALID_COMPONENT';
+        if (this.style !== 1 && this.style !== 2)
+            (0, validate_js_1.fail)(code, 'textInput.style', 'must be Short (1) or Paragraph (2).');
+        (0, validate_js_1.range)(code, 'textInput.minLength', this.minLength, 0, 4000);
+        (0, validate_js_1.range)(code, 'textInput.maxLength', this.maxLength, 1, 4000);
+        if (this.minLength > this.maxLength)
+            (0, validate_js_1.fail)(code, 'textInput', 'has minLength above maxLength.');
+        const out = this.base(constants_js_1.ComponentType.TextInput);
+        out.custom_id = (0, validate_js_1.text)(code, 'textInput.customId', this.customId, 100);
+        out.style = this.style;
+        out.label = (0, validate_js_1.text)(code, 'textInput.label', this.label, 45);
+        const placeholder = (0, validate_js_1.text)(code, 'textInput.placeholder', this.placeholder, 100, { optional: true });
+        if (placeholder !== undefined)
+            out.placeholder = placeholder;
+        out.min_length = this.minLength;
+        out.max_length = this.maxLength;
+        out.required = this.required;
+        const value = (0, validate_js_1.text)(code, 'textInput.value', this.value, 4000, { optional: true });
+        if (value !== undefined) {
+            if ([...value].length > this.maxLength)
+                (0, validate_js_1.fail)(code, 'textInput.value', 'is longer than maxLength.');
+            out.value = value;
+        }
+        return out;
+    }
+}
+exports.TextInputBuilder = TextInputBuilder;
+class ModalBuilder {
+    customId;
+    title;
+    rows = [];
+    setCustomId(customId) {
+        this.customId = customId;
+        return this;
+    }
+    setTitle(title) {
+        this.title = title;
+        return this;
+    }
+    addComponents(...rows) {
+        this.rows.push(...rows);
+        return this;
+    }
+    setComponents(...rows) {
+        this.rows = [...rows];
+        return this;
+    }
+    toJSON() {
+        const code = 'INVALID_COMPONENT';
+        if (!this.rows.length || this.rows.length > 5)
+            (0, validate_js_1.fail)(code, 'modal.components', 'needs 1-5 rows, each with one text input.');
+        const seen = new Set();
+        const components = this.rows.map((row) => {
+            const wrapped = row instanceof ActionRowBuilder_js_1.ActionRowBuilder ? row : new ActionRowBuilder_js_1.ActionRowBuilder().addComponents(row);
+            const json = wrapped.toModalJSON();
+            const id = json.components[0].custom_id;
+            if (seen.has(id))
+                (0, validate_js_1.fail)(code, 'modal.components', `custom id "${id}" is used twice.`);
+            seen.add(id);
+            return json;
+        });
+        return {
+            title: (0, validate_js_1.text)(code, 'modal.title', this.title, 45),
+            custom_id: (0, validate_js_1.text)(code, 'modal.customId', this.customId, 100),
+            components
+        };
+    }
+}
+exports.ModalBuilder = ModalBuilder;

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

@@ -0,0 +1,80 @@
+import type { APIComponent } from '../../types.js';
+import { ComponentBuilder, type EmojiInput } from './shared.js';
+export interface SelectOptionData {
+    label: string;
+    value: string;
+    description?: string;
+    emoji?: EmojiInput;
+    default?: boolean;
+}
+export declare class StringSelectMenuOptionBuilder {
+    data: Partial<SelectOptionData>;
+    constructor(data?: Partial<SelectOptionData>);
+    setLabel(label: string): this;
+    setValue(value: string): this;
+    setDescription(description: string): this;
+    setEmoji(emoji: EmojiInput): this;
+    setDefault(value?: boolean): this;
+    toJSON(path?: string): Record<string, unknown>;
+}
+declare abstract class SelectMenuBase extends ComponentBuilder {
+    protected customId?: string;
+    protected placeholder?: string;
+    protected min: number;
+    protected max: number;
+    protected disabled: boolean;
+    protected abstract readonly kind: number;
+    setCustomId(customId: string): this;
+    setPlaceholder(placeholder: string): this;
+    setMinValues(min: number): this;
+    setMaxValues(max: number): this;
+    setDisabled(disabled?: boolean): this;
+    protected finish(out: APIComponent, defaults: number): APIComponent;
+}
+export declare class StringSelectMenuBuilder extends SelectMenuBase {
+    protected readonly kind: 3;
+    private options;
+    addOptions(...options: (StringSelectMenuOptionBuilder | SelectOptionData)[]): this;
+    setOptions(...options: (StringSelectMenuOptionBuilder | SelectOptionData)[]): this;
+    toJSON(): APIComponent;
+}
+declare abstract class EntitySelectBuilder extends SelectMenuBase {
+    protected abstract readonly allowed: readonly string[];
+    protected defaults: {
+        id: string;
+        type: string;
+    }[];
+    protected addDefaults(...values: {
+        id: string;
+        type: string;
+    }[]): this;
+    protected build(): APIComponent;
+    toJSON(): APIComponent;
+}
+export declare class UserSelectMenuBuilder extends EntitySelectBuilder {
+    protected readonly kind: 5;
+    protected readonly allowed: string[];
+    setDefaultUsers(...ids: string[]): this;
+}
+export declare class RoleSelectMenuBuilder extends EntitySelectBuilder {
+    protected readonly kind: 6;
+    protected readonly allowed: string[];
+    setDefaultRoles(...ids: string[]): this;
+}
+export declare class MentionableSelectMenuBuilder extends EntitySelectBuilder {
+    protected readonly kind: 7;
+    protected readonly allowed: string[];
+    setDefaultValues(...values: {
+        id: string;
+        type: 'user' | 'role';
+    }[]): this;
+}
+export declare class ChannelSelectMenuBuilder extends EntitySelectBuilder {
+    protected readonly kind: 8;
+    protected readonly allowed: string[];
+    private types;
+    setDefaultChannels(...ids: string[]): this;
+    setChannelTypes(...types: (string | number)[]): this;
+    toJSON(): APIComponent;
+}
+export {};

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

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelSelectMenuBuilder = exports.MentionableSelectMenuBuilder = exports.RoleSelectMenuBuilder = exports.UserSelectMenuBuilder = exports.StringSelectMenuBuilder = exports.StringSelectMenuOptionBuilder = 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 StringSelectMenuOptionBuilder {
+    data;
+    constructor(data = {}) {
+        this.data = data;
+    }
+    setLabel(label) {
+        this.data.label = label;
+        return this;
+    }
+    setValue(value) {
+        this.data.value = value;
+        return this;
+    }
+    setDescription(description) {
+        this.data.description = description;
+        return this;
+    }
+    setEmoji(emoji) {
+        this.data.emoji = emoji;
+        return this;
+    }
+    setDefault(value = true) {
+        this.data.default = value;
+        return this;
+    }
+    toJSON(path = 'option') {
+        const code = 'INVALID_COMPONENT';
+        const out = {
+            label: (0, validate_js_1.text)(code, `${path}.label`, this.data.label, 100),
+            value: (0, validate_js_1.text)(code, `${path}.value`, this.data.value, 100)
+        };
+        const description = (0, validate_js_1.text)(code, `${path}.description`, this.data.description, 100, { optional: true });
+        const emoji = (0, shared_js_1.emojiJSON)(`${path}.emoji`, this.data.emoji);
+        if (description !== undefined)
+            out.description = description;
+        if (emoji)
+            out.emoji = emoji;
+        out.default = this.data.default ?? false;
+        return out;
+    }
+}
+exports.StringSelectMenuOptionBuilder = StringSelectMenuOptionBuilder;
+class SelectMenuBase extends shared_js_1.ComponentBuilder {
+    customId;
+    placeholder;
+    min = 1;
+    max = 1;
+    disabled = false;
+    setCustomId(customId) {
+        this.customId = customId;
+        return this;
+    }
+    setPlaceholder(placeholder) {
+        this.placeholder = placeholder;
+        return this;
+    }
+    setMinValues(min) {
+        this.min = min;
+        return this;
+    }
+    setMaxValues(max) {
+        this.max = max;
+        return this;
+    }
+    setDisabled(disabled = true) {
+        this.disabled = disabled;
+        return this;
+    }
+    finish(out, defaults) {
+        const code = 'INVALID_COMPONENT';
+        out.custom_id = (0, validate_js_1.text)(code, 'select.customId', this.customId, 100);
+        const placeholder = (0, validate_js_1.text)(code, 'select.placeholder', this.placeholder, 150, { optional: true });
+        if (placeholder !== undefined)
+            out.placeholder = placeholder;
+        (0, validate_js_1.range)(code, 'select.minValues', this.min, 0, 25);
+        (0, validate_js_1.range)(code, 'select.maxValues', this.max, 1, 25);
+        if (this.min > this.max)
+            (0, validate_js_1.fail)(code, 'select', 'has minValues above maxValues.');
+        if (defaults > this.max)
+            (0, validate_js_1.fail)(code, 'select', 'has more default values than maxValues allows.');
+        out.min_values = this.min;
+        out.max_values = this.max;
+        out.disabled = this.disabled;
+        return out;
+    }
+}
+class StringSelectMenuBuilder extends SelectMenuBase {
+    kind = constants_js_1.ComponentType.StringSelect;
+    options = [];
+    addOptions(...options) {
+        this.options.push(...options);
+        return this;
+    }
+    setOptions(...options) {
+        this.options = [...options];
+        return this;
+    }
+    toJSON() {
+        const code = 'INVALID_COMPONENT';
+        if (!this.options.length || this.options.length > 25)
+            (0, validate_js_1.fail)(code, 'select.options', 'needs 1-25 options.');
+        if (this.max > this.options.length)
+            (0, validate_js_1.fail)(code, 'select.maxValues', `can't be more than the number of options (${this.options.length}).`);
+        const seen = new Set();
+        const options = this.options.map((option, i) => {
+            const builder = option instanceof StringSelectMenuOptionBuilder ? option : new StringSelectMenuOptionBuilder(option);
+            const json = builder.toJSON(`select.options[${i}]`);
+            if (seen.has(json.value))
+                (0, validate_js_1.fail)(code, `select.options[${i}].value`, `"${json.value}" is used twice; option values must be unique.`);
+            seen.add(json.value);
+            return json;
+        });
+        const out = this.base(this.kind);
+        out.options = options;
+        return this.finish(out, options.filter((o) => o.default).length);
+    }
+}
+exports.StringSelectMenuBuilder = StringSelectMenuBuilder;
+class EntitySelectBuilder extends SelectMenuBase {
+    defaults = [];
+    addDefaults(...values) {
+        for (const value of values) {
+            if (!this.allowed.includes(value.type))
+                (0, validate_js_1.fail)('INVALID_COMPONENT', 'select.defaultValues', `type must be ${this.allowed.join(' or ')}.`);
+        }
+        this.defaults.push(...values);
+        return this;
+    }
+    build() {
+        const out = this.base(this.kind);
+        if (this.defaults.length)
+            out.default_values = this.defaults;
+        return this.finish(out, this.defaults.length);
+    }
+    toJSON() {
+        return this.build();
+    }
+}
+class UserSelectMenuBuilder extends EntitySelectBuilder {
+    kind = constants_js_1.ComponentType.UserSelect;
+    allowed = ['user'];
+    setDefaultUsers(...ids) {
+        return this.addDefaults(...ids.map((id) => ({ id, type: 'user' })));
+    }
+}
+exports.UserSelectMenuBuilder = UserSelectMenuBuilder;
+class RoleSelectMenuBuilder extends EntitySelectBuilder {
+    kind = constants_js_1.ComponentType.RoleSelect;
+    allowed = ['role'];
+    setDefaultRoles(...ids) {
+        return this.addDefaults(...ids.map((id) => ({ id, type: 'role' })));
+    }
+}
+exports.RoleSelectMenuBuilder = RoleSelectMenuBuilder;
+class MentionableSelectMenuBuilder extends EntitySelectBuilder {
+    kind = constants_js_1.ComponentType.MentionableSelect;
+    allowed = ['user', 'role'];
+    setDefaultValues(...values) {
+        return this.addDefaults(...values);
+    }
+}
+exports.MentionableSelectMenuBuilder = MentionableSelectMenuBuilder;
+const CHANNEL_TYPES = new Set(['text', 'dm', 'voice', 'group_dm', 'category', 'announcement', 'thread', 'stage', 'forum', 0, 1, 2, 3, 4, 5, 10, 11, 12, 13, 15]);
+class ChannelSelectMenuBuilder extends EntitySelectBuilder {
+    kind = constants_js_1.ComponentType.ChannelSelect;
+    allowed = ['channel'];
+    types = [];
+    setDefaultChannels(...ids) {
+        return this.addDefaults(...ids.map((id) => ({ id, type: 'channel' })));
+    }
+    setChannelTypes(...types) {
+        for (const type of types) {
+            if (!CHANNEL_TYPES.has(type))
+                (0, validate_js_1.fail)('INVALID_COMPONENT', 'select.channelTypes', `"${type}" is not a channel type.`);
+        }
+        this.types = [...new Set(types)];
+        return this;
+    }
+    toJSON() {
+        const out = this.build();
+        if (this.types.length)
+            out.channel_types = this.types;
+        return out;
+    }
+}
+exports.ChannelSelectMenuBuilder = ChannelSelectMenuBuilder;

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

@@ -0,0 +1,16 @@
+import type { APIComponent } from '../../types.js';
+import { type Serializable } from '../validate.js';
+export type EmojiInput = string | {
+    id?: string;
+    name?: string;
+    animated?: boolean;
+};
+export type ComponentInput<T extends Serializable = Serializable> = T | APIComponent;
+export declare function emojiJSON(path: string, emoji: EmojiInput | undefined): Record<string, unknown> | undefined;
+export declare function jsonList(list: readonly ComponentInput[]): APIComponent[];
+export declare abstract class ComponentBuilder {
+    protected componentId?: number;
+    setId(id: number): this;
+    protected base(type: number): APIComponent;
+    abstract toJSON(): APIComponent;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentBuilder = void 0;
+exports.emojiJSON = emojiJSON;
+exports.jsonList = jsonList;
+const validate_js_1 = require("../validate.js");
+function emojiJSON(path, emoji) {
+    if (emoji === undefined)
+        return undefined;
+    if (typeof emoji === 'string') {
+        if (!emoji.trim())
+            return (0, validate_js_1.fail)('INVALID_COMPONENT', path, 'must be an emoji.');
+        return { name: emoji.trim() };
+    }
+    if (!emoji.id && !emoji.name)
+        return (0, validate_js_1.fail)('INVALID_COMPONENT', path, 'needs a name (Unicode emoji) or an id (custom emoji).');
+    return emoji.id ? { id: emoji.id, name: emoji.name ?? 'emoji', animated: emoji.animated ?? false } : { name: emoji.name };
+}
+function jsonList(list) {
+    return list.map((item) => (0, validate_js_1.resolveJSON)(item));
+}
+class ComponentBuilder {
+    componentId;
+    setId(id) {
+        this.componentId = id;
+        return this;
+    }
+    base(type) {
+        return this.componentId === undefined ? { type } : { type, id: this.componentId };
+    }
+}
+exports.ComponentBuilder = ComponentBuilder;

package/dist/cjs/builders/messagePayload.d.ts

@@ -0,0 +1,35 @@
+import { AttachmentBuilder, type RawFile } from '../rest/files.js';
+import type { APIComponent, APIEmbed } from '../types.js';
+import { EmbedBuilder } from './EmbedBuilder.js';
+import { type Serializable } from './validate.js';
+export interface PollData {
+    question: string;
+    answers: {
+        text: string;
+        emoji?: string;
+    }[];
+    duration?: number;
+    allowMultiselect?: boolean;
+}
+export interface MessageOptions {
+    content?: string;
+    embeds?: (EmbedBuilder | APIEmbed)[];
+    components?: (Serializable | APIComponent)[];
+    files?: (AttachmentBuilder | RawFile)[];
+    flags?: number;
+    ephemeral?: boolean;
+    replyTo?: string;
+    mentionReply?: boolean;
+    stickers?: string[];
+    poll?: PollData;
+    nonce?: string;
+}
+export interface ResolvedMessage {
+    body: Record<string, unknown>;
+    files: RawFile[];
+}
+export declare function checkComponents(list: APIComponent[], v2: boolean): void;
+export declare function resolveEmbeds(embeds: (EmbedBuilder | APIEmbed)[]): APIEmbed[];
+export declare function resolveMessage(input: string | MessageOptions, options?: {
+    allowEphemeral?: boolean;
+}): ResolvedMessage;

package/dist/cjs/builders/messagePayload.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkComponents = checkComponents;
+exports.resolveEmbeds = resolveEmbeds;
+exports.resolveMessage = resolveMessage;
+const BaffError_js_1 = require("../errors/BaffError.js");
+const files_js_1 = require("../rest/files.js");
+const constants_js_1 = require("../util/constants.js");
+const EmbedBuilder_js_1 = require("./EmbedBuilder.js");
+const validate_js_1 = require("./validate.js");
+const V2_ONLY = new Set([constants_js_1.ComponentType.Section, constants_js_1.ComponentType.TextDisplay, constants_js_1.ComponentType.MediaGallery, constants_js_1.ComponentType.Separator, constants_js_1.ComponentType.Container]);
+const MAX_COMPONENTS = 40;
+const MAX_ROWS = 5;
+const MAX_TEXT = 4000;
+function checkComponents(list, v2) {
+    const code = 'INVALID_COMPONENT';
+    if (!v2 && list.length > MAX_ROWS)
+        throw new BaffError_js_1.BaffError(code, `A message can have up to ${MAX_ROWS} action rows (or use the IsComponentsV2 flag).`);
+    let total = 0;
+    let textLength = 0;
+    const ids = new Set();
+    const visit = (component) => {
+        total++;
+        if (typeof component.custom_id === 'string') {
+            if (ids.has(component.custom_id))
+                throw new BaffError_js_1.BaffError(code, `Custom id "${component.custom_id}" is used twice in one message.`);
+            ids.add(component.custom_id);
+        }
+        if (component.type === constants_js_1.ComponentType.TextDisplay)
+            textLength += [...String(component.content)].length;
+        for (const child of component.components ?? [])
+            visit(child);
+        if (component.accessory)
+            visit(component.accessory);
+    };
+    list.forEach(visit);
+    if (total > MAX_COMPONENTS)
+        throw new BaffError_js_1.BaffError(code, `A message can have up to ${MAX_COMPONENTS} components in total (nested ones included); this has ${total}.`);
+    if (textLength > MAX_TEXT)
+        throw new BaffError_js_1.BaffError(code, `Text displays can have up to ${MAX_TEXT} characters in total; this has ${textLength}.`);
+}
+function resolveEmbeds(embeds) {
+    if (embeds.length > EmbedBuilder_js_1.EmbedLimits.embeds)
+        throw new BaffError_js_1.BaffError('INVALID_EMBED', `A message can have up to ${EmbedBuilder_js_1.EmbedLimits.embeds} embeds.`);
+    const out = embeds.map((embed) => (embed instanceof EmbedBuilder_js_1.EmbedBuilder ? embed.toJSON() : new EmbedBuilder_js_1.EmbedBuilder(embed).toJSON()));
+    const total = embeds.reduce((sum, embed) => sum + (embed instanceof EmbedBuilder_js_1.EmbedBuilder ? embed : new EmbedBuilder_js_1.EmbedBuilder(embed)).length, 0);
+    if (total > EmbedBuilder_js_1.EmbedLimits.total)
+        throw new BaffError_js_1.BaffError('INVALID_EMBED', `Embeds can have up to ${EmbedBuilder_js_1.EmbedLimits.total} characters in total; these have ${total}.`);
+    return out;
+}
+function resolveMessage(input, options = {}) {
+    const message = typeof input === 'string' ? { content: input } : input;
+    const body = {};
+    let flags = message.flags ?? 0;
+    if (message.content !== undefined)
+        body.content = message.content;
+    if (message.embeds)
+        body.embeds = resolveEmbeds(message.embeds);
+    if (message.components) {
+        const components = message.components.map((c) => (0, validate_js_1.resolveJSON)(c));
+        if (components.some((c) => V2_ONLY.has(c.type)))
+            flags |= constants_js_1.MessageFlags.IsComponentsV2;
+        checkComponents(components, (flags & constants_js_1.MessageFlags.IsComponentsV2) !== 0);
+        body.components = components;
+    }
+    if ((flags & constants_js_1.MessageFlags.IsComponentsV2) !== 0 && (body.content || body.embeds?.length)) {
+        throw new BaffError_js_1.BaffError('INVALID_COMPONENT', 'A message with the IsComponentsV2 flag can not have content or embeds: put the text in text displays.');
+    }
+    if (message.ephemeral) {
+        if (!options.allowEphemeral)
+            throw new BaffError_js_1.BaffError('INVALID_MESSAGE', 'ephemeral only works on interaction replies.');
+        body.ephemeral = true;
+    }
+    if (flags)
+        body.flags = flags;
+    if (message.replyTo)
+        body.replyTo = message.replyTo;
+    if (message.mentionReply !== undefined)
+        body.mentionReply = message.mentionReply;
+    if (message.stickers?.length)
+        body.stickerIds = message.stickers;
+    if (message.poll)
+        body.poll = message.poll;
+    if (message.nonce)
+        body.nonce = message.nonce;
+    const files = (message.files ?? []).map((f) => (f instanceof files_js_1.AttachmentBuilder ? f.toFile() : f));
+    return { body, files };
+}

package/dist/cjs/builders/validate.d.ts

@@ -0,0 +1,12 @@
+export declare function fail(code: string, path: string, message: string): never;
+export declare function text(code: string, path: string, value: unknown, max: number, options?: {
+    min?: number;
+    optional?: boolean;
+}): string | undefined;
+export declare function url(code: string, path: string, value: unknown, optional?: boolean): string | undefined;
+export declare function range(code: string, path: string, value: number, min: number, max: number): number;
+export interface Serializable {
+    toJSON(): unknown;
+}
+export declare function isSerializable(value: unknown): value is Serializable;
+export declare function resolveJSON<T>(value: T | Serializable): T;

package/dist/cjs/builders/validate.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fail = fail;
+exports.text = text;
+exports.url = url;
+exports.range = range;
+exports.isSerializable = isSerializable;
+exports.resolveJSON = resolveJSON;
+const BaffError_js_1 = require("../errors/BaffError.js");
+function fail(code, path, message) {
+    throw new BaffError_js_1.BaffError(code, `${path} ${message}`);
+}
+function text(code, path, value, max, options = {}) {
+    if (value === undefined || value === null || value === '') {
+        if (options.optional)
+            return undefined;
+        return fail(code, path, `is required (${options.min ?? 1}-${max} characters).`);
+    }
+    if (typeof value !== 'string')
+        return fail(code, path, 'must be a string.');
+    if ((options.min ?? 1) > value.length || [...value].length > max)
+        return fail(code, path, `must be ${options.min ?? 1}-${max} characters.`);
+    return value;
+}
+function url(code, path, value, optional = true) {
+    if (value === undefined || value === null) {
+        if (optional)
+            return undefined;
+        return fail(code, path, 'is required.');
+    }
+    if (typeof value !== 'string' || value.length > 2048)
+        return fail(code, path, 'must be an http:// or https:// URL.');
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        return fail(code, path, 'must be an http:// or https:// URL.');
+    }
+    if (!/^https?:$/.test(parsed.protocol) || parsed.username || parsed.password)
+        return fail(code, path, 'must be an http:// or https:// URL.');
+    return value;
+}
+function range(code, path, value, min, max) {
+    if (!Number.isInteger(value) || value < min || value > max)
+        return fail(code, path, `must be a whole number from ${min} to ${max}.`);
+    return value;
+}
+function isSerializable(value) {
+    return typeof value === 'object' && value !== null && typeof value.toJSON === 'function';
+}
+function resolveJSON(value) {
+    return (isSerializable(value) ? value.toJSON() : value);
+}