chapterjs 0.1.4 → 0.2.0

package/dist/components/select.d.ts

@@ -82,23 +82,24 @@ export interface EntitySelectConfig<Type extends EntitySelectType, Data extends
 /** What a select file gives to `select()`: a menu of texts, or of things of the server. */
 export type SelectConfig<Options extends SelectOptions = SelectOptions, Type extends EntitySelectType = EntitySelectType, Data extends DataShape = {}, Where extends ComponentWhere = 'guild'> = StringSelectConfig<Options, Data, Where> | EntitySelectConfig<Type, Data, Where>;
 /**
- * What `select()` returns: the default export of a select file. Import it
- * where you send a message, and call it with the data it carries; a menu
- * without data is used as is, or called with what to show.
+ * What `select()` returns: a declaration the framework finds in the exports
+ * of a file. Import it where you send a message, and call it with the data
+ * it carries; a menu without data is used as is, or called with what to
+ * show.
  */
-export type SelectFile<Data extends DataShape = {}> = {
+export type SelectDeclaration<Data extends DataShape = {}> = {
     /** What the file gave to `select()`, not checked yet. */
     readonly config: unknown;
 } & ({} extends Data ? ((options?: SelectInstanceOptions) => SelectComponent) & SelectComponent : {} extends DataInputOf<Data> ? ((data?: DataInputOf<Data>, options?: SelectInstanceOptions) => SelectComponent) & SelectComponent : (data: DataInputOf<Data>, options?: SelectInstanceOptions) => SelectComponent);
 /**
- * Declares a select menu. Export the result as the default export of a
- * file of `src/components/selects/`: the path of the file is what tells
- * the menu apart, so you never write an id.
+ * Declares a select menu. Export the result from any file of `src/`: the
+ * name of the export is what tells the menu apart, so you never write an
+ * id.
  *
  * ```ts
  * import { select } from 'chapterjs';
  *
- * export default select({
+ * export const color = select({
  *   placeholder: 'Pick a color',
  *   options: { Red: 'red', Blue: 'blue' },
  *   async run({ interaction, value }) {
@@ -107,12 +108,13 @@ export type SelectFile<Data extends DataShape = {}> = {
  * });
  * ```
  */
-export declare function select<const Options extends SelectOptions, const Data extends DataShape = {}, const Where extends ComponentWhere = 'guild'>(config: StringSelectConfig<Options, Data, Where>): SelectFile<Data>;
-export declare function select<const Type extends EntitySelectType, const Data extends DataShape = {}, const Where extends ComponentWhere = 'guild'>(config: EntitySelectConfig<Type, Data, Where>): SelectFile<Data>;
-/** A select file, checked. */
+export declare function select<const Options extends SelectOptions, const Data extends DataShape = {}, const Where extends ComponentWhere = 'guild'>(config: StringSelectConfig<Options, Data, Where>): SelectDeclaration<Data>;
+export declare function select<const Type extends EntitySelectType, const Data extends DataShape = {}, const Where extends ComponentWhere = 'guild'>(config: EntitySelectConfig<Type, Data, Where>): SelectDeclaration<Data>;
+/** A select menu, checked. */
 export interface LoadedSelect {
     readonly kind: 'select';
-    readonly path: string;
+    /** The name of the export that declares it: its id for Discord. */
+    readonly name: string;
     readonly type: SelectType;
     /** The options of a menu of texts, their texts maybe computed when sent. */
     readonly options: readonly LoadedOption[];

package/dist/components/select.js

@@ -7,7 +7,7 @@ import { ChannelType } from '../discord/types/channel.js';
 import { ComponentType, } from '../discord/types/component.js';
 import { isDynamic, resolveText, } from './component.js';
 import { checkData, encodeCustomId, } from './custom-id.js';
-import { createFile } from './file.js';
+import { createComponent } from './declared.js';
 import { hasDynamicOption, resolveOptions, } from './options.js';
 export const SELECT_TYPES = {
     string: ComponentType.StringSelect,
@@ -17,7 +17,7 @@ export const SELECT_TYPES = {
     channel: ComponentType.ChannelSelect,
 };
 export function select(config) {
-    return createFile('select', config, {
+    return createComponent('select', config, {
         asPiece: true,
         pieceKind: 'select',
     });
@@ -122,7 +122,7 @@ function readInstanceOptions(loaded, name, given) {
 /** The menu as Discord takes it, for the data and the options given. */
 export function renderSelect(loaded, args) {
     const hasData = Object.keys(loaded.data).length > 0;
-    const name = loaded.path.split('/').pop();
+    const { name } = loaded;
     if (args.length > (hasData ? 2 : 1)) {
         fail(`${name} takes ${hasData ? 'its data, then options' : 'options'} at most.`);
     }
@@ -133,7 +133,7 @@ export function renderSelect(loaded, args) {
     const make = (context) => {
         const placeholder = resolveText(`The placeholder of ${name}`, merged.placeholder, context, { max: Limits.SelectPlaceholder });
         const base = {
-            custom_id: encodeCustomId(loaded.path, loaded.data, values),
+            custom_id: encodeCustomId(loaded.name, loaded.data, values),
             ...(placeholder !== undefined ? { placeholder } : {}),
             ...(loaded.min !== 1 ? { min_values: loaded.min } : {}),
             ...(loaded.max !== 1 ? { max_values: loaded.max } : {}),

package/dist/events/declaration.d.ts

@@ -0,0 +1,16 @@
+import type { Declaration } from '../loader/loader.js';
+import { type EventContexts, type EventName } from './registry.js';
+/** One reaction to an event, as a file declares it. */
+export interface EventHandler<Name extends EventName = EventName> {
+    /** The event. */
+    readonly name: Name;
+    readonly handler: (context: EventContexts[Name]) => unknown;
+    /** The options the file gave to `event()`, checked. */
+    readonly options: Readonly<Record<string, unknown>>;
+}
+/**
+ * An event, declared anywhere in `src/` with `event()`: its `name` is the
+ * event, the rest its options and what to do. A file may declare several,
+ * of the same event or not.
+ */
+export declare const eventDeclaration: Declaration<EventHandler>;

package/dist/events/declaration.js

@@ -0,0 +1,80 @@
+// What a file declares with `event()`, checked when it loads: the event
+// exists, the options are the ones of that event, `run` is a function. A
+// mistake is explained before the bot even connects.
+import { isEventDeclaration } from './event.js';
+import { EVENT_NAMES, EVENTS, isEventName, } from './registry.js';
+const fail = message => {
+    throw new TypeError(message);
+};
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** Checks the options written next to `name` against what the event accepts. */
+function readOptions(name, options) {
+    const allowed = EVENTS[name].options ?? {};
+    const names = Object.keys(allowed);
+    const list = names.length === 0
+        ? `${name} has no options: an event has a name, a run function, and nothing else.`
+        : `Options of ${name} are: ${names.join(', ')}.`;
+    for (const [key, value] of Object.entries(options)) {
+        if (!Object.hasOwn(allowed, key)) {
+            fail(`"${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') {
+                fail(`The option ${key} of ${name} is true or false, got ${got}.`);
+            }
+        }
+        else if (!kind.includes(value)) {
+            fail(`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}"?` : '';
+}
+const EXAMPLE = `event({ name: 'messageCreate', run({ message }) { ... } })`;
+/**
+ * An event, declared anywhere in `src/` with `event()`: its `name` is the
+ * event, the rest its options and what to do. A file may declare several,
+ * of the same event or not.
+ */
+export const eventDeclaration = {
+    one: 'event',
+    many: 'events',
+    is: isEventDeclaration,
+    list: true,
+    read(value) {
+        const { config } = value;
+        if (!isRecord(config)) {
+            return fail(`event() needs an object: ${EXAMPLE}`);
+        }
+        const { name, run, ...options } = config;
+        if (name === undefined) {
+            fail(`This event has no "name": the event to react to, like ${EXAMPLE}. Events are: ${EVENT_NAMES.join(', ')}.`);
+        }
+        if (!isEventName(name)) {
+            fail(`${JSON.stringify(name) ?? typeof name} is not an event.${typeof name === 'string' ? suggest(name) : ''} Events are: ${EVENT_NAMES.join(', ')}.`);
+        }
+        if (typeof run !== 'function') {
+            fail(`This ${name} event has no "run": the function to run when it happens, like ${EXAMPLE}`);
+        }
+        return Object.freeze({
+            name,
+            handler: run,
+            options: readOptions(name, options),
+        });
+    },
+};

package/dist/events/event.d.ts

@@ -1,8 +1,45 @@
-import type { EventFile } from './registry.js';
+import type { ContextOf, EventName, OptionsOf } from './registry.js';
+/** The options written next to `name` and `run`, as written. */
+type OptionsWritten<Options> = {
+    [Key in keyof Options as Key extends 'name' | 'run' ? never : Key]: Options[Key];
+};
 /**
- * Says what to do when an event happens. Export the result as the default
- * export of a file of `src/events/<event>/`: the folder says which event.
+ * What a file gives to `event()`: the event, its options when it has
+ * some, and what to do. What `run` receives follows the options: what an
+ * option lets through is only there to handle when the option is on.
  */
-export declare function event(handler: (context: never) => unknown, options?: unknown): EventFile;
+export type EventConfig<Name extends EventName = EventName, Options extends object = {}> = {
+    /** The event to react to: `'messageCreate'`, `'memberJoin'`... */
+    name: Name;
+    /** What to do when the event happens. */
+    run: (context: ContextOf<Name, OptionsWritten<Options>>) => unknown;
+} & Partial<OptionsOf<Name>> & {
+    [Key in keyof Options]: Key extends 'name' | 'run' ? unknown : Key extends keyof OptionsOf<Name> ? Options[Key] : never;
+};
+/** What `event()` returns: a declaration the framework finds in the exports of a file. */
+export interface EventDeclaration<Name extends EventName = EventName> {
+    /** What the file gave to `event()`, not checked yet. */
+    readonly config: EventConfig<Name, never>;
+}
+/**
+ * Declares what to do when an event happens. Export the result from any
+ * file of `src/`; `name` says which event, and types what `run` receives:
+ *
+ * ```ts
+ * import { event } from 'chapterjs';
+ *
+ * export const welcome = event({
+ *   name: 'memberJoin',
+ *   async run({ member, guild }) {
+ *     await member.send(`Welcome to ${guild.name}!`);
+ *   },
+ * });
+ * ```
+ *
+ * Some events have options, written next to `name` (`bots: true`, `where:
+ * 'dm'`): what `run` receives follows them.
+ */
+export declare function event<Name extends EventName, const Options extends Partial<OptionsOf<Name>> & object = {}>(config: EventConfig<Name, Options>): EventDeclaration<Name>;
 /** Whether a value was made by `event()`. */
-export declare function isEventFile(value: unknown): value is EventFile;
+export declare function isEventDeclaration(value: unknown): value is EventDeclaration;
+export {};

package/dist/events/event.js

@@ -1,19 +1,33 @@
-// `event()`, as user files import it from 'chapterjs'. Its type here is the
-// loose one; in each event folder of a project, the generated types give it
-// the one of that event (see `types.ts`).
+// `event()`, as user files import it from 'chapterjs': what to do when
+// something happens on Discord. The `name` of the event types the rest: what
+// `run` receives, and the options the event has.
 const BRAND = Symbol.for('chapterjs.event');
 /**
- * Says what to do when an event happens. Export the result as the default
- * export of a file of `src/events/<event>/`: the folder says which event.
+ * Declares what to do when an event happens. Export the result from any
+ * file of `src/`; `name` says which event, and types what `run` receives:
+ *
+ * ```ts
+ * import { event } from 'chapterjs';
+ *
+ * export const welcome = event({
+ *   name: 'memberJoin',
+ *   async run({ member, guild }) {
+ *     await member.send(`Welcome to ${guild.name}!`);
+ *   },
+ * });
+ * ```
+ *
+ * Some events have options, written next to `name` (`bots: true`, `where:
+ * 'dm'`): what `run` receives follows them.
  */
-export function event(handler, options) {
-    if (typeof handler !== 'function') {
-        throw new TypeError('event() needs the function to run when the event happens: export default event(({ ... }) => { ... })');
-    }
-    return Object.freeze({ [BRAND]: true, handler, options });
+export function event(config) {
+    return Object.freeze({
+        [BRAND]: true,
+        config,
+    });
 }
 /** Whether a value was made by `event()`. */
-export function isEventFile(value) {
+export function isEventDeclaration(value) {
     return (typeof value === 'object' &&
         value !== null &&
         value[BRAND] === true);

package/dist/events/registry.d.ts

@@ -436,15 +436,6 @@ export interface EventContexts {
 }
 /** The name of an event: the name of a folder of `src/events/`. */
 export type EventName = keyof EventContexts;
-/**
- * What `event()` returns: the default export of an event file.
- */
-export interface EventFile {
-    /** The function to run when the event happens. */
-    readonly handler: (context: never) => unknown;
-    /** What the file passed as second argument, not checked yet. */
-    readonly options: unknown;
-}
 /**
  * Where something happens: in servers (`'guild'`), in private messages with
  * the bot (`'dm'`), or in both.
@@ -624,7 +615,7 @@ interface NarrowedContexts<Options> {
  */
 export type ContextOf<Name extends EventName, Options = object> = (Name extends keyof NarrowedContexts<Options> ? NarrowedContexts<Options>[Name] : EventContexts[Name]) & TranslationContext;
 /** The options of an event; nothing for an event without options. */
-export type OptionsOf<Name extends EventName> = Name extends keyof EventOptions ? EventOptions[Name] : Record<string, never>;
+export type OptionsOf<Name extends EventName> = Name extends keyof EventOptions ? EventOptions[Name] : {};
 /** One gateway event an event comes from. */
 interface Source<Name extends EventName, E extends GatewayDispatchEventName> {
     on: E;

package/dist/events/router.d.ts

@@ -1,11 +1,12 @@
 import { type CacheLimits } from '../cache/cache.js';
 import type { GatewayDispatchEventName, GatewayDispatchEvents } from '../discord/types/gateway-events.js';
 import type { Context } from '../structures/context.js';
-import type { EventHandler } from './convention.js';
+import type { EventHandler } from './declaration.js';
 import { type EventContexts, type EventName } from './registry.js';
-/** A handler, with the file it comes from (to report its errors). */
+/** A handler, with the file and the export it comes from (to report its errors). */
 export interface LoadedEvent {
     file: string;
+    export: string;
     event: EventHandler;
 }
 /**

package/dist/index.d.ts

@@ -1,22 +1,24 @@
 export { command } from './commands/command.js';
-export type { AutocompleteContext, ChannelOption, CommandAutocomplete, CommandConfig, CommandContext, CommandInDm, CommandInGuild, CommandInPrivate, CommandWhere, CommandFile, CommandLocales, CommandOption, CommandOptions, CommandTranslation, Cooldown, Duration, NumberOption, OptionsSoFar, OptionTranslation, OptionValuesOf, SimpleOption, StringOption, Suggestion, } from './commands/command.js';
+export type { AutocompleteContext, ChannelOption, CommandAutocomplete, CommandConfig, CommandContext, CommandInDm, CommandInGuild, CommandInPrivate, CommandWhere, CommandDeclaration, CommandLocales, CommandName, CommandOption, CommandOptions, CommandTranslation, Cooldown, Duration, NumberOption, OptionsSoFar, OptionTranslation, OptionValuesOf, SimpleOption, StringOption, Suggestion, } from './commands/command.js';
 export type { CommandInteraction, ComponentInteraction, DmCommandInteraction, GuildCommandInteraction, PrivateCommandInteraction, Interaction, InteractionReply, InteractionReplyOptions, ModalInteraction, } from './structures/interaction.js';
 export type { DynamicText, TextContext } from './components/component.js';
 export { button } from './components/button.js';
-export type { ButtonConfig, ButtonContext, ButtonFile, ButtonLook, ButtonStyleName, } from './components/button.js';
+export type { ButtonConfig, ButtonContext, ButtonDeclaration, ButtonLook, ButtonStyleName, } from './components/button.js';
 export { select } from './components/select.js';
-export type { EntitySelectConfig, EntitySelectType, SelectConfig, SelectContext, SelectFile, SelectInstanceOptions, SelectLook, SelectType, StringSelectConfig, } from './components/select.js';
+export type { EntitySelectConfig, EntitySelectType, SelectConfig, SelectContext, SelectDeclaration, SelectInstanceOptions, SelectLook, SelectType, StringSelectConfig, } from './components/select.js';
 export { modal } from './components/modal.js';
-export type { CheckboxField, CheckboxesField, EntityField, FieldValue, FieldValuesOf, FilesField, ModalConfig, ModalContext, ModalField, ModalFields, ModalFile, ModalInstanceOptions, ModalPrefill, NoteField, RadioField, SelectField, TextField, } from './components/modal.js';
+export type { CheckboxField, CheckboxesField, EntityField, FieldValue, FieldValuesOf, FilesField, ModalConfig, ModalContext, ModalField, ModalFields, ModalDeclaration, ModalInstanceOptions, ModalPrefill, NoteField, RadioField, SelectField, TextField, } from './components/modal.js';
 export { embed } from './components/embed.js';
-export type { EmbedFile } from './components/embed.js';
+export type { EmbedDeclaration } from './components/embed.js';
 export type { ComponentWhere, ComponentWho, InDm, InGuild, InPrivate, InteractiveConfig, InteractiveContext, PlaceInDm, PlaceInGuild, PlaceInPrivate, PlaceOf, } from './components/component.js';
 export type { DataField, DataInputOf, DataKind, DataShape, DataValuesOf, } from './components/custom-id.js';
 export type { OptionValue, RichOption, SelectOptions, } from './components/options.js';
 export { container, file, gallery, linkButton, premiumButton, row, section, separator, text, thumbnail, } from './components/layout.js';
 export type { ContainerOptions, LinkButtonOptions, MediaOptions, SeparatorOptions, } from './components/layout.js';
 export type { ActionRowComponent, ButtonComponent, ContainerChild, ContainerComponent, FileComponent, GalleryComponent, MessageComponent, ModalComponent, Piece, SectionComponent, SelectComponent, SeparatorComponent, TextComponent, ThumbnailComponent, } from './components/instance.js';
-export type { ContextOf, EventWhere, WhereEventOptions, EventContexts, EventFile, EventName, EventOptions, MessageEventOptions, ReactionEventOptions, } from './events/registry.js';
+export { event } from './events/event.js';
+export type { EventConfig, EventDeclaration } from './events/event.js';
+export type { ContextOf, EventWhere, WhereEventOptions, EventContexts, EventName, EventOptions, MessageEventOptions, ReactionEventOptions, } from './events/registry.js';
 export type { CategoryChannel, Channel, DMChannel, FetchMessagesOptions, ForumChannel, ForumPostOptions, ForumTag, GuildChannel, GuildChannelEditOptions, InviteCreateOptions, PermissionOverwrite, TextBasedChannel, GuildTextBasedChannel, TextChannel, ThreadChannel, ThreadCreateOptions, ThreadEditOptions, ThreadMember, VoiceChannel, } from './structures/channel.js';
 export type { GuildEmoji } from './structures/emoji.js';
 export type { AuditLog, AuditLogEntry, AutoModerationRule, Ban, ChannelCreateOptions, Guild, GuildEditOptions, RoleCreateOptions, ScheduledEvent, Sticker, VoiceState, } from './structures/guild.js';
@@ -24,11 +26,11 @@ export type { Invite } from './structures/invite.js';
 export type { BanOptions, GuildMember, MemberEditOptions, } from './structures/member.js';
 export type { Attachment, EmojiInput, DmMessage, GuildMessage, MemberMessage, Message, PrivateMessage, MessageFlagName, Reaction, ReactionEmoji, } from './structures/message.js';
 export { language } from './messages/messages.js';
-export type { CommandsTranslations, FrameworkTexts, LanguageConfig, LanguageFile, MessagesOf, MessageText, MessageTexts, PluralText, ProjectCommands, ParamsArgs, ParamsOf, Placeholders, ProjectLocale, ProjectLocales, LocaleGiven, ProjectMessages, TranslationContext, Translator, } from './messages/messages.js';
+export type { CommandsTranslations, FrameworkTexts, LanguageConfig, LanguageDeclaration, MergedMessages, MessagesOf, MessageText, MessageTexts, PluralText, ProjectCommands, ProjectLanguageDefaults, ParamsArgs, ParamsOf, Placeholders, ProjectLocale, ProjectLocales, LocaleGiven, ProjectMessages, TranslationContext, Translator, } from './messages/messages.js';
 export { presence } from './presence/presence.js';
-export type { Activity, ActivityKind, PlainActivity, PresenceConfig, PresenceFile, PresenceStatusName, StreamingActivity, } from './presence/presence.js';
+export type { Activity, ActivityKind, PlainActivity, PresenceConfig, PresenceDeclaration, PresenceStatusName, StreamingActivity, } from './presence/presence.js';
 export { task } from './tasks/task.js';
-export type { CronTaskConfig, EveryTaskConfig, TaskConfig, TaskContext, TaskFile, } from './tasks/task.js';
+export type { CronTaskConfig, EveryTaskConfig, TaskConfig, TaskContext, TaskDeclaration, } from './tasks/task.js';
 export type { AssetFile, AssetOptions } from './assets/asset.js';
 export type { AllowedMentions, Embed, FileInput, MessageEditOptions, MessageInput, MessageOptions, PollInput, } from './structures/payload.js';
 export type { Role, RoleEditOptions } from './structures/role.js';

package/dist/index.js

@@ -16,6 +16,8 @@ export { select } from './components/select.js';
 export { modal } from './components/modal.js';
 export { embed } from './components/embed.js';
 export { container, file, gallery, linkButton, premiumButton, row, section, separator, text, thumbnail, } from './components/layout.js';
+// What the functions of src/events/ receive, by event.
+export { event } from './events/event.js';
 // Tasks: what the files of src/tasks/ are written with.
 export { language } from './messages/messages.js';
 export { presence } from './presence/presence.js';

package/dist/loader/generated.d.ts

@@ -1,37 +1,10 @@
-/** A folder of user files in which 'chapterjs' has its own types. */
-export interface TypedFolder {
-    /** A unique name, used for file names: `events.memberJoin`. */
-    id: string;
-    /**
-     * The folder, from the project folder, with `/`. It may contain `**` to
-     * be found at any depth (inside `(group)` folders). It may also be one
-     * file (`src/messages/fr.ts`): a file whose 'chapterjs' is its own.
-     */
-    folder: string;
-    /**
-     * What the project of this folder includes on top of its declarations:
-     * `shared` (what every file of the project gets, the default) and/or
-     * `main` (what the files outside typed folders get). A folder whose
-     * files `shared` refers to (a language file, which types `t` for every
-     * other file) takes `main` alone: through `shared`, the other files of
-     * its family would be checked with its declarations.
-     */
-    includes?: readonly ('shared' | 'main')[];
-    /**
-     * The declarations 'chapterjs' has in this folder, on top of what the
-     * package exports. Written like a `.d.ts` that imports the package from
-     * `'#chapterjs'`.
-     */
-    declarations: string;
-}
 /**
  * Writes the `.chapterjs/` folder of a project. A file whose content did
  * not change is left alone, so editors don't reload for nothing; what an
- * older version wrote and this one does not is removed. `shared` is what
- * 'chapterjs' declares in every file of the project, whatever its folder:
- * a `declare module 'chapterjs'` augmentation, importing the package from
- * `'#chapterjs'` like the declarations of a `TypedFolder`. `main` is the
- * same for the files outside typed folders only.
+ * older version wrote and this one does not is removed. `declarations` is
+ * what 'chapterjs' has in this project on top of the package: `declare
+ * module 'chapterjs'` augmentations, importing the package from
+ * `'#chapterjs'`.
  * @returns how many files were written
  */
-export declare function writeGenerated(projectDir: string, folders: readonly TypedFolder[], shared?: string, main?: string): Promise<number>;
+export declare function writeGenerated(projectDir: string, declarations: string): Promise<number>;

package/dist/loader/generated.js

@@ -1,13 +1,11 @@
 // The `.chapterjs/` folder of a project: what the framework writes so that
-// user files are typed from where they are, with nothing to write.
-//
-// A user file imports everything from 'chapterjs'. To give that import a
-// different type in each conventional folder (`event()` in
-// `src/events/memberJoin/` knows it receives a member), each such folder is
-// its own TypeScript project, in which 'chapterjs' resolves to a generated
-// declaration file: everything the package exports, plus what is specific
-// to the folder. The tsconfig of the user project only references this
-// folder; editors and `tsc -b` find the project of each file by themselves.
+// the files of the project are typed from the project itself, with nothing
+// to write. Everything 'chapterjs' gives is typed by the package; what only
+// the project knows (the files of `public/`, its languages, its commands)
+// is written here as an augmentation of 'chapterjs', in one TypeScript
+// project that covers every file of `src/`. The tsconfig of the user
+// project only references this folder; editors and `tsc -b` find it by
+// themselves.
 import { existsSync } from 'node:fs';
 import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { dirname, join, relative, sep } from 'node:path';
@@ -25,66 +23,34 @@ function packageSpecifier(projectDir) {
     return `${path.split(sep).join('/')}/dist/index.js`;
 }
 /** Every file of `.chapterjs/`, by its path inside it. */
-function generatedFiles(projectDir, folders, shared, main) {
+function generatedFiles(projectDir, declarations) {
     const files = new Map();
     const specifier = packageSpecifier(projectDir);
-    const types = (declarations) => `${HEADER}export * from '${specifier}';\n${declarations.replaceAll("'#chapterjs'", `'${specifier}'`)}`;
     // The folder ignores itself: nothing to add to the project's .gitignore.
     files.set('.gitignore', '*\n');
-    // What every file of the project gets, whatever its folder: written as
-    // an augmentation of 'chapterjs', so it adds to the package in the main
-    // project and to the generated types in the others, without a second
-    // copy of the package for editors to offer.
-    const everywhere = shared === '' ? [] : ['../types/shared.d.ts'];
-    if (shared !== '') {
-        files.set('types/shared.d.ts', `${HEADER}${shared.replaceAll("'#chapterjs'", `'${specifier}'`)}`);
-    }
-    // What only the files outside typed folders get, and the typed folders
-    // that ask for it (`includes`): the commands a language file may
-    // translate.
-    const mainOnly = main === '' ? [] : ['../types/main.d.ts'];
-    if (main !== '') {
-        files.set('types/main.d.ts', `${HEADER}${main.replaceAll("'#chapterjs'", `'${specifier}'`)}`);
-    }
-    // Files that are in no typed folder: 'chapterjs' is the package itself.
-    files.set('projects/main.json', json({
-        extends: '../../tsconfig.json',
-        include: ['../../src', ...everywhere, ...mainOnly],
-        exclude: folders.map(({ folder }) => `../../${folder}`),
-    }));
-    for (const { id, folder, declarations, includes } of folders) {
-        const more = (includes ?? ['shared']).flatMap(what => what === 'shared' ? everywhere : mainOnly);
-        files.set(`projects/${id}.json`, json({
-            extends: '../../tsconfig.json',
-            compilerOptions: { paths: { chapterjs: [`../types/${id}.d.ts`] } },
-            // The declaration file is listed too: a folder that does not exist
-            // yet is then a valid, empty project, typed as soon as it exists.
-            include: [`../../${folder}`, `../types/${id}.d.ts`, ...more],
-        }));
-        files.set(`types/${id}.d.ts`, types(declarations));
-    }
+    // What the project adds to 'chapterjs': written as an augmentation, so
+    // the editor offers one 'chapterjs' and not a second copy of it.
+    files.set('types/project.d.ts', `${HEADER}${declarations.replaceAll("'#chapterjs'", `'${specifier}'`)}`);
     files.set('tsconfig.json', json({
-        files: [],
-        references: [
-            { path: './projects/main.json' },
-            ...folders.map(({ id }) => ({ path: `./projects/${id}.json` })),
-        ],
+        extends: '../tsconfig.json',
+        // The declaration file is listed too: a project without a src folder
+        // yet is then a valid, empty project.
+        include: ['../src', './types/project.d.ts'],
     }));
     return files;
 }
 /**
  * Writes the `.chapterjs/` folder of a project. A file whose content did
  * not change is left alone, so editors don't reload for nothing; what an
- * older version wrote and this one does not is removed. `shared` is what
- * 'chapterjs' declares in every file of the project, whatever its folder:
- * a `declare module 'chapterjs'` augmentation, importing the package from
- * `'#chapterjs'` like the declarations of a `TypedFolder`. `main` is the
- * same for the files outside typed folders only.
+ * older version wrote and this one does not is removed. `declarations` is
+ * what 'chapterjs' has in this project on top of the package: `declare
+ * module 'chapterjs'` augmentations, importing the package from
+ * `'#chapterjs'`.
  * @returns how many files were written
  */
-export async function writeGenerated(projectDir, folders, shared = '', main = '') {
+export async function writeGenerated(projectDir, declarations) {
     const root = join(projectDir, '.chapterjs');
-    const files = generatedFiles(projectDir, folders, shared, main);
+    const files = generatedFiles(projectDir, declarations);
     const existing = await readdir(root, {
         recursive: true,
         withFileTypes: true,