chapterjs 0.1.4 → 0.2.1

package/dist/cli/build.js

@@ -13,9 +13,9 @@ import { mkdir, readdir, readFile, rm, stat, writeFile, } from 'node:fs/promises
 import { join, relative, sep } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { enableProjectLoader } from '../loader/hot.js';
-import { listFolder } from '../loader/loader.js';
+import { listSources } from '../loader/loader.js';
 import { sourcesJoinVoice } from '../voice/usage.js';
-import { CONVENTIONS, createProject, hasSources, writeTypes, } from './project.js';
+import { createProject, hasSources, writeTypes } from './project.js';
 /** Where the build of a project is, from its folder. */
 export const buildDir = (cwd) => join(cwd, '.chapterjs', 'build');
 /** The file the whole bot is compiled into, in the build. */
@@ -108,10 +108,9 @@ export async function build(options) {
     const sources = createProject({ cwd, version: options.version, log });
     const failures = await sources.load();
     // 2. Types: what the editor underlines, for the whole project. Written
-    // once the files ran, so a language file only offers the commands they
-    // do not describe; written even when a file failed, so the editor
-    // follows.
-    await writeTypes(cwd, sources.commands, sources.messages, sources.languageDefaults);
+    // once the files ran, so a language only offers the commands they do
+    // not describe; written even when a file failed, so the editor follows.
+    await writeTypes(cwd, sources.typesInfo());
     if (failures.length > 0) {
         for (const failure of failures)
             sources.report(failure);
@@ -128,10 +127,10 @@ export async function build(options) {
     else {
         log.success('Types checked');
     }
-    // 3. The whole bot in one file: every file of the conventional folders,
-    // with what it imports from the project. Packages stay where they are
-    // installed: the bot and the framework must share the same ones.
-    const found = (await Promise.all(CONVENTIONS.map(convention => listFolder(cwd, convention)))).flat();
+    // 3. The whole bot in one file: every file of src/, with what it
+    // imports. Packages stay where they are installed: the bot and the
+    // framework must share the same ones.
+    const found = await listSources(cwd);
     const entry = [
         ...found.map(({ path }, index) => `import * as m${index} from ${JSON.stringify(path)};`),
         `export const files = [${found

package/dist/cli/dev.js

@@ -9,6 +9,7 @@ import { GetGlobalApplicationCommands } from '../discord/endpoints.js';
 import { EVENTS } from '../events/registry.js';
 import { limitsFor } from '../events/router.js';
 import { enableProjectLoader, nextGeneration } from '../loader/hot.js';
+import { siteName } from '../loader/loader.js';
 import { messageOf } from '../loader/locate.js';
 import { watchPublic } from '../assets/public.js';
 import { snapshotFolder, watchFolder } from '../loader/watch.js';
@@ -16,6 +17,7 @@ import { RestClient } from '../rest/rest.js';
 import { readDevEnv } from './env.js';
 import { describeIntents, ensureInDevGuild, ensurePrivilegedIntents, fetchApplication, } from './preflight.js';
 import { createProject, explain, hasSources, writeTypes } from './project.js';
+import { checkForUpdate, describeUpdate } from './update-check.js';
 /** Runs until stopped. Resolves with the exit code of the process. */
 export async function dev(options) {
     const { cwd, log, signal } = options;
@@ -30,6 +32,13 @@ export async function dev(options) {
     const src = join(cwd, 'src');
     if (!(await hasSources(cwd, log)))
         return 1;
+    // Asked now, said once the bot is online: the registry answers while the
+    // files load and Discord is checked, so nobody waits for it.
+    const update = checkForUpdate({
+        cwd,
+        version: options.version,
+        env: options.env,
+    });
     // 2. The files of the project.
     const project = createProject({
         cwd,
@@ -45,9 +54,9 @@ export async function dev(options) {
     const loaded = snapshotFolder(src);
     for (const failure of await project.load())
         project.report(failure);
-    // Now that the command files ran, a language file only offers the ones
-    // they do not describe.
-    await writeTypes(cwd, project.commands, project.messages, project.languageDefaults);
+    // Now that the files ran, a language only offers the commands they do
+    // not describe, and `t` is typed from the default language.
+    await writeTypes(cwd, project.typesInfo());
     // 3. What Discord must agree with before connecting.
     const apiUrl = options.env.CHAPTERJS_API_URL;
     const rest = new RestClient({
@@ -67,7 +76,7 @@ export async function dev(options) {
     // The files of public/ are listed in the types: a file added or removed
     // is offered (or not) by the editor at once.
     const assets = watchPublic(cwd, () => {
-        writeTypes(cwd, project.commands, project.messages, project.languageDefaults)
+        writeTypes(cwd, project.typesInfo())
             .then(written => {
             if (written > 0)
                 log.reload('public/ changed: types updated');
@@ -159,24 +168,28 @@ export async function dev(options) {
                 noted.add(file);
                 log.info(`${file} ${what} only works in private messages, and chapterjs dev only runs your bot in ${guild.name}. Try it with chapterjs start.`);
             };
-            for (const { file, command } of privateOnly([
-                ...project.commands.values(),
-            ])) {
-                note(file, commandName(command.path));
+            for (const entry of privateOnly([...project.commands.values()])) {
+                note(siteName(entry), commandName(entry.command.path));
             }
-            for (const { file, event } of project.events.values()) {
+            for (const entry of project.events.values()) {
+                const { event } = entry;
                 if (EVENTS[event.name].options &&
                     event.options.where === 'dm') {
-                    note(file, `this ${event.name} file`);
+                    note(siteName(entry), `this ${event.name} event`);
                 }
             }
-            for (const { file, component } of project.components.values()) {
+            for (const entry of project.components.values()) {
+                const { component } = entry;
                 if (component.kind !== 'embed' && component.where === 'dm') {
-                    note(file, `the ${component.kind} ${component.path}`);
+                    note(siteName(entry), `the ${component.kind} ${component.name}`);
                 }
             }
         };
         notePrivateOnly();
+        update.then(found => {
+            if (found && !signal.aborted)
+                log.info(describeUpdate(found));
+        });
         // 4. Every save reloads the project. Watching starts right away; the
         // first thing done is to tell Discord the commands.
         let reloading = syncCommands().then(updated => {
@@ -197,10 +210,10 @@ export async function dev(options) {
                     if (project.applyPresence(bot))
                         log.reload('Presence updated');
                 }
-                // A language that appeared or went: `t` is typed from the
-                // folder. A command described in its file, or no longer: the
-                // language files offer it, or not.
-                if ((await writeTypes(cwd, project.commands, project.messages, project.languageDefaults)) > 0)
+                // A language that appeared or went: `t` is typed from it. A
+                // command described in its file, or no longer: the languages
+                // offer it, or not.
+                if ((await writeTypes(cwd, project.typesInfo())) > 0)
                     log.reload('Types updated');
                 const intents = project.intents(false);
                 if ((intents & ~connectedIntents) !== 0 && bot) {

package/dist/cli/project.d.ts

@@ -1,12 +1,14 @@
 import { type CommandEntry } from '../commands/tree.js';
 import { type ComponentEntry } from '../components/router.js';
-import { type LoadedPresence } from '../presence/convention.js';
+import { type LoadedPresence } from '../presence/declaration.js';
+import { type DeclaredCommand, type DeclaredLanguage } from '../messages/declaration.js';
 import { type LoadedMessages } from '../messages/translate.js';
+import type { Locale } from '../discord/types/common.js';
 import { type TaskEntry } from '../tasks/scheduler.js';
 import { type Bot, type BotOptions } from '../core/bot.js';
 import { type GatewayIntentName } from '../discord/intents.js';
 import { type LoadedEvent } from '../events/router.js';
-import { type BuiltFile, type FailedFile } from '../loader/loader.js';
+import { type BuiltFile, type Declaration, type FailedFile } from '../loader/loader.js';
 import type { Log } from './log.js';
 export interface ProjectOptions {
     /** The folder of the project. */
@@ -27,20 +29,32 @@ export interface ProjectOptions {
     /** Only tests change this. */
     deferAfter?: number;
 }
+/** What the types of a project are written from, once its files ran. */
+export interface TypesInfo {
+    /** Every language declared, with where. */
+    languages: readonly DeclaredLanguage[];
+    /** The language `t` is typed from, when known. */
+    defaultLocale?: Locale;
+    /** The languages that say `default: true`, as they are now. */
+    languageDefaults: readonly Locale[];
+    /** Every command, and whether its file describes it. */
+    commands: readonly DeclaredCommand[];
+}
 /**
- * Writes the types of a project (`.chapterjs/`): one project per typed
- * folder (every event, every language file), and what every file gets,
- * like the files of `public/`. With the commands and the languages as
- * they loaded, a language file only offers the ones without `description`
- * in their file, `t` is typed from the default language and `default:
- * true` is refused in every file when another one says it (`defaults`,
- * the files that do); without them (`sync`, which runs nothing),
- * every command is offered and the first language file types `t`.
+ * Writes the types of a project (`.chapterjs/`): what the project adds to
+ * 'chapterjs', like the files of `public/`, its languages and its
+ * commands. With the project as it loaded (`info`), a language only
+ * offers the commands without `description`, `t` is typed from the
+ * default language and `default: true` is refused in every language that
+ * says it when another one does; without it (`sync`, which runs nothing),
+ * the commands and the languages are found by reading the files, every
+ * command is offered, and the first language or the one that says
+ * `default: true` types `t`.
  * @returns how many files were written
  */
-export declare function writeTypes(cwd: string, commands?: ReadonlyMap<string, CommandEntry>, messages?: LoadedMessages | null, defaults?: readonly string[]): Promise<number>;
-/** The conventional folders of a project: one per feature. */
-export declare const CONVENTIONS: readonly [import("../loader/loader.js").Convention<import("../events/convention.js").EventHandler<keyof import("../events/registry.js").EventContexts>>, import("../loader/loader.js").Convention<import("../commands/convention.js").LoadedCommand>, import("../loader/loader.js").Convention<import("../components/convention.js").LoadedComponent>, import("../loader/loader.js").Convention<import("../tasks/convention.js").LoadedTask>, import("../loader/loader.js").Convention<LoadedPresence>, import("../loader/loader.js").Convention<import("../messages/convention.js").LoadedLanguage>];
+export declare function writeTypes(cwd: string, info?: TypesInfo): Promise<number>;
+/** The kinds of declarations a project is made of: one per feature. */
+export declare const DECLARATIONS: readonly Declaration<unknown>[];
 /** What a bot of the project is connected with. */
 export interface ConnectOptions {
     token: string;
@@ -60,27 +74,26 @@ export interface ConnectOptions {
 }
 /** The files of a project, and what runs them. */
 export interface Project {
-    /** The last version of each file that loaded: what the bot runs. */
+    /**
+     * The last version of each declaration that loaded, by the file and the
+     * export it comes from (`src/ping.ts#default`): what the bot runs.
+     */
     readonly events: ReadonlyMap<string, LoadedEvent>;
     readonly commands: ReadonlyMap<string, CommandEntry>;
     readonly components: ReadonlyMap<string, ComponentEntry>;
     readonly tasks: ReadonlyMap<string, TaskEntry>;
-    /** What `src/presence.ts` declares, or `null` without that file. */
+    /** The presence declared, or `null` without one. */
     readonly presence: LoadedPresence | null;
-    /** The languages of `src/messages/`, assembled, or `null` without any. */
+    /** The languages of the project, assembled, or `null` without any. */
     readonly messages: LoadedMessages | null;
+    /** What the types of the project are written from, as it loaded. */
+    typesInfo(): TypesInfo;
     /**
-     * The language files that say `default: true`, as they are now: a file
-     * left out because a second one says it is counted, so that both are
-     * underlined in the editor.
-     */
-    readonly languageDefaults: readonly string[];
-    /**
-     * Loads every file (again). A file that fails is returned; it keeps its
-     * last working version when it had one.
+     * Loads every file (again). A declaration that fails is returned; it
+     * keeps its last working version when it had one.
      */
     load(): Promise<FailedFile[]>;
-    /** Shows a failure with its file and line. */
+    /** Shows a failure with its file (and export) and line. */
     report(failure: FailedFile): void;
     /** "2 commands, 3 events, 4 components, a presence loaded". */
     summary(): string;