@grammyjs/commands 0.7.0 → 0.8.0

package/out/command.d.ts

@@ -1,6 +1,6 @@
-import { type BotCommand, type BotCommandScope, type BotCommandScopeAllChatAdministrators, type BotCommandScopeAllGroupChats, type BotCommandScopeAllPrivateChats, type ChatTypeMiddleware, type Context, type Middleware, type MiddlewareObj } from "./deps.node.js";
-import { CommandOptions } from "./types.js";
-export type MaybeArray<T> = T | T[];
+import { type BotCommand, type BotCommandScope, type BotCommandScopeAllChatAdministrators, type BotCommandScopeAllGroupChats, type BotCommandScopeAllPrivateChats, type ChatTypeMiddleware, type Context, type LanguageCode, type Middleware, type MiddlewareObj } from "./deps.node.js";
+import type { CommandOptions } from "./types.js";
+import { type MaybeArray } from "./utils.js";
 type BotCommandGroupsScope = BotCommandScopeAllGroupChats | BotCommandScopeAllChatAdministrators;
 export declare const matchesPattern: (value: string, pattern: string | RegExp) => boolean;
 /**
@@ -28,7 +28,7 @@ export declare class Command<C extends Context = Context> implements MiddlewareO
     /**
      * Get registered languages for this command
      */
