@grammyjs/commands 0.0.1 → 0.3.1

package/README.md

@@ -1,178 +1,68 @@
 ## grammY Commands Plugin
 
-This plugin provides a convenient way to define and manage commands for your grammY bot. It simplifies the process of
-setting up commands with scopes and localization.
+This plugin provides a convenient way to define and manage commands for your grammY bot. It simplifies the process of setting up commands with scopes and localization.
 
 ## Installation
 
-On NPM, this plugin is available as `@grammyjs/commands`, and on Deno it's available at
-[deno.land/x/grammy_commands](https://deno.land/x/grammy_commands).
-
-You can install it for Node.js with this command:
 
 ```sh
 npm i @grammyjs/commands
 ```
 
-## Core Concepts
-
-### The `Commands` class
-
-The `Commands` class is the foundation of this plugin. It allows you to create commands by specifying their names and
-descriptions, along with additional attributes such as scopes and localization.
-
-### The `ctx.setMyCommands` method
-
-The `ctx.setMyCommands` method, provided by the plugin, offers a convenient way to dynamically set the available
-commands for the current chat. By invoking this method and passing an instance of the `Commands` class, you can override
-the default command scopes and make all commands accessible within the current chat. This feature is particularly useful
-when you need to customize the command set for specific chat contexts, ignoring the predefined scopes, which allows for
-a more tailored and context-aware usage of bot commands.
-
 ## Usage
 
-### Managing Commands For Multiple Scopes
+The main functionality of this plugin is to define your commands, localize them, and give them handlers for each [scope](https://core.telegram.org/bots/api#botcommandscope), like so:
 
-To manage commands for multiple scopes at once, create an instance of the `Commands` class, add your commands to it, and
-then call the `setFor` method of the class instance. Check out this example:
 
 ```typescript
-import { Bot } from "https://deno.land/x/grammy/mod.ts";
-import { Commands } from "https://deno.land/x/grammy_commands/mod.ts";
-
-const bot = new Bot("<your_bot_token>");
-const cmds = new Commands();
+import { Bot } from "grammy";
+import { Commands } from "@grammyjs/commands";
 
-// Define your commands...
+const bot = new Bot("<telegram token>");
 
-await cmds.setFor(bot);
-```
-
-### Managing Commands For The Current Chat
-
-To set the commands for the current chat, you can use the `ctx.setMyCommands` method of the `Context` object. For that,
-you will need to install the `CommandsFlavor` to your context, and create an instance of the `Commands` class, to which
-you add your commands to and then pass to `ctx.setMyCommands`. This will override the predefined scopes and make all
-commands available to the current chat. Here's an example:
-
-> Please note that this only works in updates which have a `chat` object. If `ctx.chat` is not defined, an error will be
-> thrown ar runtime.
-
-```typescript
-import { Bot, Context } from "https://deno.land/x/grammy/mod.ts";
-import { Commands, CommandsFlavor } from "https://deno.land/x/grammy_commands/mod.ts";
-
-type MyContext = CommandsFlavor<Context>;
-const bot = new Bot<MyContext>("<your_bot_token>");
-
-bot.on(":text", async (ctx: Context) => {
-  const cmds = new Commands();
-
-  // Define your commands...
-
-  await ctx.setMyCommands(cmds);
-});
-```
-
-### Defining Commands
-
-To define a command, use the `command` method of the `CommandsPlugin` instance. The `command` method takes two
-arguments: the command name and the command description. Here's an example:
-
-```typescript
-commands.command("help", "Sends help");
-```
+const myCommands = new Commands();
 
-### Setting handlers
+myCommands.command("start", "Initializes bot configuration")
+  .localize("pt", "start", "Inicializa as configurações do bot")
+  .addToScope({ type: "all_private_chats" }, (ctx) => ctx.reply(`Hello, ${ctx.chat.first_name}!`))
+  .addToScope({ type: "all_group_chats" }, (ctx) => ctx.reply(`Hello, members of ${ctx.chat.title}!`));
 
-The underlying class returned by the `.command()` method extends the grammY `Composer` class. That means you can use
-`.use`, `.filter`, `.branch`, `.chatType` and every other `Composer` method you already know and love. Alternatively,
-you can pass your middleware as a third parameter to the `.command()` method. You can also use the `onChatType` method
-of the `Command` class to define middleware specific to that chat type. Here are some examples:
+// Calls `setMyCommands`
+await myCommands.setCommands(bot);
 
-#### Example 1
+// Registers the command handlers
+bot.use(myCommands);
 
-```typescript
-commands.command("start", "Starts the bot", (ctx) => {
-  ctx.reply(`Hello, ${ctx.chat?.first_name ?? "there"}!`);
-});
+bot.start();
 ```
 
-#### Example 2
+It is very important that you call `bot.use` with your instance of the `Commands` class.
+Otherwise, the command handlers will not be registered, and your bot will not respond to those commands.
 
-```typescript
-commands.command("start", "Starts the bot")
-  .onChatType("private", (ctx) => ctx.reply(`Hello ${ctx.chat.first_name}!`))
-  .onChatType(["group", "supergroup", "channel"], (ctx) => ctx.reply(`Hello members of ${ctx.chat.title}!`))
-  .addToScope("default");
-```
-
-### Localization
+### Context shortcuts
 
-You can localize command names and descriptions using the `localize` method. The `localize` method takes the language
-code, the localized command name, and the localized command description. Here's an example:
+This plugin provides a shortcut for setting the commands for the current chat.
+To use it, you need to install the commands flavor and the plugin itself, like so:
 
 ```typescript
-commands.command("help", "Sends help")
-  .localize("de-DE", "hilfe", "Sendet Hilfe");
-```
+import { Bot, Context } from "grammy";
+import { Commands, CommandsFlavor, commands } from "@grammyjs/commands";
 
-### Scopes
+type BotContext = CommandsFlavor;
 
-Scopes determine the availability of each command, enabling you to control whether a command can be accessed in all
-group chats, private chats, or limited to chat administrators. Commands can be assigned to different scopes using the
-`addToScope` method. Here's an example:
+const bot = new Bot<BotContext>("<telegram_token>");
+bot.use(commands());
 
-```typescript
-commands.command("help", "Sends help")
-  .addToScope("default")
-  .addToScope("all_group_chats")
-  .addToScope("all_private_chats")
-  .addToScope("all_chat_administrators")
-  .addToScope("chat_administrators", "@grammyjs")
-  .addToScope("chat", "@SpecificUserChat");
-```
+bot.on("message", async (ctx) => {
+  const cmds = new Commands();
 
-### Setting Commands for Current Chat
+  cmds.command("start", "Initializes bot configuration")
+    .localize("pt", "start", "Inicializa as configurações do bot");
 
-To set the commands for the current chat, you can use the `setMyCommands` method of the `Context` object. This will
-override the defined scopes and make all commands available to the current chat. Here's an example:
+  await ctx.setMyCommands(cmds);
 
-```typescript
-bot.on(":text", async (ctx) => {
-  await ctx.setMyCommands(commands);
+  return ctx.reply("Commands set!");
 });
-```
-
-This will set all commands defined in the `commands` instance for the current chat.
-
-## Examples
-
-### Example 1: Help Command
-
-This example shows how to define a basic help command:
-
-```typescript
-commands.command("help", "Sends help")
-  .localize("de-DE", "hilfe", "Sendet Hilfe")
-  .addToScope("default")
-  .addToScope("all_group_chats")
-  .addToScope("all_private_chats")
-  .addToScope("all_chat_administrators")
-  .addToScope("chat_administrators", "@grammyjs")
-  .addToScope("chat", "@LWJerri");
-```
-
-### Example 2: Stats Command
-
-This example shows how to define a stats command for group chats:
-
-```typescript
-commands.command("stats", "Sends group stats")
-  .addToScope("all_group_chats")
-  .addToScope("all_chat_administrators")
-  .addToScope("chat_administrators", "@grammyjs")
-  .addToScope("chat", "@LWJerri");
-```
 
-Feel free to add more commands and customize them according to your bot's needs.
+bot.start()
+```

package/out/command.d.ts

@@ -1,22 +1,26 @@
-import { BotCommand, BotCommandScope, Chat, ChatTypeContext, CommandMiddleware, Composer, Context, Middleware } from "./deps.node.js";
+import { type BotCommand, type BotCommandScope, type BotCommandScopeAllChatAdministrators, type BotCommandScopeAllGroupChats, type BotCommandScopeAllPrivateChats, type ChatTypeMiddleware, type Context, type Middleware, type MiddlewareObj } from "./deps.node.js";
 export type MaybeArray<T> = T | T[];
-export declare class Command<C extends Context = Context> extends Composer<C> {
-    #private;
-    constructor(name: string, description: string, ...middleware: Array<Middleware<C>>);
+type BotCommandGroupsScope = BotCommandScopeAllGroupChats | BotCommandScopeAllChatAdministrators;
+export declare class Command<C extends Context = Context> implements MiddlewareObj<C> {
+    private _scopes;
+    private _languages;
+    private _composer;
+    constructor(name: string, description: string);
+    get scopes(): BotCommandScope[];
     get languages(): Map<string, {
         name: string;
         description: string;
     }>;
-    get scopes(): BotCommandScope[];
+    get names(): string[];
     get name(): string;
     get description(): string;
-    addToScope(type: "default" | "all_private_chats" | "all_group_chats" | "all_chat_administrators"): this;
-    addToScope(type: "chat", chatId: string | number): this;
-    addToScope(type: "chat_member", chatId: string | number, userId: number): this;
-    addToScope(type: "chat_administrators", chatId: string | number): this;
+    addToScope(scope: BotCommandGroupsScope, ...middleware: ChatTypeMiddleware<C, "group" | "supergroup">[]): this;
+    addToScope(scope: BotCommandScopeAllPrivateChats, ...middleware: ChatTypeMiddleware<C, "private">[]): this;
+    addToScope(scope: BotCommandScope, ...middleware: Array<Middleware<C>>): this;
     localize(languageCode: string, name: string, description: string): this;
     getLocalizedName(languageCode: string): string;
     getLocalizedDescription(languageCode: string): string;
-    onChatType<T extends Chat["type"]>(chatType: MaybeArray<T>, ...middleware: Array<CommandMiddleware<ChatTypeContext<C, T>>>): this;
     toObject(languageCode?: string): BotCommand;
+    middleware(): import("grammy").MiddlewareFn<C>;
 }
+export {};

package/out/command.js

@@ -1,62 +1,54 @@
 "use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Command_scopes, _Command_languages;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
 const deps_node_js_1 = require("./deps.node.js");
-class Command extends deps_node_js_1.Composer {
-    constructor(name, description, ...middleware) {
-        super();
-        _Command_scopes.set(this, []);
-        _Command_languages.set(this, new Map());
-        if (!name.match(/[a-z0-9_]{1,32}/)) {
-            throw new Error(`${name} is not a valid command name`);
-        }
-        __classPrivateFieldGet(this, _Command_languages, "f").set("default", { name, description });
-        this.command(name, ...middleware);
+const isAdmin = (ctx) => ctx.getAuthor().then((author) => ["administrator", "creator"].includes(author.status));
+class Command {
+    constructor(name, description) {
+        this._scopes = [];
+        this._languages = new Map();
+        this._composer = new deps_node_js_1.Composer();
+        this._languages.set("default", { name, description });
+    }
+    get scopes() {
+        return this._scopes;
     }
     get languages() {
-        return __classPrivateFieldGet(this, _Command_languages, "f");
+        return this._languages;
     }
-    get scopes() {
-        return __classPrivateFieldGet(this, _Command_scopes, "f");
+    get names() {
+        return Array.from(this._languages.values()).map(({ name }) => name);
     }
     get name() {
-        return __classPrivateFieldGet(this, _Command_languages, "f").get("default").name;
+        return this._languages.get("default").name;
     }
     get description() {
-        return __classPrivateFieldGet(this, _Command_languages, "f").get("default").description;
-    }
-    addToScope(type, chatId, userId) {
-        const scope = (0, deps_node_js_1.match)({ type, chatId, userId })
-            .with({ type: "default" }, { type: "all_chat_administrators" }, { type: "all_group_chats" }, { type: "all_private_chats" }, ({ type }) => ({ type }))
-            .with({ type: deps_node_js_1.P.union("chat", "chat_administrators"), chatId: deps_node_js_1.P.not(deps_node_js_1.P.nullish) }, ({ type, chatId }) => ({ type, chat_id: chatId }))
-            .with({ type: "chat_member", chatId: deps_node_js_1.P.not(deps_node_js_1.P.nullish), userId: deps_node_js_1.P.not(deps_node_js_1.P.nullish) }, ({ type, chatId, userId }) => ({ type, chat_id: chatId, user_id: userId }))
-            .otherwise(() => null);
-        if (scope)
-            __classPrivateFieldGet(this, _Command_scopes, "f").push(scope);
+        return this._languages.get("default").description;
+    }
+    addToScope(scope, ...middleware) {
+        (0, deps_node_js_1.match)(scope)
+            .with({ type: "default" }, () => this._composer.command(this.names, ...middleware))
+            .with({ type: "all_chat_administrators" }, () => this._composer.filter(isAdmin).command(this.names, ...middleware))
+            .with({ type: "all_private_chats" }, () => this._composer.chatType("private").command(this.names, ...middleware))
+            .with({ type: "all_group_chats" }, () => this._composer.chatType(["group", "supergroup"]).command(this.names, ...middleware))
+            .with({ type: deps_node_js_1.P.union("chat", "chat_administrators"), chat_id: deps_node_js_1.P.not(deps_node_js_1.P.nullish).select() }, (chatId) => this._composer.filter((ctx) => { var _a; return ((_a = ctx.chat) === null || _a === void 0 ? void 0 : _a.id) === chatId; }).filter(isAdmin).command(this.names, ...middleware))
+            .with({ type: "chat_member", chat_id: deps_node_js_1.P.not(deps_node_js_1.P.nullish).select("chatId"), user_id: deps_node_js_1.P.not(deps_node_js_1.P.nullish).select("userId") }, ({ chatId, userId }) => this._composer.filter((ctx) => { var _a; return ((_a = ctx.chat) === null || _a === void 0 ? void 0 : _a.id) === chatId; })
+            .filter((ctx) => { var _a; return ((_a = ctx.from) === null || _a === void 0 ? void 0 : _a.id) === userId; })
+            .command(this.names, ...middleware));
+        this._scopes.push(scope);
         return this;
     }
     localize(languageCode, name, description) {
-        __classPrivateFieldGet(this, _Command_languages, "f").set(languageCode, { name, description });
+        this._languages.set(languageCode, { name, description });
         return this;
     }
     getLocalizedName(languageCode) {
         var _a, _b;
-        return (_b = (_a = __classPrivateFieldGet(this, _Command_languages, "f").get(languageCode)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : this.name;
+        return (_b = (_a = this._languages.get(languageCode)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : this.name;
     }
     getLocalizedDescription(languageCode) {
         var _a, _b;
-        return (_b = (_a = __classPrivateFieldGet(this, _Command_languages, "f").get(languageCode)) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : this.description;
-    }
-    onChatType(chatType, ...middleware) {
-        const names = Array.from(__classPrivateFieldGet(this, _Command_languages, "f").values()).map(({ name }) => name);
-        this.chatType(chatType).command(names, ...middleware);
-        return this;
+        return (_b = (_a = this._languages.get(languageCode)) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : this.description;
     }
     toObject(languageCode = "default") {
         return {
@@ -64,6 +56,8 @@ class Command extends deps_node_js_1.Composer {
             description: this.getLocalizedDescription(languageCode),
         };
     }
+    middleware() {
+        return this._composer.middleware();
+    }
 }
 exports.Command = Command;
-_Command_scopes = new WeakMap(), _Command_languages = new WeakMap();

package/out/deps.node.d.ts

@@ -1,3 +1,3 @@
-export { Bot, type ChatTypeContext, type CommandMiddleware, Composer, Context, type Middleware, type NextFunction, } from "grammy";
-export type { BotCommand, BotCommandScope, Chat } from "grammy/types";
+export { Api, Bot, type ChatTypeContext, type ChatTypeMiddleware, type CommandMiddleware, Composer, Context, type Middleware, type MiddlewareObj, type NextFunction, } from "grammy";
+export type { BotCommand, BotCommandScope, BotCommandScopeAllChatAdministrators, BotCommandScopeAllGroupChats, BotCommandScopeAllPrivateChats, Chat, } from "grammy/types";
 export { match, P } from "ts-pattern";

package/out/deps.node.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.P = exports.match = exports.Context = exports.Composer = exports.Bot = void 0;
+exports.P = exports.match = exports.Context = exports.Composer = exports.Bot = exports.Api = void 0;
 // TODO: Replace with official deno module, once it arrives (https://github.com/gvergnaud/ts-pattern/pull/108)
 var grammy_1 = require("grammy");
+Object.defineProperty(exports, "Api", { enumerable: true, get: function () { return grammy_1.Api; } });
 Object.defineProperty(exports, "Bot", { enumerable: true, get: function () { return grammy_1.Bot; } });
 Object.defineProperty(exports, "Composer", { enumerable: true, get: function () { return grammy_1.Composer; } });
 Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return grammy_1.Context; } });

package/out/plugin.d.ts

@@ -1,18 +1,27 @@
 import { Command } from "./command.js";
-import { Bot, BotCommand, BotCommandScope, Context, Middleware } from "./deps.node.js";
+import { Api, BotCommand, BotCommandScope, Context } from "./deps.node.js";
 type SetMyCommandsParams = {
     scope?: BotCommandScope;
     language_code?: string;
     commands: BotCommand[];
 };
 export declare class Commands<C extends Context> {
-    #private;
+    private _languages;
+    private _scopes;
+    private _commands;
+    private _composer;
     constructor(commands?: Command<C>[]);
-    command(name: string, description: string, ...middleware: Array<Middleware<C>>): Command<C>;
+    private _addCommandToScope;
+    private _populateComposer;
+    private _populateMetadata;
+    command(name: string, description: string): Command<C>;
     toArgs(): SetMyCommandsParams[];
     toSingleScopeArgs(scope: BotCommandScope): SetMyCommandsParams[];
-    setFor<C extends Context>(bot: Bot<C>): Promise<true[]>;
+    setCommands({ api }: {
+        api: Api;
+    }): Promise<void>;
     toJSON(): SetMyCommandsParams[];
     toString(): string;
+    middleware(): import("grammy").MiddlewareFn<C>;
 }
 export {};

package/out/plugin.js

@@ -1,38 +1,50 @@
 "use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _Commands_instances, _Commands_languages, _Commands_scopes, _Commands_commands, _Commands_addCommandToScope, _Commands_populate;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Commands = void 0;
 const command_js_1 = require("./command.js");
 const deps_node_js_1 = require("./deps.node.js");
 class Commands {
     constructor(commands = []) {
-        _Commands_instances.add(this);
-        _Commands_languages.set(this, new Set());
-        _Commands_scopes.set(this, new Map());
-        _Commands_commands.set(this, []);
-        commands.forEach((command) => __classPrivateFieldGet(this, _Commands_commands, "f").push(command));
+        this._languages = new Set();
+        this._scopes = new Map();
+        this._commands = [];
+        this._composer = new deps_node_js_1.Composer();
+        commands.forEach((command) => this._commands.push(command));
     }
-    command(name, description, ...middleware) {
-        const command = new command_js_1.Command(name, description, ...middleware);
-        __classPrivateFieldGet(this, _Commands_commands, "f").push(command);
+    _addCommandToScope(scope, command) {
+        var _a;
+        const commands = (_a = this._scopes.get(JSON.stringify(scope))) !== null && _a !== void 0 ? _a : [];
+        this._scopes.set(JSON.stringify(scope), commands.concat([command]));
+    }
+    _populateComposer() {
+        for (const command of this._commands) {
+            for (const args of command.languages.values()) {
+                this._composer.command(args.name, command.middleware());
+            }
+        }
+    }
+    _populateMetadata() {
+        this._languages.clear();
+        this._scopes.clear();
+        this._commands.forEach((command) => {
+            for (const scope of command.scopes) {
+                this._addCommandToScope(scope, command);
+            }
+            for (const language of command.languages.keys()) {
+                this._languages.add(language);
+            }
+        });
+    }
+    command(name, description) {
+        const command = new command_js_1.Command(name, description);
+        this._commands.push(command);
         return command;
     }
     toArgs() {
-        __classPrivateFieldGet(this, _Commands_instances, "m", _Commands_populate).call(this);
+        this._populateMetadata();
         const params = [];
-        for (const [scope, commands] of __classPrivateFieldGet(this, _Commands_scopes, "f").entries()) {
-            for (const language of __classPrivateFieldGet(this, _Commands_languages, "f")) {
+        for (const [scope, commands] of this._scopes.entries()) {
+            for (const language of this._languages) {
                 params.push({
                     scope: JSON.parse(scope),
                     language_code: language === "default" ? undefined : language,
@@ -43,23 +55,21 @@ class Commands {
         return params.filter((params) => params.commands.length > 0);
     }
     toSingleScopeArgs(scope) {
-        __classPrivateFieldGet(this, _Commands_instances, "m", _Commands_populate).call(this);
+        this._populateMetadata();
         const params = [];
-        for (const language of __classPrivateFieldGet(this, _Commands_languages, "f")) {
+        for (const language of this._languages) {
             params.push({
                 scope,
-                language_code: (0, deps_node_js_1.match)(language).with("default", () => undefined).otherwise((value) => value),
-                commands: __classPrivateFieldGet(this, _Commands_commands, "f")
+                language_code: language === "default" ? undefined : language,
+                commands: this._commands
                     .filter((command) => command.scopes.length)
                     .map((command) => command.toObject(language)),
             });
         }
         return params;
     }
-    setFor(bot) {
-        const argsArray = this.toArgs();
-        const promises = argsArray.map((args) => bot.api.raw.setMyCommands(args));
-        return Promise.all(promises);
+    async setCommands({ api }) {
+        await Promise.all(this.toArgs().map((args) => api.raw.setMyCommands(args)));
     }
     toJSON() {
         return this.toArgs();
@@ -67,18 +77,11 @@ class Commands {
     toString() {
         return JSON.stringify(this);
     }
-    [(_Commands_languages = new WeakMap(), _Commands_scopes = new WeakMap(), _Commands_commands = new WeakMap(), _Commands_instances = new WeakSet(), _Commands_addCommandToScope = function _Commands_addCommandToScope(scope, command) {
-        var _a;
-        const commands = (_a = __classPrivateFieldGet(this, _Commands_scopes, "f").get(JSON.stringify(scope))) !== null && _a !== void 0 ? _a : [];
-        __classPrivateFieldGet(this, _Commands_scopes, "f").set(JSON.stringify(scope), commands.concat([command]));
-    }, _Commands_populate = function _Commands_populate() {
-        __classPrivateFieldSet(this, _Commands_languages, new Set(), "f");
-        __classPrivateFieldSet(this, _Commands_scopes, new Map(), "f");
-        __classPrivateFieldGet(this, _Commands_commands, "f").forEach((command) => {
-            command.scopes.forEach((scope) => __classPrivateFieldGet(this, _Commands_instances, "m", _Commands_addCommandToScope).call(this, scope, command));
-            Array.from(command.languages.keys()).forEach((language) => __classPrivateFieldGet(this, _Commands_languages, "f").add(language));
-        });
-    }, Symbol.for("Deno.customInspect"))]() {
+    middleware() {
+        this._populateComposer();
+        return this._composer.middleware();
+    }
+    [Symbol.for("Deno.customInspect")]() {
         return this.toString();
     }
     [Symbol.for("nodejs.util.inspect.custom")]() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grammyjs/commands",
-  "version": "0.0.1",
+  "version": "0.3.1",
   "description": "grammY Commands Plugin",
   "main": "out/mod.js",
   "scripts": {
@@ -21,5 +21,7 @@
   "devDependencies": {
     "typescript": "^5.1.6"
   },
-  "files": ["out"]
+  "files": [
+    "out"
+  ]
 }