@mtkruto/node 0.1.112 → 0.1.113

package/script/5_client.d.ts

@@ -1,3 +1,4 @@
 export * from "./client/2_client_plain.js";
 export * from "./client/3_types.js";
-export * from "./client/4_client.js";
+export * from "./client/5_client.js";
+export * from "./client/6_composer.js";

package/script/5_client.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./client/2_client_plain.js"), exports);
 __exportStar(require("./client/3_types.js"), exports);
-__exportStar(require("./client/4_client.js"), exports);
+__exportStar(require("./client/5_client.js"), exports);
+__exportStar(require("./client/6_composer.js"), exports);

package/script/client/3_types.d.ts

@@ -37,7 +37,10 @@ export interface ClientParams extends ClientPlainParams {
      * Whether to automatically call `start` with no parameters in the first `invoke` call. Defaults to `true`.
      */
     autoStart?: boolean;
-    errorHandler?: (err: unknown, function_: types.Type | functions.Function<unknown>, n: number) => MaybePromise<boolean>;
+    /**
+     * Whether to use default handlers. Defaults to `true`.
+     */
+    defaultHandlers?: boolean;
 }
 export interface AnswerCallbackQueryParams {
     /** A text to be shown to the user. */
@@ -227,6 +230,10 @@ export type ConnectionState = "notConnected" | "updating" | "ready";
 export type AuthorizationState = {
     authorized: boolean;
 };
+export interface ReplyParams extends Omit<SendMessagesParams, "replyToMessageId"> {
+    /** Whether to quote the message that is to be replied. Enabled by default for non-private chats. */
+    quote?: boolean;
+}
 export type FilterableUpdates = "message" | "editedMessage" | "callbackQuery";
 export interface Update {
     message?: Message;
@@ -237,11 +244,18 @@ export interface Update {
     callbackQuery?: CallbackQuery;
     inlineQuery?: InlineQuery;
 }
-export type NextFn = () => Promise<void>;
-export interface Handler<U extends Partial<Update> = Partial<Update>> {
-    (update: U, next: NextFn): MaybePromise<void>;
+export type NextFn<T = void> = () => Promise<T>;
+export interface Handler<C> {
+    (ctx: C, next: NextFn): MaybePromise<void>;
+}
+export interface InvokeErrorHandler<C> {
+    (ctx: {
+        client: C;
+        error: unknown;
+        function: types.Type | functions.Function<unknown>;
+        n: number;
+    }, next: NextFn<boolean>): MaybePromise<boolean>;
 }
-export type FilterUpdate<U extends Update, T extends keyof U, F extends keyof NonNullable<U[T]>> = With<U, T> & Pick<{
-    [P in T]-?: With<NonNullable<U[T]>, F>;
+export type FilterUpdate<U extends Update, T extends keyof U, F extends (keyof NonNullable<U[T]>) | null> = With<U, T> & Pick<{
+    [P in T]-?: F extends keyof NonNullable<U[T]> ? With<NonNullable<U[T]>, F> : NonNullable<U[T]>;
 }, T>;
-export declare const skip: Handler;

package/script/client/3_types.js

@@ -1,5 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.skip = void 0;
-const skip = (__, _) => _();
-exports.skip = skip;

package/script/client/4_composer.d.ts

@@ -0,0 +1,22 @@
+import { FilterableUpdates, FilterUpdate, Update } from "./3_types.js";
+type MaybePromise<T> = T | Promise<T>;
+export type NextFunction = () => Promise<void>;
+export type MiddlewareFn<C extends Update = Update> = (ctx: C, next: NextFunction) => MaybePromise<unknown>;
+export interface MiddlewareObj<C extends Update = Update> {
+    middleware: () => MiddlewareFn<C>;
+}
+export type Middleware<C extends Update = Update> = MiddlewareFn<C> | MiddlewareObj<C>;
+export declare function flatten<C extends Update = Update>(mw: Middleware<C>): MiddlewareFn<C>;
+export declare function concat<C extends Update = Update>(left: MiddlewareFn<C>, right: MiddlewareFn<C>): MiddlewareFn<C>;
+export declare const skip: MiddlewareFn;
+export declare class Composer<C extends Update> implements MiddlewareObj<C> {
+    #private;
+    constructor(...middleware: Middleware<C>[]);
+    middleware(): MiddlewareFn<C>;
+    use(...middleware: Middleware<C>[]): Composer<C>;
+    branch(predicate: (ctx: C) => MaybePromise<boolean>, trueHandler_: Middleware<C>, falseHandler_: Middleware<C>): Composer<C>;
+    filter<D extends C>(predicate: (ctx: C) => ctx is D, ...middleware: Middleware<D>[]): Composer<D>;
+    filter(predicate: (ctx: C) => MaybePromise<boolean>, ...middleware: Middleware<C>[]): Composer<C>;
+    on<T extends keyof Update, F extends keyof NonNullable<Update[T]>>(filter: T extends FilterableUpdates ? T | [T, F, ...F[]] : T, ...middleawre: Middleware<FilterUpdate<C, T, F>>[]): Composer<FilterUpdate<C, T, F>>;
+}
+export {};

package/script/client/4_composer.js

@@ -0,0 +1,88 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Composer_handle;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Composer = exports.skip = exports.concat = exports.flatten = void 0;
+function flatten(mw) {
+    return typeof mw === "function" ? mw : (ctx, next) => mw.middleware()(ctx, next);
+}
+exports.flatten = flatten;
+function concat(left, right) {
+    return async (ctx, next) => {
+        let called = false;
+        await left(ctx, async () => {
+            if (called) {
+                return;
+            }
+            else {
+                called = true;
+                await right(ctx, next);
+            }
+        });
+    };
+}
+exports.concat = concat;
+const skip = (_ctx, next) => next();
+exports.skip = skip;
+class Composer {
+    constructor(...middleware) {
+        _Composer_handle.set(this, void 0);
+        __classPrivateFieldSet(this, _Composer_handle, middleware.length == 0 ? exports.skip : middleware.map(flatten).reduce(concat), "f");
+    }
+    middleware() {
+        return __classPrivateFieldGet(this, _Composer_handle, "f");
+    }
+    use(...middleware) {
+        const composer = new Composer(...middleware);
+        __classPrivateFieldSet(this, _Composer_handle, concat(__classPrivateFieldGet(this, _Composer_handle, "f"), flatten(composer)), "f");
+        return composer;
+    }
+    branch(predicate, trueHandler_, falseHandler_) {
+        const trueHandler = flatten(trueHandler_);
+        const falseHandler = flatten(falseHandler_);
+        return this.use(async (upd, next) => {
+            if (await predicate(upd)) {
+                await trueHandler(upd, next);
+            }
+            else {
+                await falseHandler(upd, next);
+            }
+        });
+    }
+    filter(predicate, ...middleware) {
+        return this.branch(predicate, middleware.length == 0 ? exports.skip : middleware.map(flatten).reduce(concat), exports.skip);
+    }
+    on(filter, ...middleawre) {
+        const type = typeof filter === "string" ? filter : filter[0];
+        const keys = Array.isArray(filter) ? filter.slice(1) : [];
+        return this.filter((ctx) => {
+            if (type in ctx) {
+                if (keys.length > 0) {
+                    for (const key of keys) {
+                        // deno-lint-ignore ban-ts-comment
+                        // @ts-ignore
+                        if (!(key in ctx[type])) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+            else {
+                return false;
+            }
+        }, ...middleawre);
+    }
+}
+exports.Composer = Composer;
+_Composer_handle = new WeakMap();

package/script/client/{4_client.d.ts → 5_client.d.ts}

@@ -2,19 +2,52 @@ import { MaybePromise } from "../1_utilities.js";
 import { functions, ReadObject, types } from "../2_tl.js";
 import { Storage } from "../3_storage.js";
 import { DC } from "../3_transport.js";
-import { BotCommand, ChatAction, ChatID, InlineQueryResult, Message, ParseMode, User } from "../3_types.js";
+import { BotCommand, CallbackQuery, ChatAction, ChatID, InlineQuery, InlineQueryResult, Message, ParseMode, User } from "../3_types.js";
 import { Migrate } from "../4_errors.js";
 import { With } from "./0_utilities.js";
 import { ClientAbstract } from "./1_client_abstract.js";
-import { AnswerCallbackQueryParams, AnswerInlineQueryParams, AuthorizeUserParams, ClientParams, DownloadParams, EditMessageParams, FilterableUpdates, FilterUpdate, ForwardMessagesParams, GetMyCommandsParams, Handler, SendMessagesParams, SendPollParams, SetMyCommandsParams, Update, UploadParams } from "./3_types.js";
+import { AnswerCallbackQueryParams, AnswerInlineQueryParams, AuthorizeUserParams, ClientParams, DownloadParams, EditMessageParams, FilterableUpdates, FilterUpdate, ForwardMessagesParams, GetMyCommandsParams, InvokeErrorHandler, ReplyParams, SendMessagesParams, SendPollParams, SetMyCommandsParams, Update, UploadParams } from "./3_types.js";
+import { Composer, Middleware } from "./4_composer.js";
 declare const getEntity: unique symbol;
 declare const getStickerSetName: unique symbol;
 export declare const handleMigrationError: unique symbol;
 declare const getMessageWithReply: unique symbol;
+export interface Context extends Update {
+    /** The client that received the update. */
+    client: Client;
+    /** Resolves to `ctx.message ?? ctx.editedMessage ?? ctx.callbackQuery?.message`. */
+    msg: undefined extends this["message"] ? undefined extends this["editedMessage"] ? undefined extends this["callbackQuery"] ? never : this["callbackQuery"] extends With<CallbackQuery, "message"> ? this["callbackQuery"]["message"] : this["callbackQuery"] extends With<CallbackQuery, "inlineMessageId"> ? never : (Message | undefined) : this["editedMessage"] : this["message"];
+    /** Resolves to `effectiveMessage?.chat`. */
+    chat: this["msg"] extends never ? never : this["msg"]["chat"];
+    /** Resolves to `(ctx.message ?? ctx.editedMessage)?.from ?? ctx.callbackQuery?.from ?? ctx.inlineQuery?.from`. */
+    from: this["message"] extends Message ? this["message"]["from"] : this["editedMessage"] extends Message ? this["editedMessage"]["from"] : this["callbackQuery"] extends CallbackQuery ? this["callbackQuery"]["from"] : this["inlineQuery"] extends InlineQuery ? this["inlineQuery"]["from"] : never;
+    /** Resolves to `effectiveMessage?.senderChat`. */
+    senderChat: this["msg"] extends never ? never : this["msg"]["senderChat"];
+    /** Reply the received message with a text message. */
+    reply: (text: string, params?: ReplyParams) => Promise<With<Message, "text">>;
+    /** Reply the received message with a poll. */
+    replyPoll: (question: string, options: [string, string, ...string[]], params?: SendPollParams) => Promise<With<Message, "poll">>;
+    /** Send a chat action to the chat which the message was received from. */
+    sendChatAction: (action: ChatAction, params?: {
+        messageThreadId?: number;
+    }) => Promise<void>;
+    /** Edit a message in the chat which the message was received from. */
+    editMessageText: (messageId: number, text: string, params?: EditMessageParams) => Promise<With<Message, "text">>;
+    /** Answer the received callback query. */
+    answerCallbackQuery: (params?: AnswerCallbackQueryParams) => Promise<void>;
+    /** Answer the received inline query. */
+    answerInlineQuery: (results: InlineQueryResult[], params?: AnswerInlineQueryParams) => Promise<void>;
+    /** Retrieve a single message of the chat which the message was received from. */
+    getMessage: (messageId: number) => Promise<Omit<Message, "replyToMessage"> | null>;
+    /** Retrieve multiple messages of the chat which the message was received from. */
+    getMessages: (messageIds: number[]) => Promise<Omit<Message, "replyToMessage">[]>;
+    toJSON: () => Update;
+}
+export declare function skipInvoke<C extends Context>(): InvokeErrorHandler<Client<C>>;
 export declare const restartAuth: unique symbol;
 export declare class ConnectionError extends Error {
 }
-export declare class Client extends ClientAbstract {
+export declare class Client<C extends Context = Context> extends ClientAbstract {
     #private;
     readonly apiId: number | null;
     readonly apiHash: string | null;
@@ -78,8 +111,12 @@ export declare class Client extends ClientAbstract {
      *
      * @param function_ The function to invoke.
      */
-    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<T extends functions.Function<unknown> ? T["__R"] : void>;
-    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T, noWait: true): Promise<void>;
+    invoke: {
+        <T extends types.Type | functions.Function<unknown> = functions.Function<unknown>>(function_: T): Promise<T extends functions.Function<unknown> ? T["__R"] : void>;
+        <T_1 extends types.Type | functions.Function<unknown> = functions.Function<unknown>>(function_: T_1, noWait: true): Promise<void>;
+    } & {
+        use: (handler: InvokeErrorHandler<Client<C>>) => void;
+    };
     /**
      * Alias for `invoke` with its second parameter being `true`.
      */
@@ -229,11 +266,11 @@ export declare class Client extends ClientAbstract {
      * @param results The results to answer with.
      */
     answerInlineQuery(id: string, results: InlineQueryResult[], params?: AnswerInlineQueryParams): Promise<void>;
-    use(handler: Handler): void;
-    branch(predicate: (upd: Update) => MaybePromise<boolean>, trueHandler: Handler, falseHandler: Handler): void;
-    filter<D extends Update>(predicate: (update: Update) => update is D, handler: Handler<D>): void;
-    filter(predicate: (update: Update) => MaybePromise<boolean>, handler: Handler): void;
-    on<T extends keyof Update, F extends keyof NonNullable<Update[T]>>(filter: T extends FilterableUpdates ? T | [T, F, ...F[]] : T, handler: Handler<FilterUpdate<Update, T, F>>): void;
+    use(...middleware: Middleware<C>[]): Composer<C>;
+    branch(predicate: (ctx: C) => MaybePromise<boolean>, trueHandler_: Middleware<C>, falseHandler_: Middleware<C>): Composer<C>;
+    filter<D extends C>(predicate: (ctx: C) => ctx is D, ...middleware: Middleware<D>[]): void;
+    filter(predicate: (ctx: C) => MaybePromise<boolean>, ...middleware: Middleware<C>[]): void;
+    on<T extends keyof Update, F extends keyof NonNullable<Update[T]>>(filter: T extends FilterableUpdates ? T | [T, F, ...F[]] : T, ...middleawre: Middleware<FilterUpdate<C, T, F>>[]): void;
     /**
      * Set the bot's description in the given language. Bot-only.
      *