Add tsup for ESM support

Add tsup

Author: notunderctrl

.github/workflows/publish.yaml

@@ -1,26 +1,26 @@
-name: 'publish'
+name: Publish to NPM
 
 on:
-    push:
-        branches: [master]
+    release:
+        types: [created]
 
 jobs:
     release:
-        name: 🚀 publish
+        name: 🚀 Publish
         runs-on: ubuntu-latest
         steps:
-            - name: 📚 checkout
+            - name: 📚 Checkout
               uses: actions/checkout@v3
             - name: 🟢 node
               uses: actions/setup-node@v2
               with:
                   node-version: 16
                   registry-url: https://registry.npmjs.org
-            - name: 🍳 prepare
+            - name: 🍳 Prepare
               run: |
                   npm install
                   npm run build
-            - name: 🚚 publish
+            - name: 🚚 Publish
               run: npm publish
               env:
                   NODE_AUTH_TOKEN: ${{secrets.NPM_AUTH_TOKEN}}

.npmignore

@@ -1,4 +1,11 @@
 /node_modules
 /src
+/.github
+/.vscode
+/.git
+
 .DS_Store
-.vscode
+yarn.lock
+tsconfig.json
+.prettierrc.json
+tsup.config.ts

.prettierrc.json

@@ -0,0 +1,4 @@
+{
+    "printWidth": 120,
+    "tabWidth": 4
+}

package.json

@@ -1,14 +1,24 @@
 {
     "name": "commandkit",
     "version": "0.0.9",
-    "main": "dist/index.js",
     "license": "MIT",
+    "main": "./dist/index.js",
+    "module": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "require": "./dist/index.js",
+            "import": "./dist/index.mjs",
+            "types": "./dist/index.d.ts"
+        }
+    },
     "scripts": {
-        "build": "tsc"
+        "lint": "tsc",
+        "build": "yarn lint && tsup"
     },
     "repository": {
         "type": "git",
-        "url": "https://github.com/notunderctrl/commandkit"
+        "url": "https://github.com/underctrl-io/commandkit"
     },
     "homepage": "https://commandkit.underctrl.io",
     "keywords": [
@@ -17,8 +27,15 @@
         "event handler",
         "command validations"
     ],
+    "dependencies": {
+        "colors": "^1.4.0"
+    },
     "devDependencies": {
         "discord.js": "^14.12.1",
+        "tsup": "^7.2.0",
         "typescript": "^5.1.6"
+    },
+    "peerDependencies": {
+        "discord.js": "^14"
     }
 }

src/CommandKit.ts

