create-chapter 0.1.4 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-chapter",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/templates/default/src/(moderation)/ban.ts

@@ -0,0 +1,49 @@
+import { button, command } from 'chapterjs';
+import { canPunish } from './checks';
+
+// A folder is only a folder: `(moderation)` groups what moderation needs,
+// and the framework reads what these files export, wherever they are.
+// /ban asks for a confirmation, then bans. The command and its button live
+// in the same file: the button is named by its export (`confirmBan`), and
+// `who: 'author'` keeps it for the person who used the command.
+export default command({
+  name: 'ban',
+  permissions: ['BanMembers'],
+  ephemeral: true,
+  options: {
+    target: { type: 'user', required: true },
+    reason: { type: 'string' },
+    days: { type: 'integer', min: 0, max: 7 },
+  },
+  async run({ interaction, options, member, guild, t }) {
+    const target = guild.members.get(options.target.id);
+    if (target && !canPunish(member, target)) {
+      await interaction.reply(t('cannotPunish', { user: target.displayName }));
+      return;
+    }
+    await interaction.reply({
+      content: t('ban.confirm', { user: options.target.username }),
+      components: [
+        confirmBan({
+          userId: options.target.id,
+          days: options.days ?? 0,
+          reason: options.reason ?? '',
+        }),
+      ],
+    });
+  },
+});
+
+export const confirmBan = button({
+  label: ({ t }) => t('ban.yes'),
+  style: 'danger',
+  who: 'author',
+  data: { userId: 'string', days: 'number', reason: 'string' },
+  async run({ interaction, data, guild, user, t }) {
+    await guild.ban(data.userId, {
+      reason: data.reason || t('ban.defaultReason', { by: user.username }),
+      deleteMessageSeconds: data.days * 86_400,
+    });
+    await interaction.update({ content: t('ban.done'), components: [] });
+  },
+});

package/templates/default/src/(moderation)/checks.ts

@@ -0,0 +1,19 @@
+import type { GuildMember } from 'chapterjs';
+
+// Shared code: this file declares nothing, the commands import it. Nothing
+// survives a restart: a real bot keeps its warnings in a database.
+export function canPunish(by: GuildMember, target: GuildMember): boolean {
+  return by.highestRole.position > target.highestRole.position;
+}
+
+const warnings = new Map<string, number>();
+
+export function addWarning(userId: string): number {
+  const count = (warnings.get(userId) ?? 0) + 1;
+  warnings.set(userId, count);
+  return count;
+}
+
+export function warningsOf(userId: string): number {
+  return warnings.get(userId) ?? 0;
+}

package/templates/default/src/(moderation)/kick.ts

@@ -0,0 +1,27 @@
+import { command } from 'chapterjs';
+
+// /kick: the texts come from the language files, like every command here.
+import { canPunish } from './checks';
+
+export default command({
+  name: 'kick',
+  permissions: ['KickMembers'],
+  ephemeral: true,
+  options: {
+    target: { type: 'user', required: true },
+    reason: { type: 'string' },
+  },
+  async run({ interaction, options, member, guild, t }) {
+    const target = guild.members.get(options.target.id);
+    if (!target) {
+      await interaction.reply(t('notHere', { user: options.target.username }));
+      return;
+    }
+    if (!canPunish(member, target)) {
+      await interaction.reply(t('cannotPunish', { user: target.displayName }));
+      return;
+    }
+    await target.kick(options.reason);
+    await interaction.reply(t('kick.done', { user: target.displayName }));
+  },
+});

package/templates/default/src/(moderation)/messages.ts

