gramio 0.0.20 → 0.0.22

package/dist/bot.d.ts

@@ -1,9 +1,10 @@
-import { Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
-import type { APIMethodParams, APIMethods, TelegramUser } from "@gramio/types";
+import type { Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
+import type { APIMethodParams, APIMethods, SetMyCommandsParams, TelegramBotCommand, TelegramUser } from "@gramio/types";
 import { Plugin } from "./plugin";
-import { BotOptions, DeriveDefinitions, ErrorDefinitions, Handler, Hooks, MaybePromise } from "./types";
+import type { BotOptions, DeriveDefinitions, ErrorDefinitions, Handler, Hooks, MaybePromise } from "./types";
 import { Updates } from "./updates";
 export declare class Bot<Errors extends ErrorDefinitions = {}, Derives extends DeriveDefinitions = DeriveDefinitions> {
+    /** @internal */
     __Derives: Derives;
     readonly options: BotOptions;
     info: TelegramUser | undefined;
@@ -75,8 +76,14 @@ export declare class Bot<Errors extends ErrorDefinitions = {}, Derives extends D
     on<T extends UpdateName>(updateName: MaybeArray<T>, handler: Handler<ContextType<typeof this, T> & Derives["global"] & Derives[T]>): this;
     use(handler: Handler<Context<typeof this> & Derives["global"]>): this;
     extend<NewPlugin extends Plugin>(plugin: MaybePromise<NewPlugin>): Bot<Errors & NewPlugin["Errors"], Derives & NewPlugin["Derives"]>;
-    hears<Ctx = ContextType<typeof this, "message"> & Derives["global"] & Derives["message"]>(trigger: RegExp | string | ((context: Ctx) => boolean), handler: (context: Ctx) => unknown): void;
-    command(command: string, handler: (context: ContextType<typeof this, "message"> & Derives["global"] & Derives["message"]) => unknown): void;
+    hears<Ctx = ContextType<typeof this, "message"> & Derives["global"] & Derives["message"]>(trigger: RegExp | string | ((context: Ctx) => boolean), handler: (context: Ctx & {
+        args: RegExpMatchArray | null;
+    }) => unknown): this;
+    command(command: string, handler: (context: ContextType<typeof this, "message"> & Derives["global"] & Derives["message"] & {
+        args: string | null;
+    }) => unknown, options?: Omit<SetMyCommandsParams, "commands"> & Omit<TelegramBotCommand, "command">): this;
+    /** Currently not isolated!!! */
+    group(grouped: (bot: typeof this) => Bot<any, any>): Bot<any, any>;
     start({ webhook, dropPendingUpdates, allowedUpdates, }?: {
         webhook?: Omit<APIMethodParams<"setWebhook">, "drop_pending_updates" | "allowed_updates">;
         dropPendingUpdates?: boolean;

package/dist/bot.js

@@ -39,6 +39,7 @@ const files_1 = require("@gramio/files");
 const format_1 = require("@gramio/format");
 const inspectable_1 = require("inspectable");
 const undici_1 = require("undici");
+const _plugin_1 = require("./plugin");
 const errors_1 = require("./errors");
 const updates_1 = require("./updates");
 let Bot = (() => {
@@ -57,6 +58,7 @@ let Bot = (() => {
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
+        /** @internal */
         __Derives;
         options = {};
         info;
@@ -78,17 +80,7 @@ let Bot = (() => {
         }
         updates = new updates_1.Updates(this, this.errorHandler.bind(this));
         hooks = {
-            preRequest: [
-                (context) => {
-                    if (!context.params)
-                        return context;
-                    const formattable = format_1.FormattableMap[context.method];
-                    // @ts-ignore add AnyTelegramMethod to @gramio/format
-                    if (formattable)
-                        context.params = formattable(context.params);
-                    return context;
-                },
-            ],
+            preRequest: [],
             onError: [],
             onStart: [],
         };
@@ -96,6 +88,18 @@ let Bot = (() => {
             if (!token || typeof token !== "string")
                 throw new Error(`Token is ${typeof token} but it should be a string!`);
             this.options = { ...options, token };
+            if (!(options?.plugins &&
+                "format" in options.plugins &&
+                !options.plugins.format))
+                this.extend(new _plugin_1.Plugin("@gramio/format").preRequest((context) => {
+                    if (!context.params)
+                        return context;
+                    const formattable = format_1.FormattableMap[context.method];
+                    // @ts-ignore add AnyTelegramMethod to @gramio/format
+                    if (formattable)
+                        context.params = formattable(context.params);
+                    return context;
+                }));
         }
         async runHooks(type, context) {
             let data = context;
@@ -264,17 +268,30 @@ let Bot = (() => {
                 else
                     this.derive(updateName, derive);
             }
+            for (const value of plugin.preRequests) {
+                const [preRequest, updateName] = value;
+                if (!updateName)
+                    this.preRequest(preRequest);
+                else
+                    this.preRequest(updateName, preRequest);
+            }
+            for (const handler of plugin.groups) {
+                this.group(handler);
+            }
             this.dependencies.push(plugin.name);
             return this;
         }
         hears(trigger, handler) {
-            this.on("message", (context, next) => {
+            return this.on("message", (context, next) => {
                 if ((typeof trigger === "string" && context.text === trigger) ||
                     // @ts-expect-error
                     (typeof trigger === "function" && trigger(context)) ||
                     (trigger instanceof RegExp &&
                         context.text &&
                         trigger.test(context.text))) {
+                    //@ts-expect-error
+                    context.args =
+                        trigger instanceof RegExp ? context.text?.match(trigger) : null;
                     // TODO: remove
                     //@ts-expect-error
                     return handler(context);
@@ -282,8 +299,11 @@ let Bot = (() => {
                 return next();
             });
         }
-        command(command, handler) {
-            this.on("message", (context, next) => {
+        command(command, handler, options) {
+            if (command.startsWith("/"))
+                throw new Error("Do not use / in command name");
+            return this.on("message", (context, next) => {
+                // TODO: change to find
                 if (context.entities?.some((entity) => {
                     if (entity.type !== "bot_command" || entity.offset > 0)
                         return false;
@@ -291,12 +311,19 @@ let Bot = (() => {
                         ?.slice(1, entity.length)
                         // biome-ignore lint/style/noNonNullAssertion: <explanation>
                         ?.replace(`@${this.info.username}`, "");
-                    return cmd && cmd === command;
+                    // @ts-expect-error
+                    context.args = context.text?.slice(entity.length).trim() || null;
+                    return cmd?.startsWith(command);
                 }))
+                    // @ts-expect-error
                     return handler(context);
                 return next();
             });
         }
+        /** Currently not isolated!!! */
+        group(grouped) {
+            return grouped(this);
+        }
         async start({ webhook, dropPendingUpdates, allowedUpdates, } = {}) {
             await Promise.all(this.lazyloadPlugins.map(async (plugin) => this.extend(await plugin)));
             this.info = await this.api.getMe();

package/dist/errors.d.ts

@@ -1,4 +1,4 @@
-import { APIMethodParams, APIMethods, TelegramAPIResponseError, TelegramResponseParameters } from "@gramio/types";
+import type { APIMethodParams, APIMethods, TelegramAPIResponseError, TelegramResponseParameters } from "@gramio/types";
 export declare const ErrorKind: unique symbol;
 export declare class TelegramError<T extends keyof APIMethods> extends Error {
     method: T;

package/dist/plugin.d.ts

@@ -1,9 +1,16 @@
-import { BotLike, Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
-import { DeriveDefinitions, ErrorDefinitions, Hooks } from "./types";
+import type { BotLike, Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
+import type { APIMethods } from "@gramio/types";
+import type { DeriveDefinitions, ErrorDefinitions, Hooks } from "./types";
+import type { Bot } from "./bot";
 export declare class Plugin<Errors extends ErrorDefinitions = {}, Derives extends DeriveDefinitions = DeriveDefinitions> {
     Errors: Errors;
     Derives: Derives;
-    derives: [Hooks.Derive<any>, UpdateName | undefined][];
+    derives: [Hooks.Derive<any>, MaybeArray<UpdateName> | undefined][];
+    preRequests: [
+        Hooks.PreRequest<any>,
+        MaybeArray<keyof APIMethods> | undefined
+    ][];
+    groups: ((bot: Bot<any, any>) => Bot<any, any>)[];
     name: string;
     errorsDefinitions: Record<string, {
         new (...args: any): any;
@@ -13,6 +20,8 @@ export declare class Plugin<Errors extends ErrorDefinitions = {}, Derives extend
     constructor(name: string, { dependencies }?: {
         dependencies?: string[];
     });
+    /** Currently not isolated!!! */
+    group(grouped: (bot: Bot<Errors, Derives>) => Bot<any, any>): this;
     /**
      * Register custom class-error in plugin
      **/
@@ -26,4 +35,6 @@ export declare class Plugin<Errors extends ErrorDefinitions = {}, Derives extend
     derive<Update extends UpdateName, Handler extends Hooks.Derive<ContextType<BotLike, Update>>>(updateName: MaybeArray<Update>, handler: Handler): Plugin<Errors, Derives & {
         [K in Update]: Awaited<ReturnType<Handler>>;
     }>;
+    preRequest<Methods extends keyof APIMethods, Handler extends Hooks.PreRequest<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;
+    preRequest(handler: Hooks.PreRequest): this;
 }

package/dist/plugin.js

@@ -60,6 +60,8 @@ let Plugin = (() => {
         Errors;
         Derives;
         derives = [];
+        preRequests = [];
+        groups = [];
         name;
         errorsDefinitions = {};
         dependencies = [];
@@ -68,6 +70,11 @@ let Plugin = (() => {
             if (dependencies)
                 this.dependencies = dependencies;
         }
+        /** Currently not isolated!!! */
+        group(grouped) {
+            this.groups.push(grouped);
+            return this;
+        }
         /**
          * Register custom class-error in plugin
          **/
@@ -78,12 +85,23 @@ let Plugin = (() => {
             return this;
         }
         derive(updateNameOrHandler, handler) {
-            if (typeof updateNameOrHandler === "string" && handler)
+            if ((typeof updateNameOrHandler === "string" ||
+                Array.isArray(updateNameOrHandler)) &&
+                handler)
                 this.derives.push([handler, updateNameOrHandler]);
             else if (typeof updateNameOrHandler === "function")
                 this.derives.push([updateNameOrHandler, undefined]);
             return this;
         }
+        preRequest(methodsOrHandler, handler) {
+            if ((typeof methodsOrHandler === "string" ||
+                Array.isArray(methodsOrHandler)) &&
+                handler)
+                this.preRequests.push([handler, methodsOrHandler]);
+            else if (typeof methodsOrHandler === "function")
+                this.preRequests.push([methodsOrHandler, undefined]);
+            return this;
+        }
     };
     return Plugin = _classThis;
 })();

package/dist/types.d.ts

@@ -1,9 +1,12 @@
-import { BotLike, Context, UpdateName } from "@gramio/contexts";
-import { APIMethodParams, APIMethods, TelegramUser } from "@gramio/types";
-import { NextMiddleware } from "middleware-io";
-import { TelegramError } from "./errors";
+import type { BotLike, Context, UpdateName } from "@gramio/contexts";
+import type { APIMethodParams, APIMethods, TelegramUser } from "@gramio/types";
+import type { NextMiddleware } from "middleware-io";
+import type { TelegramError } from "./errors";
 export interface BotOptions {
     token?: string;
+    plugins?: {
+        format?: boolean;
+    };
 }
 export type Handler<T> = (context: T, next: NextMiddleware) => unknown;
 interface ErrorHandlerParams<Ctx extends Context<BotLike>, Kind extends string, Err> {

package/dist/updates.d.ts

@@ -1,8 +1,8 @@
-import { Context, MaybeArray, UpdateName } from "@gramio/contexts";
+import { type Context, type MaybeArray, type UpdateName } from "@gramio/contexts";
 import type { APIMethodParams, TelegramUpdate } from "@gramio/types";
-import { CaughtMiddlewareHandler } from "middleware-io";
+import { type CaughtMiddlewareHandler } from "middleware-io";
 import type { Bot } from "./bot";
-import { Handler } from "./types";
+import type { Handler } from "./types";
 export declare class Updates {
     private readonly bot;
     isStarted: boolean;

package/dist/webhook/adapters.d.ts

@@ -1,5 +1,5 @@
-import { TelegramUpdate } from "@gramio/types";
-import { MaybePromise } from "../types";
+import type { TelegramUpdate } from "@gramio/types";
+import type { MaybePromise } from "../types";
 export interface FrameworkHandler {
     update: MaybePromise<TelegramUpdate>;
     header?: string;

package/dist/webhook/adapters.js

@@ -13,10 +13,10 @@ exports.frameworks = {
     }),
     hono: (c) => ({
         update: c.req.json(),
-        header: c.req.header(SECRET_TOKEN_HEADER)
+        header: c.req.header(SECRET_TOKEN_HEADER),
     }),
     express: (req) => ({
         update: req.body,
-        header: req.header(SECRET_TOKEN_HEADER)
-    })
+        header: req.header(SECRET_TOKEN_HEADER),
+    }),
 };

package/dist/webhook/index.d.ts

@@ -1,3 +1,3 @@
-import { Bot } from "../bot";
+import type { Bot } from "../bot";
 import { frameworks } from "./adapters";
 export declare function webhookHandler(bot: Bot, framework: keyof typeof frameworks): (...args: any[]) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gramio",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "Powerful Telegram Bot API framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -24,8 +24,8 @@
   "author": "kravets",
   "license": "ISC",
   "devDependencies": {
-    "@biomejs/biome": "1.5.3",
-    "@gramio/types": "^7.1.6",
+    "@biomejs/biome": "1.6.0",
+    "@gramio/types": "^7.1.7",
     "@types/node": "^20.11.25",
     "typescript": "^5.4.2"
   },