@@ -1,64 +1,71 @@
-import { CommandHandler, EventHandler, ValidationHandler } from './handlers';
-import { CommandKitData, CommandKitOptions } from '../typings';
+import { CommandHandler, EventHandler, ValidationHandler } from "./handlers";
+import { CommandKitData, CommandKitOptions } from "./typings";
+import "colors";
 
 export class CommandKit {
-    private _data: CommandKitData;
+    #data: CommandKitData;
 
     constructor({ ...options }: CommandKitOptions) {
         if (!options.client) {
-            throw new Error('"client" is required when instantiating CommandKit.');
+            throw new Error('"client" is required when instantiating CommandKit.'.red);
         }
 
         if (options.validationsPath && !options.commandsPath) {
-            throw new Error('"commandsPath" is required when "validationsPath" is set.');
+            throw new Error('"commandsPath" is required when "validationsPath" is set.'.red);
         }
 
-        this._data = {
+        this.#data = {
             ...options,
             commands: [],
         };
 
-        this._init();
+        this.#init();
     }
 
-    private _init() {
+    async #init() {
         // Event handler
-        if (this._data.eventsPath) {
-            new EventHandler({
-                client: this._data.client,
-                eventsPath: this._data.eventsPath,
+        if (this.#data.eventsPath) {
+            const eventHandler = new EventHandler({
+                client: this.#data.client,
+                eventsPath: this.#data.eventsPath,
             });
+
+            await eventHandler.init();
         }
 
         // Validation handler
         let validationFunctions: Function[] = [];
 
-        if (this._data.validationsPath) {
+        if (this.#data.validationsPath) {
             const validationHandler = new ValidationHandler({
-                validationsPath: this._data.validationsPath,
+                validationsPath: this.#data.validationsPath,
             });
 
-            validationHandler.getValidations().forEach((v) => validationFunctions.push(v));
+            await validationHandler.init();
+
+            validationHandler.validations.forEach((v) => validationFunctions.push(v));
         }
 
         // Command handler
-        if (this._data.commandsPath) {
+        if (this.#data.commandsPath) {
             const commandHandler = new CommandHandler({
-                client: this._data.client,
-                commandsPath: this._data.commandsPath,
-                devGuildIds: this._data.devGuildIds || [],
-                devUserIds: this._data.devUserIds || [],
-                devRoleIds: this._data.devRoleIds || [],
+                client: this.#data.client,
+                commandsPath: this.#data.commandsPath,
+                devGuildIds: this.#data.devGuildIds || [],
+                devUserIds: this.#data.devUserIds || [],
+                devRoleIds: this.#data.devRoleIds || [],
                 customValidations: validationFunctions,
-                skipBuiltInValidations: this._data.skipBuiltInValidations || false,
+                skipBuiltInValidations: this.#data.skipBuiltInValidations || false,
             });
 
-            this._data.commands = commandHandler.getCommands();
+            await commandHandler.init();
+
+            this.#data.commands = commandHandler.commands;
         }
     }
 
     get commands() {
-        return this._data.commands.map((cmd) => {
+        return this.#data.commands.map((cmd) => {
             const { run, ...command } = cmd;
             return command;
         });

src/handlers/command-handler/CommandHandler.ts

@@ -1,9 +1,9 @@
-import { BuiltInValidation, CommandHandlerData, CommandHandlerOptions } from './typings';
-import { ContextCommandObject, SlashCommandObject } from '../../../typings';
-import { getFilePaths } from '../../utils/get-paths';
-import registerCommands from './functions/registerCommands';
-import handleCommands from './functions/handleCommands';
-import path from 'path';
+import { CommandHandlerData, CommandHandlerOptions } from "./typings";
+import { getFilePaths } from "../../utils/get-paths";
+import builtInValidations from "./validations";
+import registerCommands from "./functions/registerCommands";
+import handleCommands from "./functions/handleCommands";
+import "colors";
 
 export class CommandHandler {
     _data: CommandHandlerData;
@@ -14,64 +14,55 @@ export class CommandHandler {
             builtInValidations: [],
             commands: [],
         };
-
-        this._init();
     }
 
-    _init() {
-        this._buildCommands();
-        this._buildValidations();
-        this._registerCommands();
-        this._handleCommands();
+    async init() {
+        await this.#buildCommands();
+        this.#buildValidations();
+        await this.#registerCommands();
+        this.#handleCommands();
     }
 
-    _buildCommands() {
+    async #buildCommands() {
         const commandFilePaths = getFilePaths(this._data.commandsPath, true).filter(
-            (path) => path.endsWith('.js') || path.endsWith('.ts')
+            (path) => path.endsWith(".js") || path.endsWith(".ts")
         );
 
         for (const commandFilePath of commandFilePaths) {
-            const commandObj: SlashCommandObject | ContextCommandObject = require(commandFilePath);
+            let commandObj = await import(commandFilePath);
+            const compactFilePath = commandFilePath.split(process.cwd())[1] || commandFilePath;
+
+            if (commandObj.default) commandObj = commandObj.default;
 
             if (!commandObj.data) {
-                console.log(`⏩ Ignoring: Command ${commandFilePath} does not export "data".`);
+                console.log(`⏩ Ignoring: Command ${compactFilePath} does not export "data".`.yellow);
                 continue;
             }
 
             if (!commandObj.run) {
-                console.log(`⏩ Ignoring: Command ${commandFilePath} does not export "run".`);
+                console.log(`⏩ Ignoring: Command ${compactFilePath} does not export "run".`.yellow);
                 continue;
             }
 
             this._data.commands.push(commandObj);
         }
     }
 
-    _buildValidations() {
-        const validationFilePaths = getFilePaths(path.join(__dirname, 'validations'), true).filter(
-            (path) => path.endsWith('.js')
-        );
-
-        for (const validationFilePath of validationFilePaths) {
-            const validationFunction: Function = require(validationFilePath);
-
-            if (typeof validationFunction !== 'function') {
-                continue;
-            }
-
-            this._data.builtInValidations.push(validationFunction as BuiltInValidation);
+    #buildValidations() {
+        for (const validationFunction of builtInValidations) {
+            this._data.builtInValidations.push(validationFunction);
         }
     }
 
-    _registerCommands() {
-        registerCommands(this);
+    async #registerCommands() {
+        await registerCommands(this);
     }
 
-    _handleCommands() {
+    #handleCommands() {
         handleCommands(this);
     }
 
-    getCommands() {
+    get commands() {
         return this._data.commands;
     }
 }

src/handlers/command-handler/functions/handleCommands.ts

@@ -1,14 +1,12 @@
-import { CommandHandler } from '../CommandHandler';
+import { CommandHandler } from "../CommandHandler";
 
 export default function handleCommands(commandHandler: CommandHandler) {
     const client = commandHandler._data.client;
 
-    client.on('interactionCreate', async (interaction) => {
+    client.on("interactionCreate", async (interaction) => {
         if (!interaction.isChatInputCommand() && !interaction.isContextMenuCommand()) return;
 
-        const targetCommand = commandHandler._data.commands.find(
-            (cmd) => cmd.data.name === interaction.commandName
-        );
+        const targetCommand = commandHandler._data.commands.find((cmd) => cmd.data.name === interaction.commandName);
 
         if (!targetCommand) return;