@mtkruto/node 0.0.986 → 0.0.988

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

@@ -1,3 +1,5 @@
 import * as types from "../tl/2_types.js";
 export declare function getChannelChatId(channelId: bigint): number;
 export declare function peerToChatId(peer: types.TypePeer | types.TypeInputPeer): number;
+export declare function hasPts(v: types.TypeUpdate | types.TypeUpdates): v is types.UpdateShortMessage | types.UpdateShortChatMessage | types.UpdateShortSentMessage | types.UpdateNewMessage | types.UpdateDeleteMessages | types.UpdateReadHistoryInbox | types.UpdateReadHistoryOutbox | types.UpdatePinnedChannelMessages | types.UpdatePinnedMessages | types.UpdateFolderPeers | types.UpdateChannelWebPage | types.UpdateEditMessage | types.UpdateReadMessagesContents | types.UpdateWebPage;
+export declare function hasChannelPts(v: types.TypeUpdate | types.TypeUpdates): v is types.UpdateNewChannelMessage | types.UpdateEditChannelMessage | types.UpdateDeleteChannelMessages | types.UpdateReadChannelInbox;

package/esm/client/0_utilities.js

@@ -18,3 +18,25 @@ export function peerToChatId(peer) {
         UNREACHABLE();
     }
 }
+export function hasPts(v) {
+    return v instanceof types.UpdateShortMessage ||
+        v instanceof types.UpdateShortChatMessage ||
+        v instanceof types.UpdateShortSentMessage ||
+        v instanceof types.UpdateNewMessage ||
+        v instanceof types.UpdateDeleteMessages ||
+        v instanceof types.UpdateReadHistoryInbox ||
+        v instanceof types.UpdateReadHistoryOutbox ||
+        v instanceof types.UpdatePinnedChannelMessages ||
+        v instanceof types.UpdatePinnedMessages ||
+        v instanceof types.UpdateFolderPeers ||
+        v instanceof types.UpdateChannelWebPage ||
+        v instanceof types.UpdateEditMessage ||
+        v instanceof types.UpdateReadMessagesContents ||
+        v instanceof types.UpdateWebPage;
+}
+export function hasChannelPts(v) {
+    return v instanceof types.UpdateNewChannelMessage ||
+        v instanceof types.UpdateEditChannelMessage ||
+        v instanceof types.UpdateDeleteChannelMessages ||
+        v instanceof types.UpdateReadChannelInbox;
+}

package/esm/client/1_client_abstract.d.ts

@@ -1,16 +1,21 @@
 import { MaybePromise } from "../utilities/0_types.js";
