gramio 0.0.12 → 0.0.13

package/dist/bot.d.ts

@@ -1,4 +1,4 @@
-import { Context } from "@gramio/contexts";
+import { Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
 import type { APIMethods } from "@gramio/types";
 import "reflect-metadata";
 import { Plugin } from "#plugin";
@@ -53,13 +53,15 @@ export declare class Bot<Errors extends ErrorDefinitions = {}, Derives = {}> {
      * Set error handler.
      * @example
      * ```ts
-     * bot.updates.onError(({ context, kind, error }) => {
-     * 	if(context.is("message")) return context.send(`${kind}: ${error.message}`);
+     * bot.onError("message", ({ context, kind, error }) => {
+     * 	return context.send(`${kind}: ${error.message}`);
      * })
      * ```
      */
+    onError<T extends UpdateName>(updateName: MaybeArray<T>, handler: Hooks.OnError<Errors, ContextType<typeof this, T>>): this;
     onError(handler: Hooks.OnError<Errors>): this;
-    derive<Handler extends (context: Context) => object>(handler: Handler): Bot<Errors, Derives & ReturnType<Handler>>;
-    use(handler: Handler<Context & Derives>): this;
+    derive<Handler extends (context: Context<typeof this>) => object>(handler: Handler): Bot<Errors, Derives & ReturnType<Handler>>;
+    on<T extends UpdateName>(updateName: MaybeArray<T>, handler: Handler<ContextType<typeof this, T> & Derives>): this;
+    use(handler: Handler<Context<typeof this> & Derives>): this;
     extend<NewPlugin extends Plugin>(plugin: NewPlugin): Bot<Errors & NewPlugin["Errors"], Derives & NewPlugin["Derives"]>;
 }

package/dist/bot.js

@@ -130,17 +130,19 @@ let Bot = class Bot {
         this.errorsDefinitions[kind] = error;
         return this;
     }
-    /**
-     * Set error handler.
-     * @example
-     * ```ts
-     * bot.updates.onError(({ context, kind, error }) => {
-     * 	if(context.is("message")) return context.send(`${kind}: ${error.message}`);
-     * })
-     * ```
-     */
-    onError(handler) {
-        this.hooks.onError.push(handler);
+    onError(updateNameOrHandler, handler) {
+        if (typeof updateNameOrHandler === "function") {
+            this.hooks.onError.push(updateNameOrHandler);
+            return this;
+        }
+        if (handler) {
+            this.hooks.onError.push(async (errContext) => {
+                if (errContext.context.is(updateNameOrHandler))
+                    // TODO:  Sorry... fix later
+                    //@ts-expect-error
+                    await handler(errContext);
+            });
+        }
         return this;
     }
     derive(handler) {
@@ -152,6 +154,10 @@ let Bot = class Bot {
         });
         return this;
     }
+    on(updateName, handler) {
+        this.updates.on(updateName, handler);
+        return this;
+    }
     use(handler) {
         this.updates.use(handler);
         return this;

package/dist/plugin.d.ts

@@ -1,9 +1,9 @@
-import { Context } from "@gramio/contexts";
+import { BotLike, Context } from "@gramio/contexts";
 import { ErrorDefinitions } from "types";
 export declare class Plugin<Errors extends ErrorDefinitions = {}, Derives = {}> {
     Errors: Errors;
     Derives: Derives;
-    derives: ((context: Context) => object)[];
+    derives: ((context: Context<BotLike>) => object)[];
     name: string;
     errorsDefinitions: Record<string, {
         new (...args: any): any;
@@ -17,5 +17,5 @@ export declare class Plugin<Errors extends ErrorDefinitions = {}, Derives = {}>
         new (...args: any): any;
         prototype: Error;
     }>(kind: Name, error: NewError): Plugin<Errors & { [name in Name]: InstanceType<NewError>; }, {}>;
-    derive<Handler extends (context: Context) => object>(handler: Handler): Plugin<Errors, Derives & ReturnType<Handler>>;
+    derive<Handler extends (context: Context<BotLike>) => object>(handler: Handler): Plugin<Errors, Derives & ReturnType<Handler>>;
 }

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { Context } from "@gramio/contexts";
+import { BotLike, Context } from "@gramio/contexts";
 import { APIMethodParams, APIMethods } from "@gramio/types";
 import { NextMiddleware } from "middleware-io";
 import { TelegramError } from "./errors";
@@ -6,8 +6,8 @@ export interface BotOptions {
     token?: string;
 }
 export type Handler<T> = (context: T, next: NextMiddleware) => unknown;
-interface ErrorHandlerParams<Kind extends string, Err> {
-    context: Context;
+interface ErrorHandlerParams<Ctx extends Context<BotLike>, Kind extends string, Err> {
+    context: Ctx;
     kind: Kind;
     error: Err;
 }
@@ -24,10 +24,10 @@ type MaybePromise<T> = T | Promise<T>;
 export declare namespace Hooks {
     type PreRequestContext = AnyTelegramMethod;
     type PreRequest = (ctx: PreRequestContext) => MaybePromise<PreRequestContext>;
-    type OnErrorContext<T extends ErrorDefinitions> = ErrorHandlerParams<"TELEGRAM", AnyTelegramError> | ErrorHandlerParams<"UNKNOWN", Error> | {
-        [K in keyof T]: ErrorHandlerParams<K & string, T[K & string]>;
+    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];
-    type OnError<T extends ErrorDefinitions> = (options: OnErrorContext<T>) => unknown;
+    type OnError<T extends ErrorDefinitions, Ctx extends Context<BotLike> = Context<BotLike>> = (options: OnErrorContext<Ctx, T>) => unknown;
     interface Store<T extends ErrorDefinitions> {
         preRequest: PreRequest[];
         onError: OnError<T>[];

package/dist/updates.d.ts

@@ -1,4 +1,4 @@
-import { Context, UpdateName, contextsMappings } from "@gramio/contexts";
+import { Context, MaybeArray, UpdateName } from "@gramio/contexts";
 import type { TelegramUpdate } from "@gramio/types";
 import { CaughtMiddlewareHandler } from "middleware-io";
 import type { Bot } from "./bot";
@@ -9,9 +9,9 @@ export declare class Updates {
     private offset;
     private composer;
     private onError;
-    constructor(bot: Bot<any, any>, onError: CaughtMiddlewareHandler<Context>);
-    on<T extends UpdateName>(updateName: T, handler: Handler<InstanceType<(typeof contextsMappings)[T]>>): this;
-    use(handler: Handler<Context & any>): this;
+    constructor(bot: Bot<any, any>, onError: CaughtMiddlewareHandler<Context<any>>);
+    on<T extends UpdateName>(updateName: MaybeArray<T>, handler: Handler<any>): this;
+    use(handler: Handler<any>): this;
     handleUpdate(data: TelegramUpdate): Promise<void>;
     startPolling(): Promise<void>;
     startFetchLoop(): Promise<void>;

package/dist/updates.js

@@ -13,6 +13,7 @@ class Updates {
         this.bot = bot;
         this.onError = onError;
     }
+    //TODO: FIX
     on(updateName, handler) {
         return this.use(async (context, next) => {
             //TODO: fix typings
@@ -34,7 +35,6 @@ class Updates {
             return;
         try {
             let context = new UpdateContext({
-                //@ts-expect-error
                 bot: this.bot,
                 update: data,
                 //@ts-expect-error
@@ -44,7 +44,6 @@ class Updates {
             });
             if ("isEvent" in context && context.isEvent() && context.eventType) {
                 context = new contexts_1.contextsMappings[context.eventType]({
-                    //@ts-expect-error
                     bot: this.bot,
                     update: data,
                     //@ts-expect-error

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gramio",
-    "version": "0.0.12",
+    "version": "0.0.13",
     "description": "WIP",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -19,7 +19,7 @@
         "typescript": "^5.3.3"
     },
     "dependencies": {
-        "@gramio/contexts": "^0.0.2",
+        "@gramio/contexts": "^0.0.4",
         "@gramio/files": "^0.0.3",
         "@gramio/format": "^0.0.8",
         "@gramio/keyboards": "^0.1.6",