@grammyjs/commands 1.0.4 → 1.0.8

package/out/command-group.d.ts

@@ -1,6 +1,6 @@
 import { Command, CommandsFlavor } from "./mod.js";
 import { Api, BotCommand, BotCommandScope, CommandContext, Context, type LanguageCode, Middleware } from "./deps.node.js";
-import type { CommandElementals, CommandOptions } from "./types.js";
+import type { BotCommandX, CommandOptions } from "./types.js";
 import { type MaybeArray } from "./utils/array.js";
 import { SetBotCommandsOptions } from "./utils/set-bot-commands.js";
 import { JaroWinklerOptions } from "./utils/jaro-winkler.js";
@@ -16,7 +16,9 @@ export interface SetMyCommandsParams {
      */
     language_code?: LanguageCode;
     /** Commands that can be each one passed to a SetMyCommands Call */
-    commands: BotCommand[];
+    commands: (BotCommand & {
+        hasHandler?: boolean;
+    })[];
 }
 /**
  * Interface to represent uncompliance of a command
@@ -110,17 +112,18 @@ export declare class CommandGroup<C extends Context> {
         api: Api;
     }, options?: Partial<SetBotCommandsOptions>): Promise<void>;
     /**
-     * Serialize all register commands into it's name, prefix and language
+     * Serialize all register commands into a more detailed object
+     * including it's name, prefix and language, and more data
      *
      * @param filterLanguage if undefined, it returns all names
      * else get only the locales for the given filterLanguage
      * fallbacks to "default"
      *
-     * @returns an array of {@link CommandElementals}
+     * @returns an array of {@link BotCommandX}
      *
      * Note: mainly used to serialize for {@link FuzzyMatch}
      */
-    toElementals(filterLanguage?: LanguageCode | "default"): CommandElementals[];
+    toElementals(filterLanguage?: LanguageCode | "default"): BotCommandX[];
     /**
      * @returns A JSON serialized version of all the currently registered commands
      */

package/out/command-group.js

@@ -158,13 +158,14 @@ class CommandGroup {
         await (0, set_bot_commands_js_1.setBotCommands)(api, scopes, uncompliantCommands, options);
     }
     /**
-     * Serialize all register commands into it's name, prefix and language
+     * Serialize all register commands into a more detailed object
+     * including it's name, prefix and language, and more data
      *
      * @param filterLanguage if undefined, it returns all names
      * else get only the locales for the given filterLanguage
      * fallbacks to "default"
      *
-     * @returns an array of {@link CommandElementals}
+     * @returns an array of {@link BotCommandX}
      *
      * Note: mainly used to serialize for {@link FuzzyMatch}
      */
