gramio 0.0.19 → 0.0.21

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;
@@ -70,9 +71,17 @@ export declare class Bot<Errors extends ErrorDefinitions = {}, Derives extends D
         [K in Update]: Awaited<ReturnType<Handler>>;
     }>;
     onStart(handler: Hooks.OnStart): this;
+    preRequest<Methods extends keyof APIMethods, Handler extends Hooks.PreRequest<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;
+    preRequest(handler: Hooks.PreRequest): this;
     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 & {
+        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;
     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: [
-                (ctx) => {
-                    if (!ctx.params)
-                        return ctx;
-                    const formattable = format_1.FormattableMap[ctx.method];
-                    // @ts-ignore add AnyTelegramMethod to @gramio/format
-                    if (formattable)
-                        ctx.params = formattable(ctx.params);
-                    return ctx;
-                },
-            ],
+            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;
@@ -213,6 +217,29 @@ let Bot = (() => {
             this.hooks.onStart.push(handler);
             return this;
         }
+        preRequest(methodsOrHandler, handler) {
+            if (typeof methodsOrHandler === "string" ||
+                Array.isArray(methodsOrHandler)) {
+                // TODO: error
+                if (!handler)
+                    throw new Error("TODO:");
+                const methods = typeof methodsOrHandler === "string"
+                    ? [methodsOrHandler]
+                    : methodsOrHandler;
+                // TODO: remove error
+                // @ts-expect-error
+                this.hooks.preRequest.push(async (context) => {
+                    // TODO: remove ts-ignore
+                    // @ts-expect-error
+                    if (methods.includes(context.method))
+                        return handler(context);
+                    return context;
+                });
+            }
+            else
+                this.hooks.preRequest.push(methodsOrHandler);
+            return this;
+        }
         on(updateName, handler) {
             this.updates.on(updateName, handler);
             return this;
@@ -244,6 +271,45 @@ let Bot = (() => {
             this.dependencies.push(plugin.name);
             return this;
         }
+        hears(trigger, handler) {
+            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);
+                }
+                return 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;
+                    const cmd = context.text
+                        ?.slice(1, entity.length)
+                        // biome-ignore lint/style/noNonNullAssertion: <explanation>
+                        ?.replace(`@${this.info.username}`, "");
+                    // @ts-expect-error
+                    context.args = context.text?.slice(entity.length).trim() || null;
+                    return cmd?.startsWith(command);
+                }))
+                    // @ts-expect-error
+                    return handler(context);
+                return next();
+            });
+        }
         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,14 @@
-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";
 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
+    ][];
     name: string;
     errorsDefinitions: Record<string, {
         new (...args: any): any;
@@ -26,4 +31,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,7 @@ let Plugin = (() => {
         Errors;
         Derives;
         derives = [];
+        preRequests = [];
         name;
         errorsDefinitions = {};
         dependencies = [];
@@ -78,12 +79,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> {
@@ -14,17 +17,17 @@ interface ErrorHandlerParams<Ctx extends Context<BotLike>, Kind extends string,
 type AnyTelegramError = {
     [APIMethod in keyof APIMethods]: TelegramError<APIMethod>;
 }[keyof APIMethods];
-type AnyTelegramMethod = {
-    [APIMethod in keyof APIMethods]: {
+type AnyTelegramMethod<Methods extends keyof APIMethods> = {
+    [APIMethod in Methods]: {
         method: APIMethod;
         params: APIMethodParams<APIMethod>;
     };
-}[keyof APIMethods];
+}[Methods];
 export type MaybePromise<T> = Promise<T> | T;
 export declare namespace Hooks {
     type Derive<Ctx> = (context: Ctx) => MaybePromise<Record<string, unknown>>;
-    type PreRequestContext = AnyTelegramMethod;
-    type PreRequest = (ctx: PreRequestContext) => MaybePromise<PreRequestContext>;
+    type PreRequestContext<Methods extends keyof APIMethods> = AnyTelegramMethod<Methods>;
+    type PreRequest<Methods extends keyof APIMethods = keyof APIMethods> = (ctx: PreRequestContext<Methods>) => MaybePromise<PreRequestContext<Methods>>;
     type OnErrorContext<Ctx extends Context<BotLike>, T extends ErrorDefinitions> = ErrorHandlerParams<Ctx, "TELEGRAM", AnyTelegramError> | ErrorHandlerParams<Ctx, "UNKNOWN", Error> | {
         [K in keyof T]: ErrorHandlerParams<Ctx, K & string, T[K & string]>;
     }[keyof T];

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/updates.js

@@ -32,7 +32,7 @@ class Updates {
         this.offset = data.update_id + 1;
         const UpdateContext = contexts_1.contextsMappings[updateType];
         if (!UpdateContext)
-            return;
+            throw new Error(updateType);
         try {
             let context = new UpdateContext({
                 bot: this.bot,
@@ -74,8 +74,8 @@ class Updates {
     async startFetchLoop(params = {}) {
         while (this.isStarted) {
             const updates = await this.bot.api.getUpdates({
-                offset: this.offset,
                 ...params,
+                offset: this.offset,
             });
             for await (const update of updates) {
                 //TODO: update errors

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.19",
+  "version": "0.0.21",
   "description": "Powerful Telegram Bot API framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -24,10 +24,10 @@
   "author": "kravets",
   "license": "ISC",
   "devDependencies": {
-    "@biomejs/biome": "1.5.3",
-    "@gramio/types": "^7.1.6",
-    "@types/node": "^20.11.24",
-    "typescript": "^5.3.3"
+    "@biomejs/biome": "1.6.0",
+    "@gramio/types": "^7.1.7",
+    "@types/node": "^20.11.25",
+    "typescript": "^5.4.2"
   },
   "dependencies": {
     "@gramio/contexts": "^0.0.7",
@@ -36,7 +36,7 @@
     "@gramio/keyboards": "^0.2.0",
     "inspectable": "^3.0.0",
     "middleware-io": "^2.8.1",
-    "undici": "^6.6.2"
+    "undici": "^6.7.1"
   },
   "files": [
     "dist"