@mtkruto/node 0.0.966 → 0.0.968

package/esm/client/0_message.js

@@ -17,11 +17,10 @@ export function getMessageId(lastMsgId) {
     if (lastMsgId >= (newMsgId)) {
         newMsgId = lastMsgId + 4n;
     }
-    lastMsgId = newMsgId;
     return newMsgId;
 }
 export function packUnencryptedMessage(data, messageId) {
-    const message = concat(bufferFromBigInt(0x00, 8), bufferFromBigInt(getMessageId(messageId), 8), bufferFromBigInt(data.length, 4), data);
+    const message = concat(bufferFromBigInt(0x00, 8), bufferFromBigInt(messageId, 8), bufferFromBigInt(data.length, 4), data);
     return message;
 }
 export function unpackUnencryptedMessage(buffer) {

package/esm/client/1_client_abstract.js

@@ -1,11 +1,11 @@
 import { initTgCrypto } from "../deps.js";
 import { DEFAULT_INITIAL_DC } from "../constants.js";
-import { defaultTransportProvider } from "../transport/2_transport_provider.js";
+import { webSocketTransportProvider } from "../transport/2_transport_provider.js";
 export class ClientAbstract {
     get initialDc() {
         return this._initialDc;
     }
-    constructor(transportProvider = defaultTransportProvider({ initialDc: DEFAULT_INITIAL_DC }), cdn = false) {
+    constructor(transportProvider = webSocketTransportProvider({ initialDc: DEFAULT_INITIAL_DC }), cdn = false) {
         Object.defineProperty(this, "transportProvider", {
             enumerable: true,
             configurable: true,

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

@@ -69,8 +69,8 @@ export interface ForwardMessagesParams {
 }
 export declare class Client extends ClientAbstract {
     readonly storage: Storage;
-    readonly apiId: number;
-    readonly apiHash: string;
+    readonly apiId: number | null;
+    readonly apiHash: string | null;
     private auth;
     private sessionId;
     private state;
@@ -93,7 +93,7 @@ export declare class Client extends ClientAbstract {
      * @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(storage?: Storage, apiId?: number, apiHash?: string, params?: ClientParams, cdn?: boolean);
+    constructor(storage?: Storage, apiId?: number | null, apiHash?: string | null, params?: ClientParams, cdn?: boolean);
     private storageInited;
     /**
      * Sets the DC and resets the auth key stored in the session provider

package/esm/client/3_client.js

@@ -372,7 +372,7 @@ export class Client extends ClientAbstract {
                                 apiId: this.apiId,
                                 apiHash: this.apiHash,
                                 phoneNumber,
-                                settings: new types.CodeSettings(),
+                                settings: new types.CodeSettings({}),
                             }));
                             dAuth("verification code sent");
                             if (sentCode instanceof types.AuthSentCode) {
@@ -567,9 +567,8 @@ export class Client extends ClientAbstract {
         const messageId = this.lastMsgId = getMessageId(this.lastMsgId);
         const message = new Message_(messageId, seqNo, function_);
         await this.transport.send(await encryptMessage(message, this.auth.key, this.auth.id, this.state.salt, this.sessionId));
-        const d_ = () => d("invoked %s", function_.constructor.name);
+        d("invoked %s", function_.constructor.name);
         if (noWait) {
-            d_();
             return;
         }
         const result = await new Promise((resolve, reject) => {
@@ -579,7 +578,6 @@ export class Client extends ClientAbstract {
             return await this.invoke(function_);
         }
         else {
-            d_();
             return result;
         }
     }
@@ -1147,8 +1145,7 @@ export class Client extends ClientAbstract {
             noWebpage,
             silent,
             noforwards,
-            replyToMsgId,
-            topMsgId,
+            replyTo: replyToMsgId !== undefined ? new types.InputReplyToMessage({ replyToMsgId, topMsgId }) : undefined,
             sendAs,
             entities,
             replyMarkup,

package/esm/connection/0_connection.d.ts

@@ -1,8 +1,17 @@
 import { MaybePromise } from "../utilities/0_types.js";
-export declare abstract class Connection {
+declare abstract class Foundation {
     abstract get connected(): boolean;
     abstract open(): MaybePromise<void>;
-    abstract read(p: Uint8Array): MaybePromise<void>;
     abstract write(p: Uint8Array): MaybePromise<void>;
     abstract close(): MaybePromise<void>;
 }
+export declare abstract class ConnectionUnframed extends Foundation {
+    readonly type: "framed";
+    abstract read(p: Uint8Array): MaybePromise<void>;
+}
+export declare abstract class ConnectionFramed extends Foundation {
+    readonly type: "framed";
+    abstract read(): MaybePromise<Uint8Array>;
+}
+export type Connection = ConnectionUnframed | ConnectionFramed;
+export {};

package/esm/connection/0_connection.js

@@ -1,2 +1,24 @@
-export class Connection {
+class Foundation {
+}
+export class ConnectionUnframed extends Foundation {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "framed"
+        });
+    }
+}
+export class ConnectionFramed extends Foundation {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "framed"
+        });
+    }
 }

package/esm/connection/1_connection_http.d.ts

@@ -0,0 +1,16 @@
+import { ConnectionFramed } from "./0_connection.js";
+export declare class ConnectionHTTP extends ConnectionFramed implements ConnectionFramed {
+    private readonly url;
+    private rMutex;
+    private wMutex;
+    private resolveCanRead;
+    private canRead;
+    private buffers;
+    constructor(url: string | URL);
+    private resetCanRead;
+    get connected(): boolean;
+    open(): Promise<void>;
+    read(): Promise<Uint8Array>;
+    write(buffer: Uint8Array): Promise<void>;
+    close(): void;
+}

package/esm/connection/1_connection_http.js

@@ -0,0 +1,91 @@
+import { Mutex } from "../deps.js";
+import { UNREACHABLE } from "../utilities/0_control.js";
+import { ConnectionFramed } from "./0_connection.js";
+export class ConnectionHTTP extends ConnectionFramed {
+    constructor(url) {
+        super();
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: url
+        });
+        Object.defineProperty(this, "rMutex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Mutex()
+        });
+        Object.defineProperty(this, "wMutex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Mutex()
+        });
+        Object.defineProperty(this, "resolveCanRead", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => { }
+        });
+        Object.defineProperty(this, "canRead", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: Promise.resolve()
+        });
+        Object.defineProperty(this, "buffers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Array()
+        });
+        this.resetCanRead();
+    }
+    resetCanRead() {
+        this.canRead = new Promise((r) => this.resolveCanRead = r);
+    }
+    get connected() {
+        return true;
+    }
+    async open() {
+    }
+    async read() {
+        await this.canRead;
+        const release = await this.rMutex.acquire();
+        try {
+            const buffer = this.buffers.pop();
+            if (buffer === undefined) {
+                throw UNREACHABLE();
+            }
+            else {
+                return buffer;
+            }
+        }
+        finally {
+            if (this.buffers.length == 0) {
+                this.resetCanRead();
+            }
+            release();
+        }
+    }
+    async write(buffer) {
+        const release = await this.wMutex.acquire();
+        try {
+            const res = await fetch(this.url, {
+                mode: "cors",
+                method: "POST",
+                body: buffer,
+            });
+            this.buffers.push(new Uint8Array(await res.arrayBuffer()));
+        }
+        finally {
+            if (this.buffers.length == 1) {
+                this.resolveCanRead();
+            }
+            release();
+        }
+    }
+    close() {
+    }
+}

package/esm/connection/1_connection_web_socket.d.ts

@@ -1,5 +1,5 @@
-import { Connection } from "./0_connection.js";
-export declare class ConnectionWebSocket implements Connection {
+import { ConnectionUnframed } from "./0_connection.js";
+export declare class ConnectionWebSocket extends ConnectionUnframed implements ConnectionUnframed {
     private webSocket;
     private rMutex;
     private wMutex;

package/esm/connection/1_connection_web_socket.js

@@ -1,8 +1,10 @@
 import * as dntShim from "../_dnt.shims.js";
 import { debug, Mutex } from "../deps.js";
+import { ConnectionUnframed } from "./0_connection.js";
 const d = debug("ConnectionWebSocket");
-export class ConnectionWebSocket {
+export class ConnectionWebSocket extends ConnectionUnframed {
     constructor(url) {
+        super();
         Object.defineProperty(this, "webSocket", {
             enumerable: true,
             configurable: true,
@@ -46,7 +48,6 @@ export class ConnectionWebSocket {
             value: null
         });
         this.webSocket = this.reinitWs(url);
-        // TODO
         this.webSocket.addEventListener("close", (e) => {
             if (e.code != 1000 && e.reason != "method") {
                 this.webSocket = this.reinitWs(url);
@@ -61,7 +62,7 @@ export class ConnectionWebSocket {
                 return;
             }
             const release = await mutex.acquire();
-            const data = new Uint8Array(await new Blob([e.data].map((v) => v instanceof ArrayBuffer ? v : Array.isArray(v) ? v.map((v) => v.buffer) : v.buffer).flat()).arrayBuffer());
+            const data = new Uint8Array(await new Blob([e.data].map((v) => v instanceof Blob ? v : v instanceof ArrayBuffer ? v : Array.isArray(v) ? v.map((v) => v.buffer) : v.buffer).flat()).arrayBuffer());
             for (const byte of data) {
                 this.buffer.push(byte);
             }
@@ -140,6 +141,5 @@ export class ConnectionWebSocket {
             throw new Error("Connection not open");
         }
         this.webSocket.close(1000, "method");
-        console.trace("close called");
     }
 }

package/esm/constants.d.ts

@@ -3,8 +3,8 @@ 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 0.0.966";
+export declare const LAYER = 160;
+export declare const DEFAULT_APP_VERSION = "MTKruto 0.0.968";
 export declare const DEFAULT_DEVICE_MODEL: string;
 export declare const DEFAULT_LANG_CODE: string;
 export declare const DEFAULT_LANG_PACK = "";

package/esm/constants.js

@@ -61,8 +61,8 @@ export const publicKeys = new Map([
 ]);
 export const VECTOR_CONSTRUCTOR = 0x1CB5C415;
 export const DEFAULT_INITIAL_DC = "2-test";
-export const LAYER = 158;
-export const DEFAULT_APP_VERSION = "MTKruto 0.0.966";
+export const LAYER = 160;
+export const DEFAULT_APP_VERSION = "MTKruto 0.0.968";
 // @ts-ignore: lib
 export const DEFAULT_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 DEFAULT_LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];