@@ -0,0 +1,81 @@
+import { language } from 'chapterjs';
+
+// A language may be declared in several places: these texts are added to the
+// en-US and fr of src/messages/, next to the commands that use them. What
+// says `default: true` there decides for the whole language.
+export const en = language({
+  locale: 'en-US',
+  texts: {
+    cannotPunish: 'You can not act on {user}: their role is above yours.',
+    notHere: '{user} is not in this server.',
+    'ban.confirm': 'Ban {user}?',
+    'ban.yes': 'Ban',
+    'ban.defaultReason': 'Banned by {by}',
+    'ban.done': 'Banned.',
+    'kick.done': '{user} was kicked.',
+    'warn.added': '{user} now has {count} warning(s).',
+    // A plural: one form per quantity, picked by `count`.
+    'warn.count': {
+      one: '{user} has {count} warning.',
+      other: '{user} has {count} warnings.',
+    },
+  },
+  // What Discord shows of these commands: their descriptions live here too.
+  commands: {
+    ban: {
+      description: 'Bans a member, after a confirmation',
+      options: {
+        target: { description: 'Who to ban' },
+        reason: { description: 'Why' },
+        days: { description: 'Days of messages to delete' },
+      },
+    },
+    kick: {
+      description: 'Kicks a member',
+      options: {
+        target: { description: 'Who to kick' },
+        reason: { description: 'Why' },
+      },
+    },
+    'warn add': {
+      description: 'Warns a member',
+      options: {
+        target: { description: 'Who to warn' },
+        reason: { description: 'Why' },
+      },
+    },
+    'warn list': {
+      description: 'Counts the warnings of a member',
+      options: { target: { description: 'Whose warnings' } },
+    },
+  },
+});
+
+export const fr = language({
+  locale: 'fr',
+  texts: {
+    cannotPunish:
+      'Vous ne pouvez pas agir sur {user} : son rôle est au-dessus du vôtre.',
+    notHere: '{user} n’est pas sur ce serveur.',
+    'ban.confirm': 'Bannir {user} ?',
+    'ban.yes': 'Bannir',
+    'ban.defaultReason': 'Banni par {by}',
+    'ban.done': 'Banni.',
+    'kick.done': '{user} a été expulsé.',
+    'warn.added': '{user} a maintenant {count} avertissement(s).',
+    'warn.count': {
+      one: '{user} a {count} avertissement.',
+      other: '{user} a {count} avertissements.',
+    },
+  },
+  commands: {
+    // A command can be renamed in a language too: /bannir for French users.
+    ban: {
+      name: 'bannir',
+      description: 'Bannit un membre, après confirmation',
+    },
+    kick: { name: 'expulser', description: 'Expulse un membre' },
+    'warn add': { description: 'Avertit un membre' },
+    'warn list': { description: 'Compte les avertissements d’un membre' },
+  },
+});

package/templates/default/src/(moderation)/warn.ts

@@ -0,0 +1,42 @@
+import { command, event } from 'chapterjs';
+import { addWarning, warningsOf } from './checks';
+
+// Two subcommands in one file: /warn add and /warn list. A subcommand is a
+// matter of `name`, not of folder.
+export const add = command({
+  name: 'warn add',
+  permissions: ['ModerateMembers'],
+  options: {
+    target: { type: 'user', required: true },
+    reason: { type: 'string', required: true },
+  },
+  async run({ interaction, options, t }) {
+    const count = addWarning(options.target.id);
+    await interaction.reply(
+      t('warn.added', { user: options.target.username, count })
+    );
+  },
+});
+
+export const list = command({
+  name: 'warn list',
+  permissions: ['ModerateMembers'],
+  ephemeral: true,
+  options: { target: { type: 'user', required: true } },
+  async run({ interaction, options, t }) {
+    await interaction.reply(
+      t('warn.count', {
+        user: options.target.username,
+        count: warningsOf(options.target.id),
+      })
+    );
+  },
+});
+
+// The event that goes with moderation, next to the commands it follows.
+export const logged = event({
+  name: 'banAdd',
+  run({ user, guild }) {
+    console.log(`${user.username} was banned from ${guild.name}`);
+  },
+});

package/templates/default/src/commands/hello.ts

