@grammyjs/commands 1.0.8 → 1.1.0

package/out/command-group.d.ts

@@ -1,5 +1,5 @@
 import { Command, CommandsFlavor } from "./mod.js";
-import { Api, BotCommand, BotCommandScope, CommandContext, Context, type LanguageCode, Middleware } from "./deps.node.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";
@@ -83,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[];
     };

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)),
                     });

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

@@ -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/package.json

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