-    get languages(): Map<string, {
+    get languages(): Map<LanguageCode | "default", {
         name: string | RegExp;
         description: string;
     }>;
@@ -44,6 +44,10 @@ export declare class Command<C extends Context = Context> implements MiddlewareO
      * Get the default description for this command
      */
     get description(): string;
+    /**
+     * Get the prefix for this command
+     */
+    get prefix(): string;
     /**
      * 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.
@@ -100,19 +104,19 @@ export declare class Command<C extends Context = Context> implements MiddlewareO
      * @param name Localized command name
      * @param description Localized command description
      */
-    localize(languageCode: string, name: string | RegExp, description: string): this;
+    localize(languageCode: LanguageCode, name: string | RegExp, description: string): this;
     /**
      * Gets the localized command name of an existing translation
      * @param languageCode Language to get the name for
      * @returns Localized command name
      */
-    getLocalizedName(languageCode: string): string | RegExp;
+    getLocalizedName(languageCode: LanguageCode | "default"): string | RegExp;
     /**
      * Gets the localized command name of an existing translation
      * @param languageCode Language to get the name for
      * @returns Localized command name
      */
-    getLocalizedDescription(languageCode: string): string;
+    getLocalizedDescription(languageCode: LanguageCode | "default"): string;
     /**
      * Converts command to an object representation.
      * Useful for JSON serialization.
@@ -120,7 +124,7 @@ 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?: string): BotCommand;
+    toObject(languageCode?: LanguageCode | "default"): BotCommand;
     middleware(): import("grammy").MiddlewareFn<C>;
 }
 export {};

package/out/command.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = exports.matchesPattern = void 0;
 const deps_node_js_1 = require("./deps.node.js");
 const errors_js_1 = require("./errors.js");
-const ensureArray = (value) => Array.isArray(value) ? value : [value];
+const utils_js_1 = require("./utils.js");
 const isAdmin = (ctx) => ctx
     .getAuthor()
     .then((author) => ["administrator", "creator"].includes(author.status));
@@ -66,8 +66,14 @@ class Command {
     get description() {
         return this._languages.get("default").description;
     }
+    /**
+     * Get the prefix for this command
+     */
+    get prefix() {
+        return this._options.prefix;
+    }
     addToScope(scope, middleware, options = this._options) {
-        const middlewareArray = ensureArray(middleware);
+        const middlewareArray = (0, utils_js_1.ensureArray)(middleware);
         const optionsObject = { ...this._options, ...options };
         switch (scope.type) {
             case "default":
@@ -142,7 +148,7 @@ class Command {
             if (matchOnlyAtStart && !ctx.msg.text.startsWith(prefix)) {
                 return false;
             }
-            const commandNames = ensureArray(command);
+            const commandNames = (0, utils_js_1.ensureArray)(command);
             const commands = prefix === "/"
                 ? ctx.entities("bot_command")
                 : ctx.msg.text.split(prefix).map((text) => ({ text }));

package/out/commands.d.ts

@@ -1,13 +1,19 @@
-import { Command, MaybeArray } from "./command.js";
-import { Api, BotCommand, BotCommandScope, CommandContext, Context, Middleware } from "./deps.node.js";
-import { CommandOptions } from "./types.js";
+import { Command } from "./command.js";
+import { Api, BotCommand, BotCommandScope, CommandContext, Context, type LanguageCode, Middleware } from "./deps.node.js";
+import type { CommandElementals, CommandOptions } from "./types.js";
+import { type MaybeArray } from "./utils.js";
+/**
+ * Interface for grouping {@link BotCommand}s that might (or not)
+ * be related to each other by scope and/or language.
+ */
 export type SetMyCommandsParams = {
-    /**
-     * Scope
-     * @param language_code two letter abbreviation in ISO_639 standard: https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes
-     */
+    /** If defined: scope on which the commands will take effect */
     scope?: BotCommandScope;
-    language_code?: string;
+    /** If defined: Language on which the commands will take effect.
+     * Two letter abbreviation in ISO_639 standard: https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes
+     */
+    language_code?: LanguageCode;
+    /** Commands that can be each one passed to a SetMyCommands Call */
     commands: BotCommand[];
 };
 /**
@@ -66,15 +72,28 @@ export declare class Commands<C extends Context> {
      * Registers all commands to be displayed by clients according to their scopes and languages
      * Calls `setMyCommands` for each language of each scope of each command.
      *
+     * [!IMPORTANT]
+     * Calling this method with upperCased command names registered, will throw
+     * @see https://core.telegram.org/bots/api#botcommand
+     * @see https://core.telegram.org/method/bots.setBotCommands
+     *
      * @param Instance of `bot` or { api: bot.api }
      */
     setCommands({ api }: {
         api: Api;
     }): Promise<void>;
     /**
-     * Alias for {@link toArgs}
+     * Serialize all register commands into it's name, prefix and language
+     *
+     * @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}
+     *
+     * Note: mainly used to serialize for {@link FuzzyMatch}
      */
-    toJSON(): SetMyCommandsParams[];
+    toElementals(filterLanguage?: LanguageCode | "default"): CommandElementals[];
     /**
      * @returns A JSON serialized version of all the currently registered commands
      */

package/out/commands.js

@@ -89,8 +89,9 @@ class Commands {
                     language_code: language === "default"
                         ? undefined
                         : language,
-                    commands: commands.map((command) => command.toObject(language))
-                        .filter((args) => args.command.length > 0),
+                    commands: commands
+                        .filter((command) => typeof command.name === "string")
+                        .map((command) => command.toObject(language)),
                 });
             }
         }
@@ -121,16 +122,52 @@ class Commands {
      * Registers all commands to be displayed by clients according to their scopes and languages
      * Calls `setMyCommands` for each language of each scope of each command.
      *
+     * [!IMPORTANT]
+     * Calling this method with upperCased command names registered, will throw
+     * @see https://core.telegram.org/bots/api#botcommand
+     * @see https://core.telegram.org/method/bots.setBotCommands
+     *
      * @param Instance of `bot` or { api: bot.api }
      */
     async setCommands({ api }) {
         await Promise.all(this.toArgs().map((args) => api.raw.setMyCommands(args)));
     }
     /**
-     * Alias for {@link toArgs}
+     * Serialize all register commands into it's name, prefix and language
+     *
+     * @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}
+     *
+     * Note: mainly used to serialize for {@link FuzzyMatch}
      */
-    toJSON() {
-        return this.toArgs();
+    toElementals(filterLanguage) {
+        this._populateMetadata();
+        return Array.from(this._scopes.values())
+            .flat()
+            .flatMap((command) => {
+            const elements = [];
+            for (const [language, local] of command.languages.entries()) {
+                elements.push({
+                    name: local.name instanceof RegExp
+                        ? local.name.source
+                        : local.name,
+                    language,
+                    prefix: command.prefix,
+                    scopes: command.scopes,
+                    description: command.getLocalizedDescription(language),
+                });
+            }
+            if (filterLanguage) {
+                const filtered = elements.filter((command) => command.language === filterLanguage);
+                const defaulted = elements.filter((command) => command.language === "default");
+                return filtered.length ? filtered[0] : defaulted[0];
+            }
+            else
+                return elements;
+        });
     }
     /**
      * @returns A JSON serialized version of all the currently registered commands

package/out/context.d.ts

@@ -1,5 +1,5 @@
 import { Commands } from "./commands.js";
-import { Context, NextFunction } from "./deps.node.js";
+import { BotCommandScopeChat, Context, NextFunction } from "./deps.node.js";
 import { JaroWinklerOptions } from "./jaro-winkler.js";
 import { SetMyCommandsParams } from "./mod.js";
 export interface CommandsFlavor<C extends Context = Context> extends Context {
@@ -7,10 +7,25 @@ export interface CommandsFlavor<C extends Context = Context> extends Context {
      * Sets the provided commands for the current chat.
      * Cannot be called on updates that don't have a `chat` property.
      *
+     * [!IMPORTANT]
+     * Calling this method with upperCased command names registered, will throw
+     * @see https://core.telegram.org/bots/api#botcommand
+     * @see https://core.telegram.org/method/bots.setBotCommands
+     *
+     * @example
+     * ```typescript
+     *  bot.hears("sudo", (ctx) =>
+     *      ctx.setMyCommands(userCommands, adminCommands));
+     *  bot.hears("logout", (ctx) =>
+     *      ctx.setMyCommands(userCommands));
+     *  bot.hears("example", (ctx) =>
+     *      ctx.setMyCommands([aCommands, bCommands, cCommands]));
+     * ```
+     *
      * @param commands List of available commands
      * @returns Promise with the result of the operations
      */
-    setMyCommands: (commands: Commands<C>, ...moreCommands: Commands<C>[]) => Promise<void>;
+    setMyCommands: (commands: Commands<C> | Commands<C>[], ...moreCommands: Commands<C>[]) => Promise<void>;
     /**
      * Returns the nearest command to the user input.
      * If no command is found, returns `null`.
@@ -19,17 +34,70 @@ export interface CommandsFlavor<C extends Context = Context> extends Context {
      * @param options Options for the Jaro-Winkler algorithm
      * @returns The nearest command or `null`
      */
-    getNearestCommand: (commands: Commands<C>, options?: Partial<JaroWinklerOptions>) => string | null;
+    getNearestCommand: (commands: Commands<C> | Commands<C>[], options?: Omit<Partial<JaroWinklerOptions>, "language">) => string | null;
 }
 /**
  * Installs the commands flavor into the context.
  */
 export declare function commands<C extends Context>(): (ctx: CommandsFlavor<C>, next: NextFunction) => Promise<void>;
 /**
- * Iterates over an array of commands params, merging commands when two commandsParams
- * are from the same language.
- *
- * @param commandParams an array of commands params coming from multiple Commands instances
- * @returns an array containing all commands to be set on ctx
+ * Static class for getting and manipulating {@link SetMyCommandsParams}.
+ * The main function is {@link from}
  */
-export declare function _mergeMyCommandsParams(commandParams: SetMyCommandsParams[][]): SetMyCommandsParams[];
+export declare class MyCommandParams {
+    /**
+     * Merges and serialize one or more Commands instances into a single array
+     * of commands params that can be used to set the commands menu displayed to the user.
+     * @example
+        ```ts
+        const adminCommands = new Commands();
+        const userCommands = new Commands();
+        adminCommands
+            .command("do a",
+                     "a description",
+                     (ctx) => ctx.doA());
+        userCommands
+            .command("do b",
+                     "b description",
+                     (ctx) => ctx.doB());
+        const mergedParams =
+            MyCommandParams.from([a, b], someChatId);
+        ```
+     * @param commands An array of one or more Commands instances.
+     * @returns an array of {@link SetMyCommandsParams} grouped by language
+     */
+    static from<C extends Context>(commands: Commands<C>[], chat_id: BotCommandScopeChat["chat_id"]): SetMyCommandsParams[];
+    /**
+     * Serializes one or multiple {@link Commands} instances, each one into their respective
+     * single scoped SetMyCommandsParams version.
+     * @example
+        ```ts
+        const adminCommands = new Commands();
+        // add to scope, localize, etc
+        const userCommands = new Commands();
+        // 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: Commands<C>[], chat_id: BotCommandScopeChat["chat_id"]): SetMyCommandsParams[][];
+    /**
+     * 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.
+     *
+     * @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;
+}

package/out/context.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._mergeMyCommandsParams = exports.commands = void 0;
+exports.MyCommandParams = exports.commands = void 0;
 const jaro_winkler_js_1 = require("./jaro-winkler.js");
+const utils_js_1 = require("./utils.js");
 /**
  * Installs the commands flavor into the context.
  */
@@ -11,19 +12,29 @@ function commands() {
             if (!ctx.chat) {
                 throw new Error("cannot call `ctx.setMyCommands` on an update with no `chat` property");
             }
-            const commandsParams = [commands].concat(moreCommands).map((commands) => commands.toSingleScopeArgs({
-                type: "chat",
-                chat_id: ctx.chat.id,
-            }));
-            const mergedCommands = _mergeMyCommandsParams(commandsParams);
-            await Promise.all(mergedCommands
+            commands = (0, utils_js_1.ensureArray)(commands).concat(moreCommands);
+            await Promise.all(MyCommandParams.from(commands, ctx.chat.id)
                 .map((args) => ctx.api.raw.setMyCommands(args)));
         };
         ctx.getNearestCommand = (commands, options) => {
             var _a;
             if ((_a = ctx.msg) === null || _a === void 0 ? void 0 : _a.text) {
-                const userInput = ctx.msg.text.substring(1);
-                return (0, jaro_winkler_js_1.fuzzyMatch)(userInput, commands, { ...options });
+                commands = (0, utils_js_1.ensureArray)(commands);
+                const results = commands.map((commands) => {
+                    var _a;
+                    const userInput = ctx.msg.text.substring(1);
+                    const result = (0, jaro_winkler_js_1.fuzzyMatch)(userInput, commands, {
+                        ...options,
+                        language: !(options === null || options === void 0 ? void 0 : options.ignoreLocalization)
+                            ? (_a = ctx.from) === null || _a === void 0 ? void 0 : _a.language_code
+                            : undefined,
+                    });
+                    return result;
+                }).sort((a, b) => { var _a, _b; return ((_a = b === null || b === void 0 ? void 0 : b.similarity) !== null && _a !== void 0 ? _a : 0) - ((_b = a === null || a === void 0 ? void 0 : a.similarity) !== null && _b !== void 0 ? _b : 0); });
+                const result = results[0];
+                if (!result || !result.command)
+                    return null;
+                return result.command.prefix + result.command.name;
             }
             return null;
         };
@@ -32,35 +43,96 @@ function commands() {
 }
 exports.commands = commands;
 /**
- * Iterates over an array of commands params, merging commands when two commandsParams
- * are from the same language.
- *
- * @param commandParams an array of commands params coming from multiple Commands instances
- * @returns an array containing all commands to be set on ctx
+ * Static class for getting and manipulating {@link SetMyCommandsParams}.
+ * The main function is {@link from}
  */
-function _mergeMyCommandsParams(commandParams) {
-    if (!commandParams.flat().length)
-        return [];
-    return commandParams
-        .flat()
-        .sort((a, b) => {
-        if (!a.language_code)
-            return -1;
-        if (!b.language_code)
-            return 1;
-        return a.language_code.localeCompare(b.language_code);
-    })
-        .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;
-        }
-    }, []);
+class MyCommandParams {
+    /**
+     * Merges and serialize one or more Commands instances into a single array
+     * of commands params that can be used to set the commands menu displayed to the user.
+     * @example
+        ```ts
+        const adminCommands = new Commands();
+        const userCommands = new Commands();
+        adminCommands
+            .command("do a",
+                     "a description",
+                     (ctx) => ctx.doA());
+        userCommands
+            .command("do b",
+                     "b description",
+                     (ctx) => ctx.doB());
+        const mergedParams =
+            MyCommandParams.from([a, b], someChatId);
+        ```
+     * @param commands An array of one or more Commands instances.
+     * @returns an array of {@link SetMyCommandsParams} grouped by language
+     */
+    static from(commands, chat_id) {
+        const commandsParams = this._serialize(commands, chat_id).flat();
+        if (!commandsParams.length)
+            return [];
+        return this.mergeByLanguage(commandsParams);
+    }
+    /**
+     * Serializes one or multiple {@link Commands} instances, each one into their respective
+     * single scoped SetMyCommandsParams version.
+     * @example
+        ```ts
+        const adminCommands = new Commands();
+        // add to scope, localize, etc
+        const userCommands = new Commands();
+        // 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.
+     *
+     * @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) {
+        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;
+            }
+        }, []);
+    }
 }
-exports._mergeMyCommandsParams = _mergeMyCommandsParams;
+exports.MyCommandParams = MyCommandParams;

package/out/deps.node.d.ts

@@ -1,2 +1,3 @@
 export { Api, Bot, type ChatTypeContext, type ChatTypeMiddleware, type CommandContext, type CommandMiddleware, Composer, Context, type Middleware, type MiddlewareObj, type NextFunction, } from "grammy";
-export type { BotCommand, BotCommandScope, BotCommandScopeAllChatAdministrators, BotCommandScopeAllGroupChats, BotCommandScopeAllPrivateChats, Chat, } from "grammy/types";
+export type { BotCommand, BotCommandScope, BotCommandScopeAllChatAdministrators, BotCommandScopeAllGroupChats, BotCommandScopeAllPrivateChats, BotCommandScopeChat, Chat, LanguageCode, } from "@grammyjs/types";
+export { LanguageCodes } from "@grammyjs/types";

package/out/deps.node.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = exports.Composer = exports.Bot = exports.Api = void 0;
+exports.LanguageCodes = exports.Context = exports.Composer = exports.Bot = exports.Api = void 0;
 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; } });
+var types_1 = require("@grammyjs/types");
+Object.defineProperty(exports, "LanguageCodes", { enumerable: true, get: function () { return types_1.LanguageCodes; } });

package/out/jaro-winkler.d.ts

@@ -1,9 +1,18 @@
 import { Commands } from "./commands.js";
-import { Context } from "./deps.node.js";
+import { Context, LanguageCode } from "./deps.node.js";
+import type { CommandElementals } from "./types.js";
 export declare function distance(s1: string, s2: string): number;
 export type JaroWinklerOptions = {
     ignoreCase?: boolean;
     similarityThreshold?: number;
+    language?: LanguageCode | string;
+    ignoreLocalization?: boolean;
 };
-export declare function JaroWinklerDistance(s1: string, s2: string, options: Partial<JaroWinklerOptions>): number;
-export declare function fuzzyMatch<C extends Context>(userInput: string, commands: Commands<C>, options: Partial<JaroWinklerOptions>): string | null;
+type CommandSimilarity = {
+    command: CommandElementals | null;
+    similarity: number;
+};
+export declare function JaroWinklerDistance(s1: string, s2: string, options: Pick<Partial<JaroWinklerOptions>, "ignoreCase">): number;
+export declare function isLanguageCode(value: string | undefined): value is LanguageCode;
+export declare function fuzzyMatch<C extends Context>(userInput: string, commands: Commands<C>, options: Partial<JaroWinklerOptions>): CommandSimilarity | null;
+export {};

package/out/jaro-winkler.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fuzzyMatch = exports.JaroWinklerDistance = exports.distance = void 0;
+exports.fuzzyMatch = exports.isLanguageCode = exports.JaroWinklerDistance = exports.distance = void 0;
+const deps_node_js_1 = require("./deps.node.js");
 function distance(s1, s2) {
     if (s1.length === 0 || s2.length === 0) {
         return 0;
@@ -87,23 +88,34 @@ function JaroWinklerDistance(s1, s2, options) {
     }
 }
 exports.JaroWinklerDistance = JaroWinklerDistance;
+function isLanguageCode(value) {
+    return Object.values(deps_node_js_1.LanguageCodes).includes(value);
+}
+exports.isLanguageCode = isLanguageCode;
 function fuzzyMatch(userInput, commands, options) {
-    const defaultSimilarityThreshold = 0.85;
+    var _a;
+    const defaultSimilarityThreshold = 0.82;
     const similarityThreshold = options.similarityThreshold ||
         defaultSimilarityThreshold;
-    const commandsSet = new Set(commands
-        .toJSON()
-        .flatMap((item) => item.commands.map((command) => command.command)));
-    const bestMatch = Array.from(commandsSet).reduce((best, command) => {
-        const similarity = JaroWinklerDistance(userInput, command, {
+    /**
+     * ctx.from.id is IETF
+     * https://en.wikipedia.org/wiki/IETF_language_tag
+     */
+    const possiblyISO639 = (_a = options.language) === null || _a === void 0 ? void 0 : _a.split("-")[0];
+    const language = isLanguageCode(possiblyISO639)
+        ? possiblyISO639
+        : undefined;
+    const cmds = options.ignoreLocalization
+        ? commands.toElementals()
+        : commands.toElementals(language);
+    const bestMatch = cmds.reduce((best, command) => {
+        const similarity = JaroWinklerDistance(userInput, command.name, {
             ...options,
         });
         return similarity > best.similarity
             ? { command, similarity }
             : best;
     }, { command: null, similarity: 0 });
-    return bestMatch.similarity > similarityThreshold
-        ? bestMatch.command
-        : null;
+    return bestMatch.similarity > similarityThreshold ? bestMatch : null;
 }
 exports.fuzzyMatch = fuzzyMatch;

package/out/types.d.ts

@@ -1,3 +1,4 @@
+import type { BotCommandScope, LanguageCode } from "./deps.node.js";
 /**
  * Supported command options
  */
@@ -22,3 +23,10 @@ export interface CommandOptions {
      */
     targetedCommands: "ignored" | "optional" | "required";
 }
+export interface CommandElementals {
+    name: string;
+    prefix: string;
+    language: LanguageCode | "default";
+    scopes: BotCommandScope[];
+    description: string;
+}

package/out/utils.d.ts

@@ -0,0 +1,2 @@
+export type MaybeArray<T> = T | T[];
+export declare const ensureArray: <T>(value: MaybeArray<T>) => T[];

package/out/utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureArray = void 0;
+const ensureArray = (value) => Array.isArray(value) ? value : [value];
+exports.ensureArray = ensureArray;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@grammyjs/commands",
-    "version": "0.7.0",
+    "version": "0.8.0",
     "description": "grammY Commands Plugin",
     "main": "out/mod.js",
     "scripts": {
@@ -16,6 +16,7 @@
     "author": "Roz <roz@rjmunhoz.me>",
     "license": "MIT",
     "dependencies": {
+        "@grammyjs/types": "^3.8.1",
         "grammy": "^1.17.1",
         "ts-pattern": "^5.0.1"
     },