@mtkruto/node 0.0.820 → 0.0.822

package/script/client/client.js

@@ -23,11 +23,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = void 0;
+exports.Client = exports.restartAuth = void 0;
 const deps_js_1 = require("../deps.js");
 const constants_js_1 = require("../constants.js");
 const _0_bigint_js_1 = require("../utilities/0_bigint.js");
 const _1_message_js_1 = require("../utilities/1_message.js");
+const _1_password_js_1 = require("../utilities/1_password.js");
 const types = __importStar(require("../tl/2_types.js"));
 const functions = __importStar(require("../tl/3_functions.js"));
 const _3_tl_reader_js_1 = require("../tl/3_tl_reader.js");
@@ -37,7 +38,16 @@ const _6_message_container_js_1 = require("../tl/6_message_container.js");
 const client_abstract_js_1 = require("./client_abstract.js");
 const client_plain_js_1 = require("./client_plain.js");
 const session_memory_js_1 = require("../session/session_memory.js");
+exports.restartAuth = Symbol();
 class Client extends client_abstract_js_1.ClientAbstract {
+    /**
+     * Constructs the client.
+     *
+     * @param session The session provider to use. Defaults to in-memory session.
+     * @param apiId App's API ID from [my.telegram.org](https://my.telegram.org/apps). Defaults to 0 (unset).
+     * @param apiHash App's API hash from [my.telegram.org/apps](https://my.telegram.org/apps). Default to empty string (unset).
+     * @param params Other parameters.
+     */
     constructor(session = new session_memory_js_1.SessionMemory(), apiId = 0, apiHash = "", params) {
         super(params?.transportProvider);
         Object.defineProperty(this, "session", {
@@ -137,6 +147,12 @@ class Client extends client_abstract_js_1.ClientAbstract {
         this.systemLangCode = params?.systemLangCode ?? constants_js_1.DEFAULT_SYSTEM_LANG_CODE;
         this.systemVersion = params?.systemVersion ?? constants_js_1.DEFAULT_SYSTEM_VERSION;
     }
+    /**
+     * Sets the DC and resets the auth key stored in the session provider
+     * if the stored DC was not the same as the `dc` parameter.
+     *
+     * @param dc The DC to change to.
+     */
     setDc(dc) {
         if (this.session.dc != dc) {
             this.session.dc = dc;
@@ -147,6 +163,11 @@ class Client extends client_abstract_js_1.ClientAbstract {
         }
         super.setDc(dc);
     }
+    /**
+     * 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.
+     * Before establishing the connection, the session is saved.
+     */
     async connect() {
         if (this.shouldLoadSession) {
             await this.session.load();
@@ -172,6 +193,23 @@ class Client extends client_abstract_js_1.ClientAbstract {
         this.receiveLoop();
         this.pingLoop();
     }
+    /**
+     * Calls [initConnection](1) and authorizes the client with one of the following:
+     *
+     * - Bot token (`string`)
+     * - Exported authorization (`types.AuthExportedAuthorization`)
+     * - User authorization handlers (`AuthorizeUserParams`)
+     *
+     * if the current auth key doesn't throw AUTH_KEY_UNREGISTERED when calling [updates.getState](2).
+     *
+     * Notes:
+     * 1. Requires the `apiId` and `apiHash` paramters to be passed when constructing the client.
+     * 2. Reconnects the client to the appropriate DC in case of MIGRATE_X errors.
+     * 3. The parameters passed to the [initConnection][1] call can be configured with the last parameter of the constructor.
+     *
+     * [1]: https://core.telegram.org/method/initConnection
+     * [2]: https://core.telegram.org/method/updates.getState
+     */
     async authorize(params) {
         if (!this.apiId) {
             throw new Error("apiId not set");
@@ -201,12 +239,92 @@ class Client extends client_abstract_js_1.ClientAbstract {
                 throw err;
             }
         }
+        let signedIn = false;
+        let phoneNumber = null;
         try {
             if (params instanceof types.AuthExportedAuthorization) {
                 await this.invoke(new functions.AuthImportAuthorization({ id: params.id, bytes: params.bytes }));
             }
             else if (typeof params == "object") {
-                throw new Error("Not implemented");
+                while (true) {
+                    if (signedIn) {
+                        break;
+                    }
+                    try {
+                        try {
+                            phoneNumber = typeof params.phone === "string" ? params.phone : await params.phone();
+                            const sentCode = await this.invoke(new functions.AuthSendCode({
+                                apiId: this.apiId,
+                                apiHash: this.apiHash,
+                                phoneNumber,
+                                settings: new types.CodeSettings(),
+                            }));
+                            if (sentCode instanceof types.AuthSentCode) {
+                                while (true) {
+                                    const phoneCode = typeof params.code === "string" ? params.code : await params.code();
+                                    try {
+                                        const auth = await this.invoke(new functions.AuthSignIn({ phoneNumber, phoneCode, phoneCodeHash: sentCode.phoneCodeHash }));
+                                        if (auth instanceof types.AuthAuthorizationSignUpRequired) {
+                                            throw new Error("Sign up not supported");
+                                        }
+                                        else {
+                                            signedIn = true;
+                                            break;
+                                        }
+                                    }
+                                    catch (err) {
+                                        if (err instanceof types.RPCError && err.errorMessage == "PHONE_CODE_INVALID") {
+                                            continue;
+                                        }
+                                        else {
+                                            throw err;
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                throw new Error(`Handling ${sentCode.constructor.name} not implemented`);
+                            }
+                        }
+                        catch (err) {
+                            if (err instanceof types.RPCError && err.errorMessage == "SESSION_PASSWORD_NEEDED") {
+                                while (true) {
+                                    const ap = await this.invoke(new functions.AccountGetPassword());
+                                    if (ap.currentAlgo instanceof types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) {
+                                        try {
+                                            const password = typeof params.password === "string" ? params.password : await params.password();
+                                            const input = await (0, _1_password_js_1.checkPassword)(password, ap);
+                                            await this.invoke(new functions.AuthCheckPassword({ password: input }));
+                                            break;
+                                        }
+                                        catch (err) {
+                                            if (err instanceof types.RPCError && err.errorMessage == "PASSWORD_HASH_INVALID") {
+                                                continue;
+                                            }
+                                            else {
+                                                throw err;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        throw new Error(`Handling ${ap.currentAlgo?.constructor.name} not implemented`);
+                                    }
+                                }
+                            }
+                            else {
+                                throw err;
+                            }
+                        }
+                    }
+                    catch (err) {
+                        if (err == exports.restartAuth) {
+                            continue;
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                }
             }
             else {
                 await this.invoke(new functions.AuthImportBotAuthorization({ apiId: this.apiId, apiHash: this.apiHash, botAuthToken: params, flags: 0 }));
@@ -221,6 +339,10 @@ class Client extends client_abstract_js_1.ClientAbstract {
                         newDc += "-test";
                     }
                     await this.reconnect(newDc);
+                    if (typeof params === "object" && phoneNumber != null) {
+                        params = Object.assign({}, params);
+                        params.phone = phoneNumber;
+                    }
                     await this.authorize(params);
                 }
                 else {
@@ -344,6 +466,9 @@ class Client extends client_abstract_js_1.ClientAbstract {
             return result;
         }
     }
+    /**
+     * Alias for `invoke` with its second parameter being `true`.
+     */
     send(function_) {
         return this.invoke(function_, true);
     }

package/script/client/client_abstract.d.ts

@@ -0,0 +1,16 @@
+import { Connection } from "../connection/connection.js";
+import { Transport } from "../transport/transport.js";
+import { DC } from "../transport/transport_provider.js";
+export declare abstract class ClientAbstract {
+    protected transportProvider: import("../transport/transport_provider.js").TransportProvider;
+    protected connection: Connection;
+    protected transport: Transport;
+    private _dcId;
+    protected connected: boolean;
+    constructor(transportProvider?: import("../transport/transport_provider.js").TransportProvider);
+    get dcId(): number;
+    setDc(dc: DC): void;
+    connect(): Promise<void>;
+    reconnect(dc?: DC): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/script/client/client_plain.d.ts

@@ -0,0 +1,9 @@
+import { Function } from "../tl/3_functions.js";
+import { ClientAbstract } from "./client_abstract.js";
+export declare class ClientPlain extends ClientAbstract {
+    invoke<T extends Function<unknown>>(function_: T): Promise<T["__R"]>;
+    createAuthKey(): Promise<{
+        authKey: Uint8Array;
+        salt: bigint;
+    }>;
+}

package/script/connection/connection.d.ts

@@ -0,0 +1,7 @@
+import { MaybePromise } from "../types.js";
+export declare abstract class Connection {
+    abstract open(): MaybePromise<void>;
+    abstract read(p: Uint8Array): MaybePromise<void>;
+    abstract write(p: Uint8Array): MaybePromise<void>;
+    abstract close(): MaybePromise<void>;
+}

package/script/connection/connection_web_socket.d.ts

@@ -0,0 +1,13 @@
+import { Connection } from "./connection.js";
+export declare class ConnectionWebSocket implements Connection {
+    private webSocket;
+    private rMutex;
+    private wMutex;
+    private buffer;
+    private nextResolve;
+    constructor(url: string | URL);
+    open(): Promise<void>;
+    read(p: Uint8Array): Promise<void>;
+    write(p: Uint8Array): Promise<void>;
+    close(): void;
+}

package/script/constants.d.ts

@@ -0,0 +1,12 @@
+import { DC } from "./transport/transport_provider.js";
+export declare const ackThreshold = 10;
+export declare const publicKeys: Map<bigint, [bigint, bigint]>;
+export declare const VECTOR_CONSTRUCTOR = 481674261;
+export declare const DEFAULT_INITIAL_DC: DC;
+export declare const LAYER = 158;
+export declare const DEFAULT_APP_VERSION = "MTKruto Unstable <v1.0.0";
+export declare const DEFAULT_DEVICE_MODEL = "Krutaya Device";
+export declare const DEFAULT_LANG_CODE = "en";
+export declare const DEFAULT_LANG_PACK = "";
+export declare const DEFAULT_SYSTEM_LANG_CODE = "en";
+export declare const DEFAULT_SYSTEM_VERSION = "1.0";

package/script/deps/deno.land/std@0.186.0/fmt/colors.d.ts

@@ -0,0 +1,270 @@
+/** RGB 8-bits per channel. Each in range `0->255` or `0x00->0xff` */
+interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+/**
+ * Set changing text color to enabled or disabled
+ * @param value
+ */
+export declare function setColorEnabled(value: boolean): void;
+/** Get whether text color change is enabled or disabled. */
+export declare function getColorEnabled(): boolean;
+/**
+ * Reset the text modified
+ * @param str text to reset
+ */
+export declare function reset(str: string): string;
+/**
+ * Make the text bold.
+ * @param str text to make bold
+ */
+export declare function bold(str: string): string;
+/**
+ * The text emits only a small amount of light.
+ * @param str text to dim
+ */
+export declare function dim(str: string): string;
+/**
+ * Make the text italic.
+ * @param str text to make italic
+ */
+export declare function italic(str: string): string;
+/**
+ * Make the text underline.
+ * @param str text to underline
+ */
+export declare function underline(str: string): string;
+/**
+ * Invert background color and text color.
+ * @param str text to invert its color
+ */
+export declare function inverse(str: string): string;
+/**
+ * Make the text hidden.
+ * @param str text to hide
+ */
+export declare function hidden(str: string): string;
+/**
+ * Put horizontal line through the center of the text.
+ * @param str text to strike through
+ */
+export declare function strikethrough(str: string): string;
+/**
+ * Set text color to black.
+ * @param str text to make black
+ */
+export declare function black(str: string): string;
+/**
+ * Set text color to red.
+ * @param str text to make red
+ */
+export declare function red(str: string): string;
+/**
+ * Set text color to green.
+ * @param str text to make green
+ */
+export declare function green(str: string): string;
+/**
+ * Set text color to yellow.
+ * @param str text to make yellow
+ */
+export declare function yellow(str: string): string;
+/**
+ * Set text color to blue.
+ * @param str text to make blue
+ */
+export declare function blue(str: string): string;
+/**
+ * Set text color to magenta.
+ * @param str text to make magenta
+ */
+export declare function magenta(str: string): string;
+/**
+ * Set text color to cyan.
+ * @param str text to make cyan
+ */
+export declare function cyan(str: string): string;
+/**
+ * Set text color to white.
+ * @param str text to make white
+ */
+export declare function white(str: string): string;
+/**
+ * Set text color to gray.
+ * @param str text to make gray
+ */
+export declare function gray(str: string): string;
+/**
+ * Set text color to bright black.
+ * @param str text to make bright-black
+ */
+export declare function brightBlack(str: string): string;
+/**
+ * Set text color to bright red.
+ * @param str text to make bright-red
+ */
+export declare function brightRed(str: string): string;
+/**
+ * Set text color to bright green.
+ * @param str text to make bright-green
+ */
+export declare function brightGreen(str: string): string;
+/**
+ * Set text color to bright yellow.
+ * @param str text to make bright-yellow
+ */
+export declare function brightYellow(str: string): string;
+/**
+ * Set text color to bright blue.
+ * @param str text to make bright-blue
+ */
+export declare function brightBlue(str: string): string;
+/**
+ * Set text color to bright magenta.
+ * @param str text to make bright-magenta
+ */
+export declare function brightMagenta(str: string): string;
+/**
+ * Set text color to bright cyan.
+ * @param str text to make bright-cyan
+ */
+export declare function brightCyan(str: string): string;
+/**
+ * Set text color to bright white.
+ * @param str text to make bright-white
+ */
+export declare function brightWhite(str: string): string;
+/**
+ * Set background color to black.
+ * @param str text to make its background black
+ */
+export declare function bgBlack(str: string): string;
+/**
+ * Set background color to red.
+ * @param str text to make its background red
+ */
+export declare function bgRed(str: string): string;
+/**
+ * Set background color to green.
+ * @param str text to make its background green
+ */
+export declare function bgGreen(str: string): string;
+/**
+ * Set background color to yellow.
+ * @param str text to make its background yellow
+ */
+export declare function bgYellow(str: string): string;
+/**
+ * Set background color to blue.
+ * @param str text to make its background blue
+ */
+export declare function bgBlue(str: string): string;
+/**
+ *  Set background color to magenta.
+ * @param str text to make its background magenta
+ */
+export declare function bgMagenta(str: string): string;
+/**
+ * Set background color to cyan.
+ * @param str text to make its background cyan
+ */
+export declare function bgCyan(str: string): string;
+/**
+ * Set background color to white.
+ * @param str text to make its background white
+ */
+export declare function bgWhite(str: string): string;
+/**
+ * Set background color to bright black.
+ * @param str text to make its background bright-black
+ */
+export declare function bgBrightBlack(str: string): string;
+/**
+ * Set background color to bright red.
+ * @param str text to make its background bright-red
+ */
+export declare function bgBrightRed(str: string): string;
+/**
+ * Set background color to bright green.
+ * @param str text to make its background bright-green
+ */
+export declare function bgBrightGreen(str: string): string;
+/**
+ * Set background color to bright yellow.
+ * @param str text to make its background bright-yellow
+ */
+export declare function bgBrightYellow(str: string): string;
+/**
+ * Set background color to bright blue.
+ * @param str text to make its background bright-blue
+ */
+export declare function bgBrightBlue(str: string): string;
+/**
+ * Set background color to bright magenta.
+ * @param str text to make its background bright-magenta
+ */
+export declare function bgBrightMagenta(str: string): string;
+/**
+ * Set background color to bright cyan.
+ * @param str text to make its background bright-cyan
+ */
+export declare function bgBrightCyan(str: string): string;
+/**
+ * Set background color to bright white.
+ * @param str text to make its background bright-white
+ */
+export declare function bgBrightWhite(str: string): string;
+/**
+ * Set text color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+ * @param str text color to apply paletted 8bit colors to
+ * @param color code
+ */
+export declare function rgb8(str: string, color: number): string;
+/**
+ * Set background color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+ * @param str text color to apply paletted 8bit background colors to
+ * @param color code
+ */
+export declare function bgRgb8(str: string, color: number): string;
+/**
+ * Set text color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ * ```ts
+ *      import { rgb24 } from "https://deno.land/std@$STD_VERSION/fmt/colors.ts";
+ *      rgb24("foo", 0xff00ff);
+ *      rgb24("foo", {r: 255, g: 0, b: 255});
+ * ```
+ * @param str text color to apply 24bit rgb to
+ * @param color code
+ */
+export declare function rgb24(str: string, color: number | Rgb): string;
+/**
+ * Set background color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ * ```ts
+ *      import { bgRgb24 } from "https://deno.land/std@$STD_VERSION/fmt/colors.ts";
+ *      bgRgb24("foo", 0xff00ff);
+ *      bgRgb24("foo", {r: 255, g: 0, b: 255});
+ * ```
+ * @param str text color to apply 24bit rgb to
+ * @param color code
+ */
+export declare function bgRgb24(str: string, color: number | Rgb): string;
+/**
+ * Remove ANSI escape codes from the string.
+ * @param string to remove ANSI escape codes from
+ */
+export declare function stripColor(string: string): string;
+export {};

package/script/deps/deno.land/std@0.186.0/testing/_diff.d.ts

@@ -0,0 +1,26 @@
+export declare enum DiffType {
+    removed = "removed",
+    common = "common",
+    added = "added"
+}
+export interface DiffResult<T> {
+    type: DiffType;
+    value: T;
+    details?: Array<DiffResult<T>>;
+}
+/**
+ * Renders the differences between the actual and expected values
+ * @param A Actual value
+ * @param B Expected value
+ */
+export declare function diff<T>(A: T[], B: T[]): Array<DiffResult<T>>;
+/**
+ * Renders the differences between the actual and expected strings
+ * Partially inspired from https://github.com/kpdecker/jsdiff
+ * @param A Actual string
+ * @param B Expected string
+ */
+export declare function diffstr(A: string, B: string): DiffResult<string>[];
+export declare function buildMessage(diffResult: ReadonlyArray<DiffResult<string>>, { stringDiff }?: {
+    stringDiff?: boolean | undefined;
+}): string[];

package/script/deps/deno.land/std@0.186.0/testing/_format.d.ts

@@ -0,0 +1 @@
+export declare function format(v: unknown): string;