chapterjs 0.1.4 → 0.2.1

package/dist/components/file.js

@@ -1,52 +0,0 @@
-// What `button()`, `select()`, `modal()` and `embed()` return: the default
-// export of a file of `src/components/`. It is a function (called with the
-// data the component carries) that the loader recognises, checks, and binds
-// to the path of its file: that path is the custom_id. Until then it can't
-// make anything, which is how a definition outside `src/components/` is
-// refused.
-import { piece, pieceFunction, } from './instance.js';
-export const COMPONENT_FOLDERS = {
-    buttons: 'button',
-    selects: 'select',
-    modals: 'modal',
-    embeds: 'embed',
-};
-const FILE = Symbol.for('chapterjs.component.file');
-/** The state of a component file, if the value is one. */
-export function fileStateOf(value) {
-    if (typeof value !== 'function')
-        return undefined;
-    return value[FILE];
-}
-/**
- * Makes a component file. `asPiece` says whether the file itself stands
- * for its instance when it carries no data (a button, a menu, a modal: not
- * an embed, which is only a function).
- */
-export function createFile(kind, config, { asPiece, pieceKind }) {
-    const state = { kind, config, made: `${kind}()` };
-    const notBound = () => {
-        throw new Error(`This ${kind} was not loaded by ChapterJS: a ${kind} is a file of src/components/${Object.keys(COMPONENT_FOLDERS).find(folder => COMPONENT_FOLDERS[folder] === kind)}/, exported by default, and used after the bot started.`);
-    };
-    const file = (...args) => {
-        if (!state.bound)
-            return notBound();
-        const rendered = state.bound.render(args);
-        return pieceKind
-            ? piece(pieceKind, rendered.raw)
-            : rendered;
-    };
-    Object.defineProperty(file, FILE, { value: state });
-    Object.defineProperty(file, 'config', { value: config, enumerable: true });
-    if (asPiece) {
-        pieceFunction(file, () => state.bound ? state.bound.render([]) : notBound());
-    }
-    return file;
-}
-/** Binds a file to its path and to what makes its instances. */
-export function bindFile(file, bound) {
-    const state = fileStateOf(file);
-    if (!state)
-        throw new TypeError('Not a component file.');
-    state.bound = bound;
-}

package/dist/events/convention.d.ts

@@ -1,25 +0,0 @@
-import type { Convention } from '../loader/loader.js';
-import { type EventContexts, type EventName } from './registry.js';
-/** One reaction to an event: a file of `src/events/<event>/`. */
-export interface EventHandler<Name extends EventName = EventName> {
-    /** The event, which is the name of the folder the file is in. */
-    readonly name: Name;
-    readonly handler: (context: EventContexts[Name]) => unknown;
-    /** The options the file gave to `event()`, checked. */
-    readonly options: Readonly<Record<string, unknown>>;
-}
-/**
- * `src/events/`: one folder per event, named after it, and in it one file
- * per reaction. The name of a file is free; it exports by default what
- * `event()` returns:
- *
- * ```ts
- * // src/events/memberJoin/welcome.ts
- * import { event } from 'chapterjs';
- *
- * export default event(async ({ member, guild }) => {
- *   await member.send(`Welcome to ${guild.name}!`);
- * });
- * ```
- */
-export declare const eventsConvention: Convention<EventHandler>;

package/dist/events/convention.js

