gramio 0.6.2 → 0.8.0

package/dist/index.js

@@ -9,10 +9,140 @@ export * from '@gramio/keyboards';
 import fs from 'node:fs/promises';
 import { Readable } from 'node:stream';
 import debug from 'debug';
-import { E as ErrorKind, w as withRetries, T as TelegramError, s as sleep, d as debug$updates, I as IS_BUN, a as simplifyObject, t as timeoutWebhook } from './utils-DqK73ALI.js';
+import { E as ErrorKind, w as withRetries, T as TelegramError, s as sleep, d as debug$updates, a as simpleHash, I as IS_BUN, b as simplifyObject, t as timeoutWebhook } from './utils-1ejkKLIB.js';
 import { defineComposerMethods, buildFromOptions, noopNext, createComposer, eventTypes, EventQueue } from '@gramio/composer';
 export { EventQueue, buildFromOptions, compose, noopNext, skip, stop } from '@gramio/composer';
 
+const ALL_NAMES = [
+  "message",
+  "edited_message",
+  "channel_post",
+  "edited_channel_post",
+  "business_connection",
+  "business_message",
+  "edited_business_message",
+  "deleted_business_messages",
+  "message_reaction",
+  "message_reaction_count",
+  "inline_query",
+  "chosen_inline_result",
+  "callback_query",
+  "shipping_query",
+  "pre_checkout_query",
+  "purchased_paid_media",
+  "poll",
+  "poll_answer",
+  "my_chat_member",
+  "chat_member",
+  "chat_join_request",
+  "chat_boost",
+  "removed_chat_boost"
+];
+const MESSAGE_PARENT_TYPES = [
+  "message",
+  "edited_message",
+  "channel_post",
+  "edited_channel_post",
+  "business_message"
+];
+const OPT_IN_TYPES = [
+  "chat_member",
+  "message_reaction",
+  "message_reaction_count"
+];
+const KNOWN_EVENTS = new Set(Object.keys(contextsMappings));
+const ALL_NAMES_SET = new Set(ALL_NAMES);
+function mapEventToAllowedUpdates(event) {
+  if (ALL_NAMES_SET.has(event)) return [event];
+  if (KNOWN_EVENTS.has(event)) return MESSAGE_PARENT_TYPES;
+  return void 0;
+}
+function detectOptInUpdates(registeredEvents) {
+  return OPT_IN_TYPES.filter((type) => registeredEvents.has(type));
+}
+class AllowedUpdatesFilter extends Array {
+  /** @internal use static factory methods instead */
+  constructor(updates) {
+    super(...updates);
+  }
+  /**
+   * All update types, including the opt-in ones:
+   * `chat_member`, `message_reaction`, and `message_reaction_count`.
+   */
+  static get all() {
+    return new AllowedUpdatesFilter(ALL_NAMES);
+  }
+  /**
+   * Telegram's **default** update set.
+   *
+   * Receive all updates _except_ `chat_member`, `message_reaction`, and
+   * `message_reaction_count` — the three types that Telegram requires to be
+   * explicitly listed in `allowed_updates`.
+   *
+   * This matches what Telegram does when `allowed_updates` is omitted or
+   * passed as an empty array.
+   */
+  static get default() {
+    return AllowedUpdatesFilter.all.except(
+      "chat_member",
+      "message_reaction",
+      "message_reaction_count"
+    );
+  }
+  /**
+   * Create a filter with **exactly** the specified update types.
+   *
+   * @example
+   * ```typescript
+   * AllowedUpdatesFilter.only("message", "callback_query", "inline_query")
+   * ```
+   */
+  static only(...types) {
+    return new AllowedUpdatesFilter(types);
+  }
+  /**
+   * Return a new filter with the given types **added**.
+   * Already-present types are silently deduplicated.
+   *
+   * @example
+   * ```typescript
+   * AllowedUpdatesFilter.default.add("chat_member", "message_reaction")
+   * ```
+   */
+  add(...types) {
+    const set = new Set(this);
+    for (const t of types) set.add(t);
+    return new AllowedUpdatesFilter([...set]);
+  }
+  /**
+   * Return a new filter with the given types **removed**.
+   *
+   * @example
+   * ```typescript
+   * AllowedUpdatesFilter.all.except("poll", "poll_answer", "chosen_inline_result")
+   * ```
+   */
+  except(...types) {
+    const excluded = new Set(types);
+    return new AllowedUpdatesFilter(
+      Array.from(this).filter((t) => !excluded.has(t))
+    );
+  }
+  /** Convert to a plain `AllowedUpdateName[]` array. */
+  toArray() {
+    return Array.from(this);
+  }
+}
+function buildAllowedUpdates(bot) {
+  const registeredEvents = bot.updates.composer.registeredEvents();
+  const allowedSet = /* @__PURE__ */ new Set();
+  for (const event of registeredEvents) {
+    const mapped = mapEventToAllowedUpdates(event);
+    if (mapped) for (const name of mapped) allowedSet.add(name);
+  }
+  return new AllowedUpdatesFilter([...allowedSet]);
+}
+
 const methods = defineComposerMethods({
   reaction(trigger, handler, macroOptions) {
     const reactions = Array.isArray(trigger) ? trigger : [trigger];
@@ -131,13 +261,32 @@ const methods = defineComposerMethods({
       return macroHandler ? macroHandler(context, noopNext) : handler(context);
     });
   },
-  command(command, handler, macroOptions) {
+  command(command, handlerOrMeta, handlerOrOptions, macroOptions) {
+    let handler;
+    let meta;
+    let resolvedMacroOptions;
+    if (typeof handlerOrMeta === "function") {
+      handler = handlerOrMeta;
+      resolvedMacroOptions = handlerOrOptions;
+    } else {
+      meta = handlerOrMeta;
+      handler = handlerOrOptions;
+      resolvedMacroOptions = macroOptions;
+    }
     const normalizedCommands = typeof command === "string" ? [command] : Array.from(command);
     for (const cmd of normalizedCommands) {
       if (cmd.startsWith("/"))
         throw new Error(`Do not use / in command name (${cmd})`);
     }
-    const macroHandler = macroOptions ? buildFromOptions(this["~"].macros, macroOptions, handler) : null;
+    if (meta) {
+      if (!this["~"].commandsMeta) {
+        this["~"].commandsMeta = /* @__PURE__ */ new Map();
+      }
+      for (const cmd of normalizedCommands) {
+        this["~"].commandsMeta.set(cmd, meta);
+      }
+    }
+    const macroHandler = resolvedMacroOptions ? buildFromOptions(this["~"].macros, resolvedMacroOptions, handler) : null;
     return this.on(["message", "business_message"], (context, next) => {
       const entity = context.entities?.find((entity2) => {
         if (entity2.type !== "bot_command" || entity2.offset > 0) return false;
@@ -184,6 +333,35 @@ const { Composer } = createComposer({
   types: eventTypes(),
   methods
 });
+if (typeof Composer.prototype.registeredEvents !== "function") {
+  Composer.prototype.registeredEvents = function() {
+    const events = /* @__PURE__ */ new Set();
+    for (const mw of this["~"].middlewares) {
+      if ((mw.type === "on" || mw.type === "derive") && mw.name) {
+        for (const part of mw.name.split("|")) {
+          const eventPart = part.includes(":") ? part.split(":")[0] : part;
+          if (eventPart) events.add(eventPart);
+        }
+      }
+    }
+    return events;
+  };
+}
+{
+  const originalExtend = Composer.prototype.extend;
+  Composer.prototype.extend = function(other) {
+    const result = originalExtend.call(this, other);
+    if (other["~"]?.commandsMeta) {
+      if (!this["~"].commandsMeta) {
+        this["~"].commandsMeta = /* @__PURE__ */ new Map();
+      }
+      for (const [cmd, meta] of other["~"].commandsMeta) {
+        this["~"].commandsMeta.set(cmd, meta);
+      }
+    }
+    return result;
+  };
+}
 
 class Plugin {
   /**
@@ -343,7 +521,7 @@ class Plugin {
    * import { Bot } from "gramio";
    *
    * const bot = new Bot(process.env.TOKEN!).onStart(
-   *     ({ plugins, info, updatesFrom }) => {
+   *     ({ plugins, info, updatesFrom, bot }) => {
    *         console.log(`plugin list - ${plugins.join(", ")}`);
    *         console.log(`bot username is @${info.username}`);
    * 		   console.log(`updates from ${updatesFrom}`);
@@ -367,7 +545,7 @@ class Plugin {
    * import { Bot } from "gramio";
    *
    * const bot = new Bot(process.env.TOKEN!).onStop(
-   *     ({ plugins, info, updatesFrom }) => {
+   *     ({ plugins, info, bot }) => {
    *         console.log(`plugin list - ${plugins.join(", ")}`);
    *         console.log(`bot username is @${info.username}`);
    *     }
@@ -796,7 +974,7 @@ class Bot {
    * import { Bot } from "gramio";
    *
    * const bot = new Bot(process.env.TOKEN!).onStart(
-   *     ({ plugins, info, updatesFrom }) => {
+   *     ({ plugins, info, updatesFrom, bot }) => {
    *         console.log(`plugin list - ${plugins.join(", ")}`);
    *         console.log(`bot username is @${info.username}`);
    * 		   console.log(`updates from ${updatesFrom}`);
@@ -820,7 +998,7 @@ class Bot {
    * import { Bot } from "gramio";
    *
    * const bot = new Bot(process.env.TOKEN!).onStop(
-   *     ({ plugins, info, updatesFrom }) => {
+   *     ({ plugins, info, bot }) => {
    *         console.log(`plugin list - ${plugins.join(", ")}`);
    *         console.log(`bot username is @${info.username}`);
    *     }
@@ -1087,18 +1265,8 @@ class Bot {
     this.updates.composer.hears(trigger, handler, options);
     return this;
   }
-  /**
-   * Register handler to `message` and `business_message` event when entities contains a command
-   *
-   * @example
-   * ```ts
-   * new Bot().command("start", async (context) => {
-   *     return context.send(`You message is /start ${context.args}`);
-   * });
-   * ```
-   */
-  command(command, handler, options) {
-    this.updates.composer.command(command, handler, options);
+  command(command, handlerOrMeta, handlerOrOptions, macroOptions) {
+    this.updates.composer.command(command, handlerOrMeta, handlerOrOptions, macroOptions);
     return this;
   }
   /**
@@ -1123,6 +1291,96 @@ class Bot {
   group(grouped) {
     return grouped(this);
   }
+  /**
+   * Sync registered command metadata with the Telegram API.
+   *
+   * Groups commands by `{scope, language_code}` and calls `setMyCommands` for each group.
+   * When a `storage` is provided, hashes each payload and skips unchanged groups.
+   *
+   * @example
+   * ```ts
+   * bot.onStart(() => bot.syncCommands());
+   * ```
+   */
+  async syncCommands(options) {
+    const commandsMeta = this.updates.composer["~"].commandsMeta ?? /* @__PURE__ */ new Map();
+    if (commandsMeta.size === 0) return;
+    const storage = options?.storage;
+    const botId = this.info?.id;
+    const excludeSet = options?.exclude ? new Set(options.exclude) : void 0;
+    const groups = /* @__PURE__ */ new Map();
+    const getOrCreateGroup = (scope, langCode) => {
+      const key = `${JSON.stringify(scope ?? { type: "default" })}:${langCode}`;
+      let group = groups.get(key);
+      if (!group) {
+        group = { scope, language_code: langCode || void 0, commands: [] };
+        groups.set(key, group);
+      }
+      return group;
+    };
+    for (const [name, meta] of commandsMeta) {
+      if (meta.hide) continue;
+      if (excludeSet?.has(name)) continue;
+      const scopes = meta.scopes ? meta.scopes.map(
+        (s) => typeof s === "string" ? { type: s } : s
+      ) : [void 0];
+      for (const scope of scopes) {
+        getOrCreateGroup(scope, "").commands.push({
+          command: name,
+          description: meta.description
+        });
+        if (meta.locales) {
+          for (const [lang, desc] of Object.entries(meta.locales)) {
+            getOrCreateGroup(scope, lang).commands.push({
+              command: name,
+              description: desc
+            });
+          }
+        }
+      }
+    }
+    for (const [key, group] of groups) {
+      if (group.commands.length > 100) {
+        throw new Error(
+          `Too many commands (${group.commands.length}) for scope ${key}. Telegram allows max 100 per scope+language.`
+        );
+      }
+    }
+    for (const [, group] of groups) {
+      const payload = {
+        commands: group.commands,
+        scope: group.scope,
+        language_code: group.language_code
+      };
+      if (storage) {
+        const hash = simpleHash(JSON.stringify(payload));
+        const storageKey = `gramio:commands:${botId ?? "unknown"}:${JSON.stringify(group.scope ?? { type: "default" })}:${group.language_code ?? ""}`;
+        const stored = await storage.get(storageKey);
+        if (stored === hash) continue;
+        await this.api.setMyCommands(payload);
+        await storage.set(storageKey, hash);
+      } else {
+        await this.api.setMyCommands(payload);
+      }
+    }
+    if (options?.cleanUnusedScopes) {
+      const declaredScopes = /* @__PURE__ */ new Set();
+      for (const [, group] of groups) {
+        declaredScopes.add(JSON.stringify(group.scope ?? { type: "default" }));
+      }
+      const allScopes = [
+        { type: "default" },
+        { type: "all_private_chats" },
+        { type: "all_group_chats" },
+        { type: "all_chat_administrators" }
+      ];
+      for (const scope of allScopes) {
+        if (!declaredScopes.has(JSON.stringify(scope))) {
+          await this.api.deleteMyCommands({ scope });
+        }
+      }
+    }
+  }
   /**
    * Init bot. Call it manually only if you doesn't use {@link Bot.start}
    */
@@ -1161,10 +1419,21 @@ class Bot {
     webhook,
     longPolling,
     dropPendingUpdates,
-    allowedUpdates,
+    allowedUpdates: allowedUpdatesRaw,
     deleteWebhook: deleteWebhookRaw
   } = {}) {
     await this.init();
+    let allowedUpdates;
+    if (allowedUpdatesRaw === "strict") {
+      allowedUpdates = buildAllowedUpdates(this);
+    } else if (allowedUpdatesRaw === void 0) {
+      const optIn = detectOptInUpdates(
+        this.updates.composer.registeredEvents()
+      );
+      allowedUpdates = optIn.length > 0 ? AllowedUpdatesFilter.default.add(...optIn) : void 0;
+    } else {
+      allowedUpdates = allowedUpdatesRaw;
+    }
     const deleteWebhook = deleteWebhookRaw ?? "on-conflict-with-polling";
     if (!webhook) {
       if (deleteWebhook === true)
@@ -1187,7 +1456,8 @@ class Bot {
         plugins: this.dependencies,
         // biome-ignore lint/style/noNonNullAssertion: bot.init() guarantees this.info
         info: this.info,
-        updatesFrom: "long-polling"
+        updatesFrom: "long-polling",
+        bot: this
       });
       return this.info;
     }
@@ -1205,7 +1475,8 @@ class Bot {
       plugins: this.dependencies,
       // biome-ignore lint/style/noNonNullAssertion: bot.init() guarantees this.info
       info: this.info,
-      updatesFrom: "webhook"
+      updatesFrom: "webhook",
+      bot: this
     });
     return this.info;
   }
@@ -1222,7 +1493,8 @@ class Bot {
     await this.runImmutableHooks("onStop", {
       plugins: this.dependencies,
       // biome-ignore lint/style/noNonNullAssertion: bot.init() guarantees this.info
-      info: this.info
+      info: this.info,
+      bot: this
     });
   }
 }
@@ -1511,4 +1783,4 @@ function webhookHandler(bot, framework, secretTokenOrOptions) {
 
 Symbol.metadata ??= Symbol("Symbol.metadata");
 
-export { Bot, Composer, ErrorKind, Plugin, TelegramError, Updates, filters, webhookHandler };
+export { AllowedUpdatesFilter, Bot, Composer, ErrorKind, OPT_IN_TYPES, Plugin, TelegramError, Updates, buildAllowedUpdates, detectOptInUpdates, filters, mapEventToAllowedUpdates, webhookHandler };

package/dist/{utils-DqK73ALI.js → utils-1ejkKLIB.js}

@@ -48,6 +48,13 @@ function simplifyObject(obj) {
 const IS_BUN = typeof Bun !== "undefined";
 debug("gramio:api");
 const debug$updates = debug("gramio:updates");
+function simpleHash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i) | 0;
+  }
+  return (hash >>> 0).toString(36);
+}
 function timeoutWebhook(task, timeout, mode) {
   return new Promise((resolve, reject) => {
     const timeoutTask = setTimeout(() => {
@@ -86,4 +93,4 @@ async function withRetries(resultPromise) {
   return state.value;
 }
 
-export { ErrorKind as E, IS_BUN as I, TelegramError as T, simplifyObject as a, debug$updates as d, sleep as s, timeoutWebhook as t, withRetries as w };
+export { ErrorKind as E, IS_BUN as I, TelegramError as T, simpleHash as a, simplifyObject as b, debug$updates as d, sleep as s, timeoutWebhook as t, withRetries as w };

package/dist/{utils-DCXj-tb5.cjs → utils-BKLnNOBm.cjs}

@@ -50,6 +50,13 @@ function simplifyObject(obj) {
 const IS_BUN = typeof Bun !== "undefined";
 debug("gramio:api");
 const debug$updates = debug("gramio:updates");
+function simpleHash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i) | 0;
+  }
+  return (hash >>> 0).toString(36);
+}
 function timeoutWebhook(task, timeout, mode) {
   return new Promise((resolve, reject) => {
     const timeoutTask = setTimeout(() => {
@@ -92,6 +99,7 @@ exports.ErrorKind = ErrorKind;
 exports.IS_BUN = IS_BUN;
 exports.TelegramError = TelegramError;
 exports.debug$updates = debug$updates;
+exports.simpleHash = simpleHash;
 exports.simplifyObject = simplifyObject;
 exports.sleep = sleep;
 exports.timeoutWebhook = timeoutWebhook;

package/dist/utils.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var utils = require('./utils-DCXj-tb5.cjs');
+var utils = require('./utils-BKLnNOBm.cjs');
 require('debug');
 
 

package/dist/utils.js

@@ -1,2 +1,2 @@
-export { w as withRetries } from './utils-DqK73ALI.js';
+export { w as withRetries } from './utils-1ejkKLIB.js';
 import 'debug';

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "gramio",
 	"type": "module",
-	"version": "0.6.2",
+	"version": "0.8.0",
 	"description": "Powerful, extensible and really type-safe Telegram Bot API framework",
 	"main": "dist/index.cjs",
 	"module": "dist/index.js",
@@ -65,12 +65,12 @@
 	},
 	"dependencies": {
 		"@gramio/callback-data": "^0.1.0",
-		"@gramio/composer": "^0.3.3",
-		"@gramio/contexts": "^0.4.0",
-		"@gramio/files": "^0.3.1",
-		"@gramio/format": "^0.4.0",
-		"@gramio/keyboards": "^1.3.0",
-		"@gramio/types": "^9.4.2",
+		"@gramio/composer": "^0.4.0",
+		"@gramio/contexts": "^0.5.0",
+		"@gramio/files": "^0.3.2",
+		"@gramio/format": "^0.5.0",
+		"@gramio/keyboards": "^1.3.1",
+		"@gramio/types": "^9.5.0",
 		"debug": "^4.4.3"
 	},
 	"files": [