gramio 0.0.19 → 0.0.20

package/dist/bot.d.ts

@@ -70,9 +70,13 @@ 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) => unknown): void;
+    command(command: string, handler: (context: ContextType<typeof this, "message"> & Derives["global"] & Derives["message"]) => unknown): void;
     start({ webhook, dropPendingUpdates, allowedUpdates, }?: {
         webhook?: Omit<APIMethodParams<"setWebhook">, "drop_pending_updates" | "allowed_updates">;
         dropPendingUpdates?: boolean;

package/dist/bot.js

@@ -79,14 +79,14 @@ 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];
+                (context) => {
+                    if (!context.params)
+                        return context;
+                    const formattable = format_1.FormattableMap[context.method];
                     // @ts-ignore add AnyTelegramMethod to @gramio/format
                     if (formattable)
-                        ctx.params = formattable(ctx.params);
-                    return ctx;
+                        context.params = formattable(context.params);
+                    return context;
                 },
             ],
             onError: [],
@@ -213,6 +213,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 +267,36 @@ let Bot = (() => {
             this.dependencies.push(plugin.name);
             return this;
         }
+        hears(trigger, handler) {
+            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))) {
+                    // TODO: remove
+                    //@ts-expect-error
+                    return handler(context);
+                }
+                return next();
+            });
+        }
+        command(command, handler) {
+            this.on("message", (context, next) => {
+                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}`, "");
+                    return cmd && cmd === command;
+                }))
+                    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/types.d.ts

@@ -14,17 +14,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.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gramio",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "description": "Powerful Telegram Bot API framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -26,8 +26,8 @@
   "devDependencies": {
     "@biomejs/biome": "1.5.3",
     "@gramio/types": "^7.1.6",
-    "@types/node": "^20.11.24",
-    "typescript": "^5.3.3"
+    "@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"