-import { Connection } from "../connection/0_connection.js";
-import { Transport } from "../transport/0_transport.js";
-import { DC } from "../transport/2_transport_provider.js";
+import { DC, TransportProvider } from "../transport/2_transport_provider.js";
+export interface ClientAbstractParams {
+    initialDc?: DC;
+    /**
+     * The transport provider to use. Defaults to `webSocketTransportProvider` with its default options.
+     */
+    transportProvider?: TransportProvider;
+    cdn?: boolean;
+}
 export declare abstract class ClientAbstract {
-    protected transportProvider: import("../transport/2_transport_provider.js").TransportProvider;
+    protected readonly initialDc: DC;
+    protected readonly transportProvider: TransportProvider;
     protected readonly cdn: boolean;
-    protected connection: Connection;
-    protected transport: Transport;
-    private _dcId;
-    private _initialDc;
-    get initialDc(): DC;
-    constructor(transportProvider?: import("../transport/2_transport_provider.js").TransportProvider, cdn?: boolean);
+    protected transport?: ReturnType<TransportProvider>;
+    private dc?;
+    constructor(params?: ClientAbstractParams);
+    protected stateChangeHandler?: (connected: boolean) => void;
     get dcId(): number;
     setDc(dc: DC): MaybePromise<void>;
     get connected(): boolean;

package/esm/client/1_client_abstract.js

@@ -2,23 +2,20 @@ import { initTgCrypto } from "../deps.js";
 import { INITIAL_DC } from "../constants.js";
 import { webSocketTransportProvider } from "../transport/2_transport_provider.js";
 export class ClientAbstract {
-    get initialDc() {
-        return this._initialDc;
-    }
-    constructor(transportProvider = webSocketTransportProvider({ initialDc: INITIAL_DC }), cdn = false) {
-        Object.defineProperty(this, "transportProvider", {
+    constructor(params) {
+        Object.defineProperty(this, "initialDc", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: transportProvider
+            value: void 0
         });
-        Object.defineProperty(this, "cdn", {
+        Object.defineProperty(this, "transportProvider", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: cdn
+            value: void 0
         });
-        Object.defineProperty(this, "connection", {
+        Object.defineProperty(this, "cdn", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -30,42 +27,41 @@ export class ClientAbstract {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "_dcId", {
+        Object.defineProperty(this, "dc", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "_initialDc", {
+        Object.defineProperty(this, "stateChangeHandler", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        const { initialDc, createTransport } = transportProvider;
-        this._initialDc = initialDc;
-        const { connection, transport, dcId } = createTransport({ cdn: this.cdn });
-        this.connection = connection;
-        this.transport = transport;
-        this._dcId = dcId;
+        this.initialDc = params?.initialDc ?? INITIAL_DC;
+        this.transportProvider = params?.transportProvider ?? webSocketTransportProvider();
+        this.cdn = params?.cdn ?? false;
     }
     get dcId() {
-        return this._dcId;
+        if (!this.transport) {
+            throw new Error("Not connected");
+        }
+        return this.transport.dcId;
     }
     // MaybePromise since `Client` has to deal with `Storage.set()`
     setDc(dc) {
-        const { connection, transport, dcId } = this.transportProvider.createTransport({ dc, cdn: this.cdn });
-        this.connection = connection;
-        this.transport = transport;
-        this._dcId = dcId;
+        this.dc = dc;
     }
     get connected() {
-        return this.connection.connected;
+        return this.transport === undefined ? false : this.transport.connection.connected;
     }
     async connect() {
+        this.transport = this.transportProvider({ dc: this.dc ?? this.initialDc, cdn: this.cdn });
+        this.transport.connection.stateChangeHandler = this.stateChangeHandler;
         await initTgCrypto();
-        await this.connection.open();
-        await this.transport.initialize();
+        await this.transport.connection.open();
+        await this.transport.transport.initialize();
     }
     async reconnect(dc) {
         await this.disconnect();
@@ -75,7 +71,10 @@ export class ClientAbstract {
         await this.connect();
     }
     async disconnect() {
-        await this.transport.deinitialize();
-        await this.connection.close();
+        if (!this.transport) {
+            throw new Error("Not connected");
+        }
+        await this.transport.transport.deinitialize();
+        await this.transport.connection.close();
     }
 }

package/esm/client/2_client_plain.d.ts

@@ -1,10 +1,16 @@
+import { PublicKeys } from "../constants.js";
 import { Function } from "../tl/3_functions.js";
-import { TransportProvider } from "../transport/2_transport_provider.js";
-import { ClientAbstract } from "./1_client_abstract.js";
+import { ClientAbstract, ClientAbstractParams } from "./1_client_abstract.js";
+export interface ClientPlainParams extends ClientAbstractParams {
+    /**
+     * MTProto public keys to use in the `[keyId, [key, exponent]][]` format. Don't set this unless you know what you are doing.
+     */
+    publicKeys?: PublicKeys;
+}
 export declare class ClientPlain extends ClientAbstract {
     private readonly publicKeys;
     private lastMsgId;
-    constructor(transportProvider: TransportProvider, publicKeys?: import("../constants.js").PublicKeys);
+    constructor(params?: ClientPlainParams);
     invoke<T extends Function<unknown>>(function_: T): Promise<T["__R"]>;
     createAuthKey(): Promise<{
         authKey: Uint8Array;

package/esm/client/2_client_plain.js

@@ -13,13 +13,13 @@ import { ClientAbstract } from "./1_client_abstract.js";
 import { getMessageId, packUnencryptedMessage, unpackUnencryptedMessage } from "./0_message.js";
 const d = debug("ClientPlain/createAuthKey");
 export class ClientPlain extends ClientAbstract {
-    constructor(transportProvider, publicKeys = PUBLIC_KEYS) {
-        super(transportProvider);
+    constructor(params) {
+        super(params);
         Object.defineProperty(this, "publicKeys", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: publicKeys
+            value: void 0
         });
         Object.defineProperty(this, "lastMsgId", {
             enumerable: true,
@@ -27,11 +27,15 @@ export class ClientPlain extends ClientAbstract {
             writable: true,
             value: 0n
         });
+        this.publicKeys = params?.publicKeys ?? PUBLIC_KEYS;
     }
     async invoke(function_) {
+        if (!this.transport) {
+            throw new Error("Not connected");
+        }
         const msgId = this.lastMsgId = getMessageId(this.lastMsgId);
-        await this.transport.send(packUnencryptedMessage(function_[serialize](), msgId));
-        const buffer = await this.transport.receive();
+        await this.transport.transport.send(packUnencryptedMessage(function_[serialize](), msgId));
+        const buffer = await this.transport.transport.receive();
         if (buffer.length == 4) {
             const int = bigIntFromBuffer(buffer, true, true);
             if (int == -404n) {

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

@@ -1,10 +1,9 @@
-import { PublicKeys } from "../constants.js";
 import { MaybePromise } from "../utilities/0_types.js";
 import * as types from "../tl/2_types.js";
 import * as functions from "../tl/3_functions.js";
 import { ReadObject } from "../tl/3_tl_reader.js";
 import { Storage } from "../storage/0_storage.js";
-import { DC, TransportProvider } from "../transport/2_transport_provider.js";
+import { DC } from "../transport/2_transport_provider.js";
 import { MessageEntity } from "../types/0_message_entity.js";
 import { ReplyKeyboardRemove } from "../types/0_reply_keyboard_remove.js";
 import { ForceReply } from "../types/0_force_reply.js";
@@ -12,6 +11,7 @@ import { ReplyKeyboardMarkup } from "../types/2_reply_keyboard_markup.js";
 import { InlineKeyboardMarkup } from "../types/2_inline_keyboard_markup.js";
 import { Message } from "../types/3_message.js";
 import { ClientAbstract } from "./1_client_abstract.js";
+import { ClientPlainParams } from "./2_client_plain.js";
 export declare const getEntity: unique symbol;
 export declare const getStickerSetName: unique symbol;
 export declare const handleMigrationError: unique symbol;
@@ -25,16 +25,11 @@ export interface AuthorizeUserParams<S = string> {
     code: S | (() => MaybePromise<S>);
     password: S | ((hint: string | null) => MaybePromise<S>);
 }
-export type UpdateHandler = null | ((client: Client, update: types.TypeUpdate) => MaybePromise<void>);
-export interface ClientParams {
+export interface ClientParams extends ClientPlainParams {
     /**
      * Default parse mode. Defauls to `ParseMode.None`.
      */
     parseMode?: ParseMode;
-    /**
-     * The transport provider to use. Defaults to `webSocketTransportProvider`.
-     */
-    transportProvider?: TransportProvider;
     /**
      * The app_version parameter to be passed to initConnection when calling `authorize`.
      */
@@ -59,10 +54,6 @@ export interface ClientParams {
      * The system_version parameter to be passed to initConnection when calling `authorize`.
      */
     systemVersion?: string;
-    /**
-     * MTProto public keys to use in the `[keyId, [key, exponent]][]` format. Don't set this unless you know what you are doing.
-     */
-    publicKeys?: PublicKeys;
     /**
      * Whether to automatically call `start` with no parameters in the first `invoke` call.
      */
@@ -161,7 +152,6 @@ export declare class Client extends ClientAbstract {
     private promises;
     private toAcknowledge;
     private updateState?;
-    updateHandler: UpdateHandler;
     readonly parseMode: ParseMode;
     readonly appVersion: string;
     readonly deviceModel: string;
@@ -179,7 +169,9 @@ export declare class Client extends ClientAbstract {
      * @param apiHash App's API hash from [my.telegram.org/apps](https://my.telegram.org/apps). Defaults to empty string (unset).
      * @param params Other parameters.
      */
-    constructor(storage?: Storage, apiId?: number | null, apiHash?: string | null, params?: ClientParams, cdn?: boolean);
+    constructor(storage?: Storage, apiId?: number | null, apiHash?: string | null, params?: ClientParams);
+    private propagateConnectionState;
+    protected stateChangeHandler: (connected: boolean) => void;
     private storageInited;
     /**
      * Sets the DC and resets the auth key stored in the session provider
@@ -189,6 +181,7 @@ export declare class Client extends ClientAbstract {
      */
     setDc(dc: DC): Promise<void>;
     private setAuth;
+    private connectMutex;
     /**
      * Loads the session if `setDc` was not called, initializes and connnects
      * a `ClientPlain` to generate auth key if there was none, and connects the client.
@@ -240,14 +233,13 @@ export declare class Client extends ClientAbstract {
     send<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<void>;
     private processChats;
     private processUsers;
-    private updateApplicationMutex;
-    private applyUpdateNoGap;
-    private applyUpdate;
-    private updateProcessLock;
+    private handleUpdateQueue;
+    private processUpdatesQueue;
+    private checkGap;
+    private checkChannelGap;
     private processUpdates;
     private setUpdateStateDate;
     private getLocalState;
-    private updateGapRecoveryMutex;
     private recoverUpdateGap;
     private recoverChannelUpdateGap;
     getInputPeer(id: ChatID): Promise<types.InputPeerChat | types.InputPeerUser | types.InputPeerChannel>;
@@ -313,4 +305,21 @@ export declare class Client extends ClientAbstract {
      * Get information on the currently authorized user.
      */
     getMe(): Promise<import("../types/1_user.js").User>;
+    private handleUpdate;
+    handler: Handler;
+    use(middleware: Handler): void;
+    on<U extends keyof Update, K extends keyof Update[U]>(filter: Update[U] extends string ? U : U | [U, ...K[]], handler: Handler<Pick<{
+        [P in U]: With<Update[U], K>;
+    }, U>>): void;
+}
+type With<T, K extends keyof T> = T & Required<Pick<T, K>>;
+export type ConnectionState = "not-connected" | "updating" | "ready";
+export interface Update {
+    message: Message;
+    editedMessage: Message;
+    connectionState: ConnectionState;
+}
+export interface Handler<U extends Partial<Update> = Partial<Update>> {
+    (update: U, next: () => Promise<void>): MaybePromise<void>;
 }
+export {};