@@ -3,6 +3,7 @@ import { asset, command } from 'chapterjs';
 // /hello joins your voice channel and plays public/hello.ogg. An Opus file
 // (.ogg, .webm) plays as it is; an .mp3 or a link needs ffmpeg installed.
 export default command({
+  name: 'hello',
   async run({ interaction, member, t }) {
     const channel = member.voiceChannel;
     if (!channel) {

package/templates/default/src/commands/ping.ts

@@ -1,14 +1,15 @@
-import { command } from 'chapterjs';
-import again from '../components/buttons/again';
+import { button, command } from 'chapterjs';
 
-// The path of the file is the name of the command: this one is /ping.
-// A file in a folder is a subcommand: src/commands/mod/ban.ts is /mod ban.
+// A command is declared with command() and exported: `name` is what people
+// type after the /. Where the file is and what it is called are up to you:
+// this one could live anywhere in src/.
 export default command({
+  name: 'ping',
   // Only the person sees the answer, so `t` speaks their language.
   ephemeral: true,
   async run({ interaction, t }) {
-    // A button of src/components/buttons/, with the data it carries, and a
-    // text of src/messages/ in the language of who will read the answer.
+    // The button below, with the data it carries, and a text of
+    // src/messages/ in the language of who will read the answer.
     await interaction.reply({
       content: t('pong'),
       components: [again({ count: 1 })],
@@ -16,10 +17,27 @@ export default command({
   },
 });
 
+// A button is declared with button() and exported: the name of the export
+// (here `again`) is what tells which one was clicked, you never write an
+// id. `data` is what the button carries from one click to the next.
+export const again = button({
+  label: 'Again',
+  data: { count: 'number' },
+  async run({ interaction, data, t }) {
+    const count = data.count + 1;
+    // Changes the message the button is on, instead of sending a new one.
+    await interaction.update({
+      content: t('again', { count }),
+      components: [again({ count })],
+    });
+  },
+});
+
 // A command can ask for options, typed for you in `run`, suggest values
 // while the person types, and make each person wait between two uses:
 //
-// export default command({
+// export const hello = command({
+//   name: 'hello',
 //   description: 'Says hello to someone',
 //   cooldown: '10s',
 //   options: {

package/templates/default/src/commands/play.ts

@@ -3,6 +3,7 @@ import { command } from 'chapterjs';
 // /play plays a song in your voice channel: a file you send with the
 // command, or a link to an audio file or a stream. play() takes both.
 export default command({
+  name: 'play',
   options: {
     file: { type: 'attachment' },
     url: { type: 'string' },

package/templates/default/src/events/ready.ts

@@ -0,0 +1,34 @@
+import { event } from 'chapterjs';
+
+// An event is declared with event() and exported: `name` is the event, and
+// it types what `run` receives. This one runs once, when your bot is
+// connected. A file may declare several events, commands or buttons.
+export default event({
+  name: 'ready',
+  run({ user, guilds }) {
+    console.log(`${user.username} is online in ${guilds.size} server(s)`);
+  },
+});
+
+// Something to do by itself, every so often or at given times, is a task:
+// the name of its export is the name of the task.
+//
+// import { task } from 'chapterjs';
+//
+// export const report = task({
+//   cron: '0 9 * * 1', // every Monday at 9:00
+//   async run({ guilds }) {
+//     console.log(`A new week in ${guilds.size} server(s)`);
+//   },
+// });
+//
+// To react to something else, declare another event. For example, one that
+// answers "Pong!" to "!ping" (reading messages needs the Message Content
+// intent: `chapterjs dev` tells you how to enable it):
+//
+// export const pong = event({
+//   name: 'messageCreate',
+//   async run({ message }) {
+//     if (message.content === '!ping') await message.reply('Pong!');
+//   },
+// });

package/templates/default/src/events/wave.ts

@@ -0,0 +1,14 @@
+import { event } from 'chapterjs';
+
+// Runs every time someone adds a reaction to a message of your server.
+// Reactions of bots, yours included, are left out: when yours waves back
+// below, this does not run again. Other events work the same way:
+// voiceJoin, pollVoteAdd, banAdd... (see the list of events in the docs).
+export default event({
+  name: 'reactionAdd',
+  async run({ emoji, channel, messageId }) {
+    if (emoji.name !== '👋') return;
+    const message = await channel.fetchMessage(messageId);
+    await message.react('👋');
+  },
+});

package/templates/default/src/messages/en-US.ts

@@ -1,9 +1,10 @@
 import { language } from 'chapterjs';
 
-// One file per language in src/messages/, named after the language. Each
+// A language is declared with language(): `locale` says which one. Each
 // function of your project receives `t`, which picks the language of who
 // will read the message: t('pong'), t('again', { count }).
 export default language({
+  locale: 'en-US',
   // The language used when the one of a person or of a server is not here.
   default: true,
   texts: {
@@ -15,6 +16,8 @@ export default language({
       'Send an audio file (.mp3, .ogg...) or a link starting with https://.',
     playing: 'Playing {song} in {channel}.',
   },
+  // What Discord shows of each command, by its name: its description, and
+  // the ones of its options. A command described here has none in its file.
   commands: {
     ping: {
       description: 'Replies with Pong!',

package/templates/default/src/messages/fr.ts

@@ -3,6 +3,7 @@ import { language } from 'chapterjs';
 // Every language has the texts of the default one, with the same
 // {placeholders}: a missing one is reported when the file loads.
 export default language({
+  locale: 'fr',
   texts: {
     pong: 'Pong! en fr',
     again: 'Pong en fr ! ×{count}',

package/templates/default/src/components/buttons/again.ts

@@ -1,19 +0,0 @@
-import { button } from 'chapterjs';
-
-// The folder is the kind of component (buttons, selects, modals, embeds)
-// and the path of the file is what tells which one was used: you never
-// write an id. `data` is what the button carries from one click to the next.
-const again = button({
-  label: 'Again',
-  data: { count: 'number' },
-  async run({ interaction, data, t }) {
-    const count = data.count + 1;
-    // Changes the message the button is on, instead of sending a new one.
-    await interaction.update({
-      content: t('again', { count }),
-      components: [again({ count })],
-    });
-  },
-});
-
-export default again;

package/templates/default/src/events/reactionAdd/wave.ts

@@ -1,11 +0,0 @@
-import { event } from 'chapterjs';
-
-// Runs every time someone adds a reaction to a message of your server.
-// Reactions of bots, yours included, are left out: when yours waves back
-// below, this file does not run again. Other folders work the same way:
-// voiceJoin, pollVoteAdd, banAdd... (see the list of events in the docs).
-export default event(async ({ emoji, channel, messageId }) => {
-  if (emoji.name !== '👋') return;
-  const message = await channel.fetchMessage(messageId);
-  await message.react('👋');
-});

package/templates/default/src/events/ready/online.ts

@@ -1,30 +0,0 @@
-import { event } from 'chapterjs';
-
-// The folder is the event: every file of src/events/ready/ runs once, when
-// your bot is connected. The name of the file is yours to choose.
-export default event(({ user, guilds }) => {
-  console.log(`${user.username} is online in ${guilds.size} server(s)`);
-});
-
-// Something to do by itself, every so often or at given times, is a task:
-// a file of src/tasks/, like src/tasks/report.ts:
-//
-// import { task } from 'chapterjs';
-//
-// export default task({
-//   cron: '0 9 * * 1', // every Monday at 9:00
-//   async run({ guilds }) {
-//     console.log(`A new week in ${guilds.size} server(s)`);
-//   },
-// });
-//
-// To react to something else, create a folder named after the event. For
-// example src/events/messageCreate/ping.ts, which answers "Pong!" to "!ping"
-// (reading messages needs the Message Content intent: `chapterjs dev` tells
-// you how to enable it):
-//
-// import { event } from 'chapterjs';
-//
-// export default event(async ({ message }) => {
-//   if (message.content === '!ping') await message.reply('Pong!');
-// });