@mtkruto/node 0.1.114 → 0.1.116

package/esm/4_constants.d.ts

@@ -5,7 +5,7 @@ export declare const PUBLIC_KEYS: PublicKeys;
 export declare const VECTOR_CONSTRUCTOR = 481674261;
 export declare const INITIAL_DC: DC;
 export declare const LAYER = 166;
-export declare const APP_VERSION = "MTKruto 0.1.114";
+export declare const APP_VERSION = "MTKruto 0.1.116";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/esm/4_constants.js

@@ -54,7 +54,7 @@ export const PUBLIC_KEYS = Object.freeze([
 export const VECTOR_CONSTRUCTOR = 0x1CB5C415;
 export const INITIAL_DC = "2";
 export const LAYER = 166;
-export const APP_VERSION = "MTKruto 0.1.114";
+export const APP_VERSION = "MTKruto 0.1.116";
 // @ts-ignore: lib
 export const DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
 export const LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];

package/esm/client/0_utilities.d.ts

@@ -9,3 +9,4 @@ export declare function isChannelPtsUpdate(v: types.TypeUpdate | types.TypeUpdat
 export type FileSource = string | URL | Uint8Array;
 export declare function getFileContents(source: FileSource, fileName?: string): Promise<readonly [Uint8Array, string]>;
 export declare function isHttpUrl(string: string): boolean;
+export declare function getUsername(string: string): string;

package/esm/client/0_utilities.js

@@ -2,6 +2,7 @@ import * as dntShim from "../_dnt.shims.js";
 import { path } from "../0_deps.js";
 import { UNREACHABLE } from "../1_utilities.js";
 import { types } from "../2_tl.js";
+import { Username } from "../tl/2_types.js";
 export const resolve = () => Promise.resolve();
 export function isPtsUpdate(v) {
     return v instanceof types.UpdateShortMessage ||
@@ -74,3 +75,66 @@ export function isHttpUrl(string) {
         return false;
     }
 }
+function isAlpha(string) {
+    const c = string.charCodeAt(0) | 0x20;
+    return "a".charCodeAt(0) <= c && c <= "z".charCodeAt(0);
+}
+function isDigit(string) {
+    const c = string.charCodeAt(0);
+    return "0".charCodeAt(0) <= c && c <= "9".charCodeAt(0);
+}
+const errInvalidUsername = (u) => new Error("Invalid username: " + u);
+function validateUsername(string, ignoreAt = false) {
+    string = string.trim();
+    if (ignoreAt && string.startsWith("@")) {
+        string = string.slice(1);
+    }
+    if (string.length == 0 || string.length > 32) {
+        throw errInvalidUsername(string);
+    }
+    if (!isAlpha(string[0])) {
+        throw errInvalidUsername(string);
+    }
+    for (const c of string) {
+        if (!isAlpha(c) && !isDigit(c) && c != "_") {
+            throw errInvalidUsername(string);
+        }
+    }
+    if (string[Username.length - 1] == "_") {
+        throw errInvalidUsername(string);
+    }
+    for (let i = 1; i < string.length; ++i) {
+        if (string[i - 1] == "_" && string[i] == "_") {
+            throw errInvalidUsername(string);
+        }
+    }
+    return string;
+}
+export function getUsername(string) {
+    let url = null;
+    try {
+        url = new URL(string);
+    }
+    catch {
+        try {
+            url = new URL("https://" + string);
+        }
+        catch {
+            //
+        }
+    }
+    if (url === null || (url.protocol != "http:" && url.protocol != "https:")) {
+        return validateUsername(string, true);
+    }
+    if (url.hostname != "telegram.dog" && url.hostname != "telegram.me" && url.hostname != "t.me" && !url.hostname.endsWith(".t.me")) {
+        return validateUsername(string, true);
+    }
+    if (url.hostname == "telegram.dog" || url.hostname == "telegram.me" || url.hostname == "t.me") {
+        return validateUsername(url.pathname.split("/")[1]);
+    }
+    const parts = url.hostname.split(".");
+    if (parts.length != 3) {
+        return validateUsername(string);
+    }
+    return validateUsername(parts[0]);
+}

package/esm/client/0_utilities_test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -41,6 +41,10 @@ export interface ClientParams extends ClientPlainParams {
      * Whether to use default handlers. Defaults to `true`.
      */
     defaultHandlers?: boolean;
+    /**
+     * Whether to ignore outgoing messages. Defaults to `true` for bots, and `false` for users.
+     */
+    ignoreOutgoing?: boolean;
 }
 export interface AnswerCallbackQueryParams {
     /** A text to be shown to the user. */

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

@@ -1,4 +1,8 @@
-import { FilterableUpdates, FilterUpdate, Update } from "./3_types.js";
+import { User } from "../3_types.js";
+import { FilterableUpdates, FilterUpdate, Update as Update_ } from "./3_types.js";
+interface Update extends Update_ {
+    me: undefined extends this["connectionState"] ? undefined extends this["authorizationState"] ? User : (User | undefined) : (User | undefined);
+}
 type MaybePromise<T> = T | Promise<T>;
 export type NextFunction = () => Promise<void>;
 export type MiddlewareFn<C extends Update = Update> = (ctx: C, next: NextFunction) => MaybePromise<unknown>;
@@ -18,5 +22,6 @@ export declare class Composer<C extends Update> implements MiddlewareObj<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>>;
+    command(commands: string | RegExp | (string | RegExp)[], ...middleawre: Middleware<FilterUpdate<C, "message", "text">>[]): Composer<FilterUpdate<C, "message", "text">>;
 }
 export {};

package/esm/client/4_composer.js

@@ -54,7 +54,9 @@ export class Composer {
         });
     }
     filter(predicate, ...middleware) {
-        return this.branch(predicate, middleware.length == 0 ? skip : middleware.map(flatten).reduce(concat), skip);
+        const composer = new Composer(...middleware);
+        this.branch(predicate, composer, skip);
+        return composer;
     }
     on(filter, ...middleawre) {
         const type = typeof filter === "string" ? filter : filter[0];
@@ -77,5 +79,31 @@ export class Composer {
             }
         }, ...middleawre);
     }