@@ -1,97 +0,0 @@
-import { isEventFile } from './event.js';
-import { EVENT_NAMES, EVENTS, isEventName, } from './registry.js';
-/** Checks the second argument of `event()` against what the event accepts. */
-function readOptions(name, options) {
-    if (options === undefined)
-        return Object.freeze({});
-    const allowed = EVENTS[name].options ?? {};
-    const names = Object.keys(allowed);
-    const first = names[0];
-    const kind = first === undefined ? undefined : allowed[first];
-    const example = first === undefined
-        ? 'option: true'
-        : `${first}: ${kind === 'boolean' || !kind ? 'true' : `'${kind.at(-1)}'`}`;
-    const list = names.length === 0
-        ? `${name} has no options: remove the second argument of event().`
-        : `Options of ${name} are: ${names.join(', ')}.`;
-    if (typeof options !== 'object' ||
-        options === null ||
-        Array.isArray(options)) {
-        throw new TypeError(`The second argument of event() is its options, like { ${example} }. ${list}`);
-    }
-    for (const [key, value] of Object.entries(options)) {
-        if (!Object.hasOwn(allowed, key)) {
-            throw new TypeError(`"${key}" is not an option of ${name}. ${list}`);
-        }
-        const kind = allowed[key];
-        const got = JSON.stringify(value) ?? typeof value;
-        if (kind === 'boolean') {
-            if (typeof value !== 'boolean') {
-                throw new TypeError(`The option ${key} of ${name} is true or false, got ${got}.`);
-            }
-        }
-        else if (!kind.includes(value)) {
-            throw new TypeError(`The option ${key} of ${name} is ${kind
-                .map(word => `'${word}'`)
-                .join(', ')
-                .replace(/, ([^,]*)$/, ' or $1')}, got ${got}.`);
-        }
-    }
-    return Object.freeze({ ...options });
-}
-/** " Did you mean "x"?" when a name is close to a real one. */
-function suggest(name) {
-    const wanted = name.toLowerCase().replace(/[^a-z]/g, '');
-    if (wanted === '')
-        return '';
-    const close = EVENT_NAMES.find(event => {
-        const real = event.toLowerCase();
-        return real === wanted || real.includes(wanted) || wanted.includes(real);
-    });
-    return close ? ` Did you mean "${close}"?` : '';
-}
-/**
- * `src/events/`: one folder per event, named after it, and in it one file
- * per reaction. The name of a file is free; it exports by default what
- * `event()` returns:
- *
- * ```ts
- * // src/events/memberJoin/welcome.ts
- * import { event } from 'chapterjs';
- *
- * export default event(async ({ member, guild }) => {
- *   await member.send(`Welcome to ${guild.name}!`);
- * });
- * ```
- */
-export const eventsConvention = {
-    folder: 'events',
-    one: 'event',
-    many: 'events',
-    /** The event of a file, from its path: known without running the file. */
-    check(path) {
-        const parts = path.split('/');
-        if (parts.length < 2) {
-            throw new TypeError(`This file is directly in src/events/. Put it in a folder named after the event it reacts to, like src/events/messageCreate/${path}. Events are: ${EVENT_NAMES.join(', ')}.`);
-        }
-        const name = parts[0];
-        if (!isEventName(name)) {
-            throw new TypeError(`The folder src/events/${name} is not named after an event.${suggest(name)} Events are: ${EVENT_NAMES.join(', ')}.`);
-        }
-    },
-    read(exports, path) {
-        const name = path.split('/')[0];
-        const file = exports.default;
-        if (!isEventFile(file)) {
-            const example = `import { event } from 'chapterjs'; export default event(({ ... }) => { ... })`;
-            throw new TypeError('default' in exports
-                ? `The default export of this file must be what event() returns: ${example}`
-                : `This file has no default export. It should look like: ${example}`);
-        }
-        return Object.freeze({
-            name,
-            handler: file.handler,
-            options: readOptions(name, file.options),
-        });
-    },
-};

package/dist/events/types.d.ts

@@ -1,7 +0,0 @@
-import type { TypedFolder } from '../loader/generated.js';
-/**
- * One typed folder per event: in `src/events/<event>/`, the `event()`
- * imported from 'chapterjs' gives its handler what that event gives.
- * Written for every event, so a new folder is typed as soon as it exists.
- */
-export declare function eventTypedFolders(): TypedFolder[];

package/dist/events/types.js

