@grammyjs/commands 1.0.5 → 1.0.9

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 { Api, BotCommand, BotCommandScope, BotCommandScopeChat, CommandContext, Context, type LanguageCode, Middleware } from "./deps.node.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
@@ -81,7 +83,7 @@ export declare class CommandGroup<C extends Context> {
      *
      * @returns One item for each combination of command + scope + language
      */
-    toArgs(): {
+    toArgs(chat_id?: BotCommandScopeChat["chat_id"]): {
         scopes: SetMyCommandsParams[];
         uncompliantCommands: UncompliantCommand[];
     };
@@ -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

@@ -78,7 +78,7 @@ class CommandGroup {
      *
      * @returns One item for each combination of command + scope + language
      */
-    toArgs() {
+    toArgs(chat_id) {
         this._populateMetadata();
         const scopes = [];
         const uncompliantCommands = [];
@@ -98,7 +98,9 @@ class CommandGroup {
                 });
                 if (compliantScopedCommands.length) {
                     scopes.push({
-                        scope: JSON.parse(scope),
+                        scope: chat_id
+                            ? { ...JSON.parse(scope), chat_id }
+                            : { ...JSON.parse(scope) },
                         language_code: language === "default" ? undefined : language,
                         commands: compliantScopedCommands.map((command) => command.toObject(language)),
                     });
@@ -158,13 +160,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 +179,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.d.ts

@@ -84,40 +84,13 @@ export declare class MyCommandParams {
         commandsParams: SetMyCommandsParams[];
         uncompliantCommands: import("./command-group.js").UncompliantCommand[];
     };
-    /**
-       * Serializes one or multiple {@link CommandGroup} instances, each one into their respective
-       * single scoped SetMyCommandsParams version.
-       * @example
-          ```ts
-          const adminCommands = new CommandGroup();
-          // add to scope, localize, etc
-          const userCommands = new CommandGroup();
-          // add to scope, localize, etc
-          const [
-              singleScopedAdminParams,
-              singleScopedUserParams
-          ] = MyCommandsParams.serialize([adminCommands,userCommands])
-          ```
-       * @param commandsArr an array of one or more commands instances
-       * @param chat_id the chat id relative to the message update, coming from the ctx object.
-       * @returns an array of scoped {@link SetMyCommandsParams} mapped from their respective Commands instances
-       */
-    static _serialize<C extends Context>(commandsArr: CommandGroup<C>[], chat_id: BotCommandScopeChat["chat_id"]): {
-        commandParams: SetMyCommandsParams[];
-        uncompliantCommands: import("./command-group.js").UncompliantCommand[];
-    }[];
-    /**
-     * Lexicographically sorts commandParams based on their language code.
-     * @returns the sorted array
-     */
-    static _sortByLanguage(params: SetMyCommandsParams[]): SetMyCommandsParams[];
     /**
      * Iterates over an array of CommandsParams
      * merging their respective {@link SetMyCommandsParams.commands}
-     * when they are from the same language, separating when they are not.
+     * when they are from the same language and scope
      *
      * @param params a flattened array of commands params coming from one or more Commands instances
      * @returns an array containing all commands grouped by language
      */
-    private static mergeByLanguage;
+    private static merge;
 }

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")) {
@@ -98,79 +98,41 @@ class MyCommandParams {
        * @returns an array of {@link SetMyCommandsParams} grouped by language
        */
     static from(commands, chat_id) {
-        const serializedCommands = this._serialize(commands, chat_id);
+        const serializedCommands = commands.map((cmds) => cmds.toArgs(chat_id));
         const commandsParams = serializedCommands
-            .map(({ commandParams }) => commandParams)
+            .map(({ scopes }) => scopes)
             .flat();
         const uncompliantCommands = serializedCommands
             .map(({ uncompliantCommands }) => uncompliantCommands)
             .flat();
         return {
-            commandsParams: this.mergeByLanguage(commandsParams),
+            commandsParams: this.merge(commandsParams),
             uncompliantCommands,
         };
     }
-    /**
-       * Serializes one or multiple {@link CommandGroup} instances, each one into their respective
-       * single scoped SetMyCommandsParams version.
-       * @example
-          ```ts
-          const adminCommands = new CommandGroup();
-          // add to scope, localize, etc
-          const userCommands = new CommandGroup();
-          // add to scope, localize, etc
-          const [
-              singleScopedAdminParams,
-              singleScopedUserParams
-          ] = MyCommandsParams.serialize([adminCommands,userCommands])
-          ```
-       * @param commandsArr an array of one or more commands instances
-       * @param chat_id the chat id relative to the message update, coming from the ctx object.
-       * @returns an array of scoped {@link SetMyCommandsParams} mapped from their respective Commands instances
-       */
-    static _serialize(commandsArr, chat_id) {
-        return commandsArr.map((commands) => commands.toSingleScopeArgs({
-            type: "chat",
-            chat_id,
-        }));
-    }
-    /**
-     * Lexicographically sorts commandParams based on their language code.
-     * @returns the sorted array
-     */
-    static _sortByLanguage(params) {
-        return params.sort((a, b) => {
-            if (!a.language_code)
-                return -1;
-            if (!b.language_code)
-                return 1;
-            return a.language_code.localeCompare(b.language_code);
-        });
-    }
     /**
      * Iterates over an array of CommandsParams
      * merging their respective {@link SetMyCommandsParams.commands}
-     * when they are from the same language, separating when they are not.
+     * when they are from the same language and scope
      *
      * @param params a flattened array of commands params coming from one or more Commands instances
      * @returns an array containing all commands grouped by language
      */
-    static mergeByLanguage(params) {
+    static merge(params) {
         if (!params.length)
             return [];
-        const sorted = this._sortByLanguage(params);
-        return sorted.reduce((result, current, i, arr) => {
-            if (i === 0 || current.language_code !== arr[i - 1].language_code) {
-                result.push(current);
-                return result;
-            }
-            else {
-                result[result.length - 1].commands = result[result.length - 1]
-                    .commands
-                    .concat(current.commands);
-                return result;
+        const map = new Map();
+        params.forEach((curr) => {
+            if (!curr.scope)
+                return;
+            const key = `${curr.scope.type},${curr.language_code}`;
+            const old = map.get(key);
+            if (old) {
+                curr.commands = curr.commands.concat(old.commands);
             }
-        }, []);
+            map.set(key, curr);
+        });
+        return [...map.values()];
     }
 }
 exports.MyCommandParams = MyCommandParams;

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.5",
+  "version": "1.0.9",
   "description": "grammY Commands Plugin",
   "main": "out/mod.js",
   "scripts": {