+    command(commands, ...middleawre) {
+        const commands_ = Array.isArray(commands) ? commands : [commands];
+        return this.on(["message", "text"]).filter((ctx) => {
+            const botCommand = ctx.message.entities?.find((v) => v.type == "botCommand");
+            if (!botCommand) {
+                return false;
+            }
+            const cmd = ctx.message.text.slice(botCommand.offset, botCommand.offset + botCommand.length);
+            if (cmd.includes("@")) {
+                const username = cmd.split("@")[1];
+                if (username.toLowerCase() !== ctx.me.username?.toLowerCase()) {
+                    return false;
+                }
+            }
+            const command_ = cmd.split("@")[0].split("/")[1].toLowerCase();
+            for (const command of commands_) {
+                if (typeof command === "string" && (command.toLowerCase() == command_)) {
+                    return true;
+                }
+                else if (command instanceof RegExp && command.test(command_)) {
+                    return true;
+                }
+            }
+            return false;
+        }, ...middleawre);
+    }
 }
 _Composer_handle = new WeakMap();

package/esm/client/5_client.d.ts

@@ -15,6 +15,7 @@ declare const getMessageWithReply: unique symbol;
 export interface Context extends Update {
     /** The client that received the update. */
     client: Client;
+    me: undefined extends this["connectionState"] ? undefined extends this["authorizationState"] ? User : (User | undefined) : (User | undefined);
     /** 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`. */
@@ -135,7 +136,7 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      * Alias for `invoke` with its second parameter being `true`.
      */
     send<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<void>;
-    checkGap(pts: number, ptsCount: number, assertNoGap: boolean): Promise<void>;
+    checkGap(pts: number, ptsCount: number): Promise<void>;
     getUserAccessHash(userId: bigint): Promise<bigint>;
     getInputPeer(id: ChatID): Promise<types.InputPeerChat | types.InputPeerUser | types.InputPeerChannel>;
     private [getEntity];
@@ -282,9 +283,10 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
     answerInlineQuery(id: string, results: InlineQueryResult[], params?: AnswerInlineQueryParams): Promise<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;
+    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>>;
+    command(commands: string | RegExp | (string | RegExp)[], ...middleawre: Middleware<FilterUpdate<C, "message", "text">>[]): Composer<FilterUpdate<C, "message", "text">>;
     /**
      * Set the bot's description in the given language. Bot-only.
      *