@@ -1,48 +0,0 @@
-import { EVENT_NAMES, EVENTS } from './registry.js';
-/**
- * One typed folder per event: in `src/events/<event>/`, the `event()`
- * imported from 'chapterjs' gives its handler what that event gives.
- * Written for every event, so a new folder is typed as soon as it exists.
- */
-export function eventTypedFolders() {
-    return EVENT_NAMES.map(name => {
-        const hasOptions = EVENTS[name].options !== undefined;
-        return {
-            id: `events.${name}`,
-            // At any depth: the event folder may be inside `(group)` folders.
-            folder: `src/events/**/${name}`,
-            declarations: hasOptions
-                ? `import type { ContextOf, EventFile, EventOptions } from '#chapterjs';
-
-/**
- * Says what to do when \`${name}\` happens. Export the result as the default
- * export of a file of src/events/${name}/.
- *
- * What the function receives follows the options: what an option lets
- * through is only there to handle in the files that turn it on.
- */
-export declare function event<
-  const Options extends EventOptions['${name}'] = {},
->(
-  handler: (context: ContextOf<'${name}', Options>) => unknown,
-  // The options of the event come first so editors offer them; the rest
-  // makes a misspelled option an error instead of something ignored.
-  options?: EventOptions['${name}'] &
-    Options & {
-      [Key in Exclude<keyof Options, keyof EventOptions['${name}']>]: never;
-    }
-): EventFile;
-`
-                : `import type { ContextOf, EventFile } from '#chapterjs';
-
-/**
- * Says what to do when \`${name}\` happens. Export the result as the default
- * export of a file of src/events/${name}/.
- */
-export declare function event(
-  handler: (context: ContextOf<'${name}'>) => unknown
-): EventFile;
-`,
-        };
-    });
-}

package/dist/messages/convention.d.ts

@@ -1,89 +0,0 @@
-import type { Locale } from '../discord/types/common.js';
-import type { TypedFolder } from '../loader/generated.js';
-import { type Convention, type FailedFile, type FoundFile } from '../loader/loader.js';
-import { type LoadedMessages, type Template } from './translate.js';
-/** A language file, checked: what the languages are assembled from. */
-export interface LoadedLanguage {
-    /** The language, from the name of the file. */
-    readonly locale: Locale;
-    /** Whether the file says it is the default language. */
-    readonly isDefault: boolean;
-    /** The texts, compiled. */
-    readonly texts: ReadonlyMap<string, Template>;
-    /** The phrases of the framework this file translates, compiled. */
-    readonly framework: ReadonlyMap<string, Template>;
-    /** The `commands` section, by the path of the command file, not checked yet. */
-    readonly commands: Readonly<Record<string, unknown>> | undefined;
-}
-/**
- * `src/messages/`: one file per language. Each file exports by default
- * what `language()` returns:
- *
- * ```ts
- * // src/messages/fr.ts
- * import { language } from 'chapterjs';
- *
- * export default language({ texts: { pong: 'Pong !' } });
- * ```
- */
-export declare const languagesConvention: Convention<LoadedLanguage>;
-/** A language file as the project loaded it. */
-export interface LanguageEntry {
-    readonly file: string;
-    readonly language: LoadedLanguage;
-}
-/**
- * Puts the languages together: one default, which `t` is typed from and
- * gives a text to the languages that do not have it, and every other
- * language with texts the default has, the same placeholders included. A
- * language that does not match is left out and reported on its file: the
- * others still work. `null` when there is no language at all.
- */
-export declare function assembleMessages(entries: readonly LanguageEntry[]): {
-    messages: LoadedMessages | null;
-    failed: FailedFile[];
-};
-/**
- * The augmentation that types `t` from the files themselves: the editor
- * reads the default language of `src/messages/` directly, so the keys
- * and placeholders follow every keystroke; the other languages take the
- * texts they do not have from it. Which file is the default is known
- * once the files ran (`defaultFile`, from the loaded messages): until
- * then (`sync`), the first file is taken. Nothing when the folder has no
- * language.
- */
-export declare function messagesDeclarations(files: readonly FoundFile[], defaultFile?: string): string;
-/**
- * One typed folder per language file: in `src/messages/fr.ts`, the
- * `language()` imported from 'chapterjs' knows the other files. When
- * another one says `default: true` (`defaults`, the files that do, known
- * once they ran: `dev` and `build` give them, `sync` runs nothing), it
- * refuses `default: true`, naming that file: a second default language is
- * underlined in the editor, and no longer only reported in the console.
- * Each project takes `main` (the commands a language file may translate)
- * and not `shared`, which types `t` from the default file: a language file
- * checked with the `language()` of another would be a false error.
- */
-export declare function languageTypedFolders(files: readonly FoundFile[], defaults?: readonly string[]): TypedFolder[];
-/** A command file, and whether it has its own `description`. */
-export interface DeclaredCommand {
-    /** `src/commands/(mod)/mod/ban.ts` */
-    readonly file: string;
-    /**
-     * Whether the file gives its own texts; `false` when it is not known,
-     * like before the file ran: the language files may then describe it.
-     */
-    readonly described: boolean;
-}
-/**
- * The augmentation that offers the commands of the project in the
- * `commands` of a language file: the path of each command file, `true`
- * when the language files describe it and `false` when the file has its
- * own `description`, so that the editor only offers the first ones. The
- * path comes from the file name; whether it is described comes from
- * running the file (`dev` and `build` know it, `sync` does not). The
- * command files themselves are never referred to: their `t` is typed from
- * the languages, which would be a circle. Nothing when the project has no
- * command.
- */
-export declare function commandsDeclarations(commands: readonly DeclaredCommand[]): string;