@@ -176,13 +177,16 @@ class CommandGroup {
             const elements = [];
             for (const [language, local] of command.languages.entries()) {
                 elements.push({
-                    name: local.name instanceof RegExp
+                    command: local.name instanceof RegExp
                         ? local.name.source
                         : local.name,
                     language,
                     prefix: command.prefix,
                     scopes: command.scopes,
                     description: command.getLocalizedDescription(language),
+                    ...(command.hasHandler
+                        ? { hasHandler: true }
+                        : { hasHandler: false }),
                 });
             }
             if (filterLanguage) {

package/out/command.d.ts

@@ -1,5 +1,5 @@
-import { type BotCommand, type BotCommandScope, type BotCommandScopeAllChatAdministrators, type BotCommandScopeAllGroupChats, type BotCommandScopeAllPrivateChats, type ChatTypeMiddleware, CommandContext, type Context, type LanguageCode, type Middleware, type MiddlewareObj } from "./deps.node.js";
-import type { CommandOptions } from "./types.js";
+import { type BotCommandScope, type BotCommandScopeAllChatAdministrators, type BotCommandScopeAllGroupChats, type BotCommandScopeAllPrivateChats, type ChatTypeMiddleware, CommandContext, type Context, type LanguageCode, type Middleware, type MiddlewareObj } from "./deps.node.js";
+import type { BotCommandX, CommandOptions } from "./types.js";
 import { type MaybeArray } from "./utils/array.js";
 type BotCommandGroupsScope = BotCommandScopeAllGroupChats | BotCommandScopeAllChatAdministrators;
 /**
@@ -27,9 +27,12 @@ export interface CommandMatch {
 export declare class Command<C extends Context = Context> implements MiddlewareObj<C> {
     private _scopes;
     private _languages;
-    private _composer;
     private _defaultScopeComposer;
     private _options;
+    private _scopeHandlers;
+    private _cachedComposer;
+    private _cachedComposerInvalidated;
+    private _hasHandler;
     /**
      * Initialize a new command with a default handler.
      *
@@ -111,6 +114,10 @@ export declare class Command<C extends Context = Context> implements MiddlewareO
      * Get the prefix for this command
      */
     get prefix(): string;
+    /**
+     * Get if this command has a handler
+     */
+    get hasHandler(): boolean;
     /**
      * Registers the command to a scope to allow it to be handled and used with `setMyCommands`.
      * This will automatically apply filtering middlewares for you, so the handler only runs on the specified scope.
@@ -198,7 +205,8 @@ export declare class Command<C extends Context = Context> implements MiddlewareO
      * @param languageCode If specified, uses localized versions of the command name and description
      * @returns Object representation of this command
      */
-    toObject(languageCode?: LanguageCode | "default"): BotCommand;
+    toObject(languageCode?: LanguageCode | "default"): Pick<BotCommandX, "command" | "description" | "hasHandler">;
+    private registerScopeHandlers;
     middleware(): import("grammy").MiddlewareFn<C>;
 }
 export {};

package/out/command.js

@@ -14,7 +14,6 @@ class Command {
         var _a;
         this._scopes = [];
         this._languages = new Map();
-        this._composer = new deps_node_js_1.Composer();
         this._defaultScopeComposer = new deps_node_js_1.Composer();
         this._options = {
             prefix: "/",
@@ -22,12 +21,19 @@ class Command {
             targetedCommands: "optional",
             ignoreCase: false,
         };
-        const handler = (0, checks_js_1.isMiddleware)(handlerOrOptions)
-            ? handlerOrOptions
-            : undefined;
+        this._scopeHandlers = new Map();
+        this._cachedComposer = new deps_node_js_1.Composer();
+        this._cachedComposerInvalidated = false;
+        let handler = (0, checks_js_1.isMiddleware)(handlerOrOptions) ? handlerOrOptions : undefined;
         options = !handler && (0, checks_js_1.isCommandOptions)(handlerOrOptions)
             ? handlerOrOptions
             : options;
+        if (!handler) {
+            handler = async (_ctx, next) => await next();
+            this._hasHandler = false;
+        }
+        else
+            this._hasHandler = true;
         this._options = { ...this._options, ...options };
         if (((_a = this._options.prefix) === null || _a === void 0 ? void 0 : _a.trim()) === "")
             this._options.prefix = "/";
@@ -111,58 +117,20 @@ class Command {
     get prefix() {
         return this._options.prefix;
     }
+    /**
+     * Get if this command has a handler
+     */
+    get hasHandler() {
+        return this._hasHandler;
+    }
     addToScope(scope, middleware, options = this._options) {
         const middlewareArray = middleware ? (0, array_js_1.ensureArray)(middleware) : undefined;
         const optionsObject = { ...this._options, ...options };
-        if (middlewareArray) {
-            switch (scope.type) {
-                case "default":
-                    this._defaultScopeComposer
-                        .filter(Command.hasCommand(this.names, optionsObject))
-                        .use(...middlewareArray);
-                    break;
-                case "all_chat_administrators":
-                    this._composer
-                        .filter(Command.hasCommand(this.names, optionsObject))
-                        .filter(checks_js_1.isAdmin)
-                        .use(...middlewareArray);
-                    break;
-                case "all_private_chats":
-                    this._composer
-                        .filter(Command.hasCommand(this.names, optionsObject))
-                        .chatType("private")
-                        .use(...middlewareArray);
-                    break;
-                case "all_group_chats":
-                    this._composer
-                        .filter(Command.hasCommand(this.names, optionsObject))
-                        .chatType(["group", "supergroup"])
-                        .use(...middlewareArray);
-                    break;
-                case "chat":
-                case "chat_administrators":
-                    if (scope.chat_id) {
-                        this._composer
-                            .filter(Command.hasCommand(this.names, optionsObject))
-                            .filter((ctx) => { var _a; return ((_a = ctx.chat) === null || _a === void 0 ? void 0 : _a.id) === scope.chat_id; })
-                            .filter(checks_js_1.isAdmin)
-                            .use(...middlewareArray);
-                    }
-                    break;
-                case "chat_member":
-                    if (scope.chat_id && scope.user_id) {
-                        this._composer
-                            .filter(Command.hasCommand(this.names, optionsObject))
-                            .filter((ctx) => { var _a; return ((_a = ctx.chat) === null || _a === void 0 ? void 0 : _a.id) === scope.chat_id; })
-                            .filter((ctx) => { var _a; return ((_a = ctx.from) === null || _a === void 0 ? void 0 : _a.id) === scope.user_id; })
-                            .use(...middlewareArray);
-                    }
-                    break;
-                default:
-                    throw new errors_js_1.InvalidScopeError(scope);
-            }
-        }
         this._scopes.push(scope);
+        if (middlewareArray && middlewareArray.length) {
+            this._scopeHandlers.set(scope, [optionsObject, middlewareArray]);
+            this._cachedComposerInvalidated = true;
+        }
         return this;
     }
     /**
@@ -176,17 +144,18 @@ class Command {
      * ```
      */
     static findMatchingCommand(command, options, ctx) {
-        var _a;
+        var _a, _b;
         const { matchOnlyAtStart, prefix, targetedCommands } = options;
-        if (!ctx.has(":text"))
+        if (!ctx.has([":text", ":caption"]))
             return null;
-        if (matchOnlyAtStart && !ctx.msg.text.startsWith(prefix)) {
+        const txt = (_a = ctx.msg.text) !== null && _a !== void 0 ? _a : ctx.msg.caption;
+        if (matchOnlyAtStart && !txt.startsWith(prefix)) {
             return null;
         }
         const commandNames = (0, array_js_1.ensureArray)(command);
         const escapedPrefix = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
         const commandRegex = new RegExp(`${escapedPrefix}(?<command>[^@ ]+)(?:@(?<username>[^\\s]*))?(?<rest>.*)`, "g");
-        const firstCommand = (_a = commandRegex.exec(ctx.msg.text)) === null || _a === void 0 ? void 0 : _a.groups;
+        const firstCommand = (_b = commandRegex.exec(txt)) === null || _b === void 0 ? void 0 : _b.groups;
         if (!firstCommand)
             return null;
         if (!firstCommand.username && targetedCommands === "required")
@@ -206,7 +175,7 @@ class Command {
             return {
                 command: matchingCommand,
                 rest: firstCommand.rest.trim(),
-                match: matchingCommand.exec(ctx.msg.text),
+                match: matchingCommand.exec(txt),
             };
         }
         if (matchingCommand) {
@@ -263,6 +232,7 @@ class Command {
             name: name,
             description,
         });
+        this._cachedComposerInvalidated = true;
         return this;
     }
     /**
@@ -297,11 +267,80 @@ class Command {
                 ? localizedName.source
                 : localizedName,
             description: this.getLocalizedDescription(languageCode),
+            ...(this.hasHandler ? { hasHandler: true } : { hasHandler: false }),
         };
     }
+    registerScopeHandlers() {
+        const entries = this._scopeHandlers.entries();
+        for (const [scope, [optionsObject, middlewareArray]] of entries) {
+            if (middlewareArray) {
+                switch (scope.type) {
+                    case "default":
+                        this._defaultScopeComposer
+                            .filter(Command.hasCommand(this.names, optionsObject))
+                            .use(...middlewareArray);
+                        break;
+                    case "all_chat_administrators":
+                        this._cachedComposer
+                            .filter(Command.hasCommand(this.names, optionsObject))
+                            .chatType(["group", "supergroup"])
+                            .filter(checks_js_1.isAdmin)
+                            .use(...middlewareArray);
+                        break;
+                    case "all_private_chats":
+                        this._cachedComposer
+                            .filter(Command.hasCommand(this.names, optionsObject))
+                            .chatType("private")
+                            .use(...middlewareArray);
+                        break;
+                    case "all_group_chats":
+                        this._cachedComposer
+                            .filter(Command.hasCommand(this.names, optionsObject))
+                            .chatType(["group", "supergroup"])
+                            .use(...middlewareArray);
+                        break;
+                    case "chat":
+                        if (scope.chat_id) {
+                            this._cachedComposer
+                                .filter(Command.hasCommand(this.names, optionsObject))
+                                .chatType(["group", "supergroup", "private"])
+                                .filter((ctx) => ctx.chatId === scope.chat_id)
+                                .use(...middlewareArray);
+                        }
+                        break;
+                    case "chat_administrators":
+                        if (scope.chat_id) {
+                            this._cachedComposer
+                                .filter(Command.hasCommand(this.names, optionsObject))
+                                .chatType(["group", "supergroup"])
+                                .filter((ctx) => ctx.chatId === scope.chat_id)
+                                .filter(checks_js_1.isAdmin)
+                                .use(...middlewareArray);
+                        }
+                        break;
+                    case "chat_member":
+                        if (scope.chat_id && scope.user_id) {
+                            this._cachedComposer
+                                .filter(Command.hasCommand(this.names, optionsObject))
+                                .chatType(["group", "supergroup"])
+                                .filter((ctx) => ctx.chatId === scope.chat_id)
+                                .filter((ctx) => { var _a; return ((_a = ctx.from) === null || _a === void 0 ? void 0 : _a.id) === scope.user_id; })
+                                .use(...middlewareArray);
+                        }
+                        break;
+                    default:
+                        throw new errors_js_1.InvalidScopeError(scope);
+                }
+            }
+        }
+        this._cachedComposer.use(this._defaultScopeComposer);
+        this._cachedComposerInvalidated = false;
+    }
     middleware() {
-        return new deps_node_js_1.Composer(this._composer, this._defaultScopeComposer)
-            .middleware();
+        if (this._cachedComposerInvalidated) {
+            this.registerScopeHandlers();
+        }
+        return this._cachedComposer.middleware();
     }
 }
 exports.Command = Command;

package/out/context.js

@@ -38,7 +38,7 @@ function commands() {
             const result = results[0];
             if (!result || !result.command)
                 return null;
-            return result.command.prefix + result.command.name;
+            return result.command.prefix + result.command.command;
         };
         ctx.getCommandEntities = (commands) => {
             if (!ctx.has(":text")) {

package/out/mod.d.ts

@@ -2,3 +2,4 @@ export { Command } from "./command.js";
 export * from "./command-group.js";
 export * from "./context.js";
 export type { CommandOptions } from "./types.js";
+export { LanguageCodes } from "./language-codes.js";

package/out/mod.js

@@ -14,8 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Command = void 0;
+exports.LanguageCodes = exports.Command = void 0;
 var command_js_1 = require("./command.js");
 Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_js_1.Command; } });
 __exportStar(require("./command-group.js"), exports);
 __exportStar(require("./context.js"), exports);
+var language_codes_js_1 = require("./language-codes.js");
+Object.defineProperty(exports, "LanguageCodes", { enumerable: true, get: function () { return language_codes_js_1.LanguageCodes; } });

package/out/types.d.ts

@@ -1,4 +1,4 @@
-import type { BotCommandScope, LanguageCode, MessageEntity } from "./deps.node.js";
+import type { BotCommand, BotCommandScope, LanguageCode, MessageEntity } from "./deps.node.js";
 /**
  * Supported command options
  */
@@ -28,12 +28,24 @@ export interface CommandOptions {
      */
     ignoreCase: boolean;
 }
-export interface CommandElementals {
-    name: string;
+/**
+ * BotCommand representation with more information about it.
+ * Specially in regards to the plugin manipulation of it
+ */
+export interface BotCommandX extends BotCommand {
     prefix: string;
+    /**
+     * Language in which this command is localize
+     */
     language: LanguageCode | "default";
+    /**
+     * Scopes in which this command is registered
+     */
     scopes: BotCommandScope[];
-    description: string;
+    /**
+     * True if this command has middleware attach to it. False if not.
+     */
+    hasHandler: boolean;
 }
 /** represents a bot__command entity inside a text message */
 export interface BotCommandEntity extends MessageEntity.CommonMessageEntity {

package/out/utils/jaro-winkler.d.ts

@@ -1,6 +1,6 @@
 import { CommandGroup } from "../command-group.js";
 import { Context, LanguageCode } from "../deps.node.js";
-import type { CommandElementals } from "../types.js";
+import type { BotCommandX } from "../types.js";
 export declare function distance(s1: string, s2: string): number;
 export type JaroWinklerOptions = {
     ignoreCase?: boolean;
@@ -9,7 +9,7 @@ export type JaroWinklerOptions = {
     ignoreLocalization?: boolean;
 };
 type CommandSimilarity = {
-    command: CommandElementals | null;
+    command: BotCommandX | null;
     similarity: number;
 };
 export declare function JaroWinklerDistance(s1: string, s2: string, options: Pick<Partial<JaroWinklerOptions>, "ignoreCase">): number;

package/out/utils/jaro-winkler.js

@@ -107,7 +107,7 @@ function fuzzyMatch(userInput, commands, options) {
         ? commands.toElementals()
         : commands.toElementals(language);
     const bestMatch = cmds.reduce((best, command) => {
-        const similarity = JaroWinklerDistance(userInput, command.name, {
+        const similarity = JaroWinklerDistance(userInput, command.command, {
             ...options,
         });
         return similarity > best.similarity ? { command, similarity } : best;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grammyjs/commands",
-  "version": "1.0.4",
+  "version": "1.0.8",
   "description": "grammY Commands Plugin",
   "main": "out/mod.js",
   "scripts": {