@mtkruto/node 0.2.6 → 0.2.10

package/esm/client/5_client.js

@@ -747,13 +747,13 @@ export class Client extends Composer {
      */
     async connect() {
         const unlock = await __classPrivateFieldGet(this, _Client_connectMutex, "f").lock();
-        if (this.connected) {
-            return;
-        }
-        if (__classPrivateFieldGet(this, _Client_lastConnect, "f") != null && Date.now() - __classPrivateFieldGet(this, _Client_lastConnect, "f").getTime() <= 10 * second) {
-            await new Promise((r) => setTimeout(r, 3 * second));
-        }
         try {
+            if (this.connected) {
+                return;
+            }
+            if (__classPrivateFieldGet(this, _Client_lastConnect, "f") != null && Date.now() - __classPrivateFieldGet(this, _Client_lastConnect, "f").getTime() <= 10 * second) {
+                await new Promise((r) => setTimeout(r, 3 * second));
+            }
             await __classPrivateFieldGet(this, _Client_instances, "m", _Client_initStorage).call(this);
             const [authKey, dc] = await Promise.all([this.storage.getAuthKey(), this.storage.getDc()]);
             if (authKey != null && dc != null) {
@@ -1532,6 +1532,21 @@ export class Client extends Composer {
     async sendPoll(chatId, question, options, params) {
         return await __classPrivateFieldGet(this, _Client_messageManager, "f").sendPoll(chatId, question, options, params);
     }
+    /**
+     * Send an invoice.
+     *
+     * @method ms
+     * @param chatId The chat to send the invoice to.
+     * @param title The invoice's title.
+     * @param description The invoice's description.
+     * @param payload The invoice's payload.
+     * @param currency The invoice's currency.
+     * @param prices The invoice's price tags.
+     * @returns The sent invoice.
+     */
+    async sendInvoice(chatId, title, description, payload, currency, prices, params) {
+        return await __classPrivateFieldGet(this, _Client_messageManager, "f").sendInvoice(chatId, title, description, payload, currency, prices, params);
+    }
     /**
      * Edit a message's text.
      *

package/esm/connection/1_connection_tcp.node.d.ts

@@ -0,0 +1,12 @@
+import { Connection } from "./0_connection.js";
+export declare class ConnectionTCP implements Connection {
+    #private;
+    stateChangeHandler?: Connection["stateChangeHandler"];
+    constructor(hostname: string, port: number);
+    open(): Promise<void>;
+    get connected(): boolean;
+    read(p: Uint8Array): Promise<void>;
+    write(p: Uint8Array): Promise<void>;
+    close(): void;
+}
+//# sourceMappingURL=1_connection_tcp.node.d.ts.map

package/esm/connection/1_connection_tcp.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1_connection_tcp.node.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_tcp.node.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAI/C,qBAAa,aAAc,YAAW,UAAU;;IAW9C,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;gBAE1C,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAY1C,IAAI;IAsCJ,IAAI,SAAS,YAEZ;IAQK,IAAI,CAAC,CAAC,EAAE,UAAU;IAclB,KAAK,CAAC,CAAC,EAAE,UAAU;IA0BzB,KAAK;CAKN"}

package/esm/connection/1_connection_tcp.node.js

@@ -0,0 +1,122 @@
+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 _ConnectionTCP_instances, _ConnectionTCP_hostname, _ConnectionTCP_port, _ConnectionTCP_socket, _ConnectionTCP_rMutex, _ConnectionTCP_wMutex, _ConnectionTCP_buffer, _ConnectionTCP_nextResolve, _ConnectionTCP_rejectRead, _ConnectionTCP_assertConnected;
+import { Socket } from "node:net";
+import { Mutex } from "../1_utilities.js";
+import { ConnectionError } from "../0_errors.js";
+const errConnectionNotOpen = new ConnectionError("Connection not open");
+export class ConnectionTCP {
+    constructor(hostname, port) {
+        _ConnectionTCP_instances.add(this);
+        _ConnectionTCP_hostname.set(this, void 0);
+        _ConnectionTCP_port.set(this, void 0);
+        _ConnectionTCP_socket.set(this, void 0);
+        _ConnectionTCP_rMutex.set(this, new Mutex());
+        _ConnectionTCP_wMutex.set(this, new Mutex());
+        _ConnectionTCP_buffer.set(this, new Array());
+        _ConnectionTCP_nextResolve.set(this, null);
+        Object.defineProperty(this, "stateChangeHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        __classPrivateFieldSet(this, _ConnectionTCP_hostname, hostname, "f");
+        __classPrivateFieldSet(this, _ConnectionTCP_port, port, "f");
+    }
+    open() {
+        __classPrivateFieldSet(this, _ConnectionTCP_socket, new Socket(), "f");
+        __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").on("close", () => {
+            __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_rejectRead).call(this);
+            this.stateChangeHandler?.(false);
+        });
+        const mutex = new Mutex();
+        __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").on("data", async (data) => {
+            const unlock = await mutex.lock();
+            for (const byte of data) {
+                __classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").push(byte);
+            }
+            if (__classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f") != null && __classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").length >= __classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f")[0]) {
+                const resolve = __classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f")[1].resolve;
+                __classPrivateFieldSet(this, _ConnectionTCP_nextResolve, null, "f");
+                resolve();
+            }
+            unlock();
+        });
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").connect(__classPrivateFieldGet(this, _ConnectionTCP_port, "f"), __classPrivateFieldGet(this, _ConnectionTCP_hostname, "f"));
+            __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").once("error", reject);
+            __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").once("connect", () => {
+                __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").off("error", reject);
+                resolve();
+                this.stateChangeHandler?.(true);
+            });
+        });
+    }
+    get connected() {
+        return __classPrivateFieldGet(this, _ConnectionTCP_socket, "f")?.readyState == "open";
+    }
+    async read(p) {
+        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
+        const unlock = await __classPrivateFieldGet(this, _ConnectionTCP_rMutex, "f").lock();
+        try {
+            __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
+            if (__classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").length < p.length) {
+                await new Promise((resolve, reject) => __classPrivateFieldSet(this, _ConnectionTCP_nextResolve, [p.length, { resolve, reject }], "f"));
+            }
+            p.set(__classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").splice(0, p.length));
+        }
+        finally {
+            unlock();
+        }
+    }
+    async write(p) {
+        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
+        const unlock = await __classPrivateFieldGet(this, _ConnectionTCP_wMutex, "f").lock();
+        try {
+            __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
+            try {
+                await new Promise((resolve, reject) => {
+                    __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").write(p, (err) => {
+                        (err === undefined || err == null) ? resolve() : reject(err);
+                    });
+                });
+            }
+            catch (err) {
+                if (!this.connected) {
+                    throw errConnectionNotOpen;
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        finally {
+            unlock();
+        }
+    }
+    close() {
+        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
+        __classPrivateFieldGet(this, _ConnectionTCP_socket, "f").destroy();
+        __classPrivateFieldSet(this, _ConnectionTCP_socket, undefined, "f");
+    }
+}
+_ConnectionTCP_hostname = new WeakMap(), _ConnectionTCP_port = new WeakMap(), _ConnectionTCP_socket = new WeakMap(), _ConnectionTCP_rMutex = new WeakMap(), _ConnectionTCP_wMutex = new WeakMap(), _ConnectionTCP_buffer = new WeakMap(), _ConnectionTCP_nextResolve = new WeakMap(), _ConnectionTCP_instances = new WeakSet(), _ConnectionTCP_rejectRead = function _ConnectionTCP_rejectRead() {
+    if (__classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f") != null) {
+        __classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f")[1].reject(errConnectionNotOpen);
+        __classPrivateFieldSet(this, _ConnectionTCP_nextResolve, null, "f");
+    }
+}, _ConnectionTCP_assertConnected = function _ConnectionTCP_assertConnected() {
+    if (!this.connected) {
+        throw errConnectionNotOpen;
+    }
+};

package/esm/connection/1_connection_web_socket.js

@@ -34,7 +34,7 @@ import { concat, unreachable } from "../0_deps.js";
 import { ConnectionError } from "../0_errors.js";
 import { getLogger, Mutex } from "../1_utilities.js";
 const L = getLogger("ConnectionWebSocket");
-const errConnectionNotOpen = new Error("Connection not open");
+const errConnectionNotOpen = new ConnectionError("Connection not open");
 export class ConnectionWebSocket {
     constructor(url) {
         _ConnectionWebSocket_instances.add(this);