package/dist/messages/convention.js

@@ -1,347 +0,0 @@
-// `src/messages/`: one file per language, named after it (`fr.ts` is the
-// French of the bot). What a file declares is checked when it loads, and
-// the languages are checked against each other once loaded: every one has
-// the texts of the default language, with the same placeholders, so a
-// missing text is explained before anyone asks for it.
-import { commandName } from '../commands/tree.js';
-import { logicalPath, } from '../loader/loader.js';
-import { isLanguageFile } from './messages.js';
-import { FRAMEWORK, FRAMEWORK_KEYS } from './phrases.js';
-import { compile, compilePlural, LOCALES, PLURAL_FORMS, } from './translate.js';
-const fail = message => {
-    throw new TypeError(message);
-};
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-const NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const KEYS = ['default', 'texts', 'commands', 'framework'];
-const EXAMPLE = `language({ texts: { pong: 'Pong!' } })`;
-/** Placeholders, for a message: `{name}, {count}`, or `none`. */
-const showParams = (names) => names.length === 0 ? 'none' : names.map(name => `{${name}}`).join(', ');
-/** Whether two templates take the same placeholders. */
-const samePlaceholders = (a, b) => [...a.params].sort().join('\0') === [...b.params].sort().join('\0');
-/** One form of a text, cut around its placeholders, each one checked. */
-function readForm(what, text, example) {
-    if (typeof text !== 'string' || text === '') {
-        fail(`${what} must be a text: ${example}`);
-    }
-    const template = compile(text);
-    for (const name of template.params) {
-        if (!NAME.test(name)) {
-            fail(`${what} has a placeholder "{${name}}": a placeholder is a name made of letters, digits and _, like {name}.`);
-        }
-    }
-    return template;
-}
-/**
- * A text of a language file: a string, or a plural (one form per
- * quantity, `other` at least), with an error saying what to write.
- */
-function readText(key, text, kind = 'message') {
-    const what = `The ${kind} "${key}"`;
-    if (isRecord(text)) {
-        const forms = new Map();
-        for (const [form, one] of Object.entries(text)) {
-            if (!PLURAL_FORMS.includes(form)) {
-                fail(`"${form}" is not a form of the plural "${key}". A plural has: ${PLURAL_FORMS.join(', ')} (other at least): ${key}: { one: '{count} member', other: '{count} members' }`);
-            }
-            forms.set(form, readForm(`The form "${form}" of the plural "${key}"`, one, `${form}: '{count} members'`));
-        }
-        if (!forms.has('other')) {
-            fail(`The plural "${key}" needs an "other" form, used when no other form fits: ${key}: { one: '{count} member', other: '{count} members' }`);
-        }
-        return compilePlural(forms);
-    }
-    return readForm(what, text, `${key}: 'Hello {name}!'${kind === 'message' ? `, or a plural: ${key}: { one: '{count} member', other: '{count} members' }` : ''}`);
-}
-/** The language a file is named after, or an error saying which ones exist. */
-function localeOf(path) {
-    const name = path.replace(/\.[^./]+$/, '');
-    if (name.includes('/')) {
-        fail(`A language is a file directly in src/messages/, named after the language: src/messages/${name.split('/').pop()}.ts. It can't be in a subfolder.`);
-    }
-    if (!LOCALES.has(name)) {
-        fail(`"${name}" is not a language Discord knows: the name of a file of src/messages/ is the language it holds. It can be: ${[...LOCALES].join(', ')}.`);
-    }
-    return name;
-}
-/**
- * `src/messages/`: one file per language. Each file exports by default
- * what `language()` returns:
- *
- * ```ts
- * // src/messages/fr.ts
- * import { language } from 'chapterjs';
- *
- * export default language({ texts: { pong: 'Pong !' } });
- * ```
- */
-export const languagesConvention = {
-    folder: 'messages',
-    one: 'language',
-    many: 'languages',
-    check(path) {
-        localeOf(path);
-    },
-    read(exports, path) {
-        const locale = localeOf(path);
-        const file = exports.default;
-        const example = `import { language } from 'chapterjs'; export default ${EXAMPLE}`;
-        if (!isLanguageFile(file)) {
-            return fail('default' in exports
-                ? `The default export of this file must be what language() returns: ${example}`
-                : `This file has no default export. It should look like: ${example}`);
-        }
-        const config = file.config;
-        if (!isRecord(config)) {
-            return fail(`language() needs an object: ${EXAMPLE}`);
-        }
-        for (const key of Object.keys(config)) {
-            if (!KEYS.includes(key)) {
-                fail(`"${key}" is not something a language has. It can have: ${KEYS.join(', ')}.`);
-            }
-        }
-        if (config.default !== undefined && typeof config.default !== 'boolean') {
-            fail(`"default" is true or false, got ${JSON.stringify(config.default)}.`);
-        }
-        if (!isRecord(config.texts)) {
-            fail(`"texts" is an object, one text per key: texts: { pong: 'Pong!', welcome: 'Welcome {name}!' }`);
-        }
-        const texts = new Map();
-        for (const [key, text] of Object.entries(config.texts)) {
-            texts.set(key, readText(key, text));
-        }
-        const framework = new Map();
-        if (config.framework !== undefined) {
-            if (!isRecord(config.framework)) {
-                fail(`"framework" is an object, one phrase per key: framework: { guildOnly: '...' }. It can have: ${FRAMEWORK_KEYS.join(', ')}.`);
-            }
-            for (const [key, text] of Object.entries(config.framework)) {
-                const expected = FRAMEWORK.get(key);
-                if (!expected) {
-                    fail(`"${key}" is not a phrase of the framework. It can be: ${FRAMEWORK_KEYS.join(', ')}.`);
-                }
-                const template = readText(key, text, 'phrase');
-                if (!samePlaceholders(template, expected)) {
-                    fail(`The phrase "${key}" does not have the placeholders of the framework: it has ${showParams(template.params)}, the framework has ${showParams(expected.params)}.`);
-                }
-                framework.set(key, template);
-            }
-        }
-        if (config.commands !== undefined) {
-            if (!isRecord(config.commands)) {
-                fail(`"commands" is an object whose keys are the paths of your command files: commands: { ping: { description: '...' }, 'mod/ban': { name: '...' } }`);
-            }
-            for (const [path, translation] of Object.entries(config.commands)) {
-                if (!/^[a-z0-9_-]+(?:\/[a-z0-9_-]+){0,2}$/.test(path)) {
-                    fail(`"${path}" in "commands" is not the path of a command file: write it as the file is named, like 'ping' or 'mod/ban'.`);
-                }
-                if (!isRecord(translation)) {
-                    fail(`The texts of the command ${commandName(path.split('/'))} must be an object like { name: '...', description: '...' }.`);
-                }
-            }
-        }
-        return {
-            locale,
-            isDefault: config.default === true,
-            texts,
-            framework,
-            commands: config.commands,
-        };
-    },
-};
-/**
- * Puts the languages together: one default, which `t` is typed from and
- * gives a text to the languages that do not have it, and every other
- * language with texts the default has, the same placeholders included. A
- * language that does not match is left out and reported on its file: the
- * others still work. `null` when there is no language at all.
- */
-export function assembleMessages(entries) {
-    if (entries.length === 0)
-        return { messages: null, failed: [] };
-    const failed = [];
-    const defaults = entries.filter(({ language }) => language.isDefault);
-    let reference;
-    if (entries.length === 1) {
-        reference = entries[0];
-    }
-    else if (defaults.length === 1) {
-        reference = defaults[0];
-    }
-    else if (defaults.length === 0) {
-        // No default: nothing can be assembled.
-        return {
-            messages: null,
-            failed: entries.map(({ file }) => ({
-                file,
-                error: new TypeError(`None of the ${entries.length} languages of src/messages/ is the default one, used when the language of a person or of a server is not there. Add default: true in one of them.`),
-            })),
-        };
-    }
-    else {
-        return {
-            messages: null,
-            failed: defaults.map(({ file }) => ({
-                file,
-                error: new TypeError(`${defaults.length} languages say default: true (${defaults.map(({ file }) => file).join(', ')}): only one can be the default.`),
-            })),
-        };
-    }
-    const locales = new Map();
-    const framework = new Map();
-    const commands = new Map();
-    const files = new Map();
-    const name = reference.file.split('/').pop();
-    for (const entry of entries) {
-        const { file, language } = entry;
-        try {
-            // A text a language does not have is taken from the default one;
-            // one the default does not have is dead: `t` offers the default's.
-            if (entry !== reference) {
-                for (const [key, template] of language.texts) {
-                    const expected = reference.language.texts.get(key);
-                    if (!expected) {
-                        fail(`The message "${key}" is not in ${name}: add it there, or remove it here.`);
-                    }
-                    if (!samePlaceholders(template, expected)) {
-                        fail(`The message "${key}" does not have the placeholders of ${name}: it has ${showParams([...template.params].sort())}, ${name} has ${showParams([...expected.params].sort())}.`);
-                    }
-                }
-            }
-            locales.set(language.locale, language.texts);
-            if (language.framework.size > 0) {
-                framework.set(language.locale, language.framework);
-            }
-            files.set(language.locale, file);
-            if (language.commands)
-                commands.set(language.locale, language.commands);
-        }
-        catch (error) {
-            failed.push({ file, error });
-        }
-    }
-    return {
-        messages: {
-            default: reference.language.locale,
-            locales,
-            framework,
-            commands,
-            files,
-        },
-        failed,
-    };
-}
-/**
- * The augmentation that types `t` from the files themselves: the editor
- * reads the default language of `src/messages/` directly, so the keys
- * and placeholders follow every keystroke; the other languages take the
- * texts they do not have from it. Which file is the default is known
- * once the files ran (`defaultFile`, from the loaded messages): until
- * then (`sync`), the first file is taken. Nothing when the folder has no
- * language.
- */
-export function messagesDeclarations(files, defaultFile) {
-    const named = namedFiles(files);
-    const first = named.find(({ file }) => file === defaultFile) ?? named[0];
-    if (!first)
-        return '';
-    const path = first.file.replace(/^src\//, '').replace(/\.[^./]+$/, '');
-    const locales = named
-        .map(({ locale }) => `    ${JSON.stringify(locale)}: true;`)
-        .sort()
-        .join('\n');
-    return `import type { MessagesOf } from '#chapterjs';
-
-declare module 'chapterjs' {
-  /** The texts of src/messages/, as ${first.file} writes them: what \`t\` accepts. */
-  export interface ProjectMessages
-    extends MessagesOf<typeof import('../../src/${path}').default> {}
-  /** The languages of src/messages/: what \`t.in()\` offers. */
-  export interface ProjectLocales {
-${locales}
-  }
-}
-`;
-}
-/** The files of `src/messages/` named after a language, with it. */
-function namedFiles(files) {
-    return files.flatMap(({ file }) => {
-        try {
-            return [{ file, locale: localeOf(file.slice('src/messages/'.length)) }];
-        }
-        catch {
-            return [];
-        }
-    });
-}
-/**
- * One typed folder per language file: in `src/messages/fr.ts`, the
- * `language()` imported from 'chapterjs' knows the other files. When
- * another one says `default: true` (`defaults`, the files that do, known
- * once they ran: `dev` and `build` give them, `sync` runs nothing), it
- * refuses `default: true`, naming that file: a second default language is
- * underlined in the editor, and no longer only reported in the console.
- * Each project takes `main` (the commands a language file may translate)
- * and not `shared`, which types `t` from the default file: a language file
- * checked with the `language()` of another would be a false error.
- */
-export function languageTypedFolders(files, defaults = []) {
-    return namedFiles(files).map(({ file, locale }) => {
-        const others = defaults.filter(one => one !== file).sort();
-        const refusal = others.length === 0
-            ? ''
-            : ` & {
-    /** ${others.join(' and ')} already ${others.length === 1 ? 'says' : 'say'} \`default: true\`: only one file of src/messages/ is the default language. Remove it there to make this one the default. */
-    default?: false;
-  }`;
-        return {
-            id: `messages.${locale}`,
-            folder: file,
-            includes: ['main'],
-            declarations: `import type { LanguageConfig, LanguageFile, MessageTexts } from '#chapterjs';
-
-/**
- * Declares one language of the bot: the one this file is named after.
- * Every handler then receives \`t\`, which gives a text in the language of
- * who will read the message, with its \`{placeholders}\` filled in.
- */
-export declare function language<const T extends MessageTexts>(
-  config: LanguageConfig<T>${refusal}
-): LanguageFile<T>;
-`,
-        };
-    });
-}
-/**
- * The augmentation that offers the commands of the project in the
- * `commands` of a language file: the path of each command file, `true`
- * when the language files describe it and `false` when the file has its
- * own `description`, so that the editor only offers the first ones. The
- * path comes from the file name; whether it is described comes from
- * running the file (`dev` and `build` know it, `sync` does not). The
- * command files themselves are never referred to: their `t` is typed from
- * the languages, which would be a circle. Nothing when the project has no
- * command.
- */
-export function commandsDeclarations(commands) {
-    const entries = commands
-        .map(({ file, described }) => {
-        const inside = file.slice('src/commands/'.length);
-        const path = logicalPath(inside).replace(/\.[^./]+$/, '');
-        return `    ${JSON.stringify(path)}: ${!described};`;
-    })
-        .sort();
-    if (entries.length === 0)
-        return '';
-    // A module (`export {}`), so that this augments 'chapterjs' instead of
-    // declaring it anew.
-    return `export {};
-
-declare module 'chapterjs' {
-  /** The commands of src/commands/, by the path of their file: true when the language files describe it, false when the file has its own description. */
-  export interface ProjectCommands {
-${entries.join('\n')}
-  }
-}
-`;
-}