@mtkruto/node 0.0.834 → 0.0.900

package/esm/client/client_abstract.d.ts

@@ -1,7 +1,7 @@
+import { MaybePromise } from "../utilities/0_types.js";
 import { Connection } from "../connection/connection.js";
 import { Transport } from "../transport/transport.js";
 import { DC } from "../transport/transport_provider.js";
-import { MaybePromise } from "../types.js";
 export declare abstract class ClientAbstract {
     protected transportProvider: import("../transport/transport_provider.js").TransportProvider;
     protected connection: Connection;

package/esm/connection/connection.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 export declare abstract class Connection {
     abstract get connected(): boolean;
     abstract open(): MaybePromise<void>;

package/esm/constants.d.ts

@@ -14,3 +14,5 @@ export declare const USERNAME_TTL = 86400;
 export declare const MAX_CHAT_ID = 999999999999;
 export declare const MAX_CHANNEL_ID = 997852516352;
 export declare const ZERO_CHANNEL_ID = -1000000000000;
+export declare const CHANNEL_DIFFERENCE_LIMIT_USER = 100;
+export declare const CHANNEL_DIFFERENCE_LIMIT_BOT = 100000;

package/esm/constants.js

@@ -72,3 +72,5 @@ export const USERNAME_TTL = 86400;
 export const MAX_CHAT_ID = 999999999999;
 export const MAX_CHANNEL_ID = 997852516352;
 export const ZERO_CHANNEL_ID = -1000000000000;
+export const CHANNEL_DIFFERENCE_LIMIT_USER = 100;
+export const CHANNEL_DIFFERENCE_LIMIT_BOT = 100000;

package/esm/deps/deno.land/std@0.190.0/encoding/base64.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * @param data
+ */
+export declare function encode(data: ArrayBuffer | string): string;
+/**
+ * Decodes a given RFC4648 base64 encoded string
+ * @param b64
+ */
+export declare function decode(b64: string): Uint8Array;

package/esm/deps/deno.land/std@0.190.0/encoding/base64.js

@@ -0,0 +1,140 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * {@linkcode encode} and {@linkcode decode} for
+ * [base64](https://en.wikipedia.org/wiki/Base64) encoding.
+ *
+ * This module is browser compatible.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   decode,
+ *   encode,
+ * } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * const b64Repr = "Zm9vYg==";
+ *
+ * const binaryData = decode(b64Repr);
+ * console.log(binaryData);
+ * // => Uint8Array [ 102, 111, 111, 98 ]
+ *
+ * console.log(encode(binaryData));
+ * // => Zm9vYg==
+ * ```
+ *
+ * @module
+ */
+const base64abc = [
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z",
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "+",
+    "/",
+];
+/**
+ * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * @param data
+ */
+export function encode(data) {
+    const uint8 = typeof data === "string"
+        ? new TextEncoder().encode(data)
+        : data instanceof Uint8Array
+            ? data
+            : new Uint8Array(data);
+    let result = "", i;
+    const l = uint8.length;
+    for (i = 2; i < l; i += 3) {
+        result += base64abc[uint8[i - 2] >> 2];
+        result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
+        result += base64abc[((uint8[i - 1] & 0x0f) << 2) | (uint8[i] >> 6)];
+        result += base64abc[uint8[i] & 0x3f];
+    }
+    if (i === l + 1) {
+        // 1 octet yet to write
+        result += base64abc[uint8[i - 2] >> 2];
+        result += base64abc[(uint8[i - 2] & 0x03) << 4];
+        result += "==";
+    }
+    if (i === l) {
+        // 2 octets yet to write
+        result += base64abc[uint8[i - 2] >> 2];
+        result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
+        result += base64abc[(uint8[i - 1] & 0x0f) << 2];
+        result += "=";
+    }
+    return result;
+}
+/**
+ * Decodes a given RFC4648 base64 encoded string
+ * @param b64
+ */
+export function decode(b64) {
+    const binString = atob(b64);
+    const size = binString.length;
+    const bytes = new Uint8Array(size);
+    for (let i = 0; i < size; i++) {
+        bytes[i] = binString.charCodeAt(i);
+    }
+    return bytes;
+}

package/esm/deps/deno.land/x/q@v0.0.1/mod.d.ts

@@ -0,0 +1,6 @@
+export declare function queue<T, R>(runner: (task: T) => R, concurrency: number): {
+    push: (task: T | T[]) => void;
+    drain: (fn?: any) => void | Promise<any>;
+    onError: (fn: (task: T, error: Error) => any) => (task: T, error: Error) => any;
+    onDone: (fn: (task: T, result: R) => any) => (task: T, result: R) => any;
+};

package/esm/deps/deno.land/x/q@v0.0.1/mod.js

@@ -0,0 +1,71 @@
+export function queue(runner, concurrency) {
+    if (concurrency <= 0) {
+        throw new RangeError('concurrency can only be a positive integer');
+    }
+    if (!Number.isInteger(concurrency)) {
+        throw new RangeError('concurrency can only be a positive integer');
+    }
+    const tasks = [];
+    let running = 0;
+    let drains = [];
+    let onError = () => { };
+    let onDone = () => { };
+    let drainAwaiters = [];
+    function drained() {
+        drains.forEach((d) => d());
+        drains = [];
+        drainAwaiters.forEach((s) => s());
+        drainAwaiters = [];
+    }
+    async function runNext() {
+        if (running < concurrency && tasks.length > 0) {
+            running++;
+            const task = tasks.shift();
+            if (task) {
+                try {
+                    const result = await runner(task);
+                    onDone(task, result);
+                }
+                catch (err) {
+                    onError(task, err);
+                }
+            }
+            running--;
+            if (tasks.length > 0) {
+                queueMicrotask(runNext); // to prevent "Maximum call stack size exceeded"
+            }
+            else if (running === 0) {
+                drained();
+            }
+        }
+    }
+    return {
+        push: (task) => {
+            let needed = 1;
+            if (Array.isArray(task)) {
+                tasks.push(...task);
+                needed = task.length;
+            }
+            else {
+                tasks.push(task);
+            }
+            const free = concurrency - running;
+            for (let i = 0; i < Math.max(free, needed); i++) {
+                runNext();
+            }
+        },
+        drain: (fn) => {
+            if (fn) {
+                drains.push(fn);
+            }
+            else if (tasks.length > 0 || running > 0) {
+                return new Promise((resolve) => drainAwaiters.push(resolve));
+            }
+            else {
+                return Promise.resolve();
+            }
+        },
+        onError: (fn) => (onError = fn),
+        onDone: (fn) => (onDone = fn),
+    };
+}

package/esm/deps.d.ts

@@ -5,3 +5,5 @@ export { Mutex } from "async-mutex";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
 import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/master/mod.js";
 export declare const debug: typeof debug_;
+export { queue } from "./deps/deno.land/x/q@v0.0.1/mod.js";
+export { decode as base64Decode, encode as base64Encode } from "./deps/deno.land/std@0.190.0/encoding/base64.js";

package/esm/deps.js

@@ -5,3 +5,5 @@ export { Mutex } from "async-mutex";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
 import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/master/mod.js";
 export const debug = (v) => debug_(`mtkruto__${v}`);
+export { queue } from "./deps/deno.land/x/q@v0.0.1/mod.js";
+export { decode as base64Decode, encode as base64Encode } from "./deps/deno.land/std@0.190.0/encoding/base64.js";

package/esm/mod.d.ts

@@ -7,9 +7,9 @@ export declare const utils: {
 export { as } from "./tl/1_tl_object.js";
 export * as types from "./tl/2_types.js";
 export * as functions from "./tl/3_functions.js";
-export * from "./tl/4_rpc_result.js";
-export * from "./tl/5_message.js";
-export * from "./tl/6_message_container.js";
+export * from "./tl/5_rpc_result.js";
+export * from "./tl/6_message.js";
+export * from "./tl/7_message_container.js";
 export * from "./client/client_plain.js";
 export * from "./client/client.js";
 export * from "./storage/storage.js";

package/esm/mod.js

@@ -4,9 +4,9 @@ export const utils = { checkPassword, getRandomId };
 export { as } from "./tl/1_tl_object.js";
 export * as types from "./tl/2_types.js";
 export * as functions from "./tl/3_functions.js";
-export * from "./tl/4_rpc_result.js";
-export * from "./tl/5_message.js";
-export * from "./tl/6_message_container.js";
+export * from "./tl/5_rpc_result.js";
+export * from "./tl/6_message.js";
+export * from "./tl/7_message_container.js";
 export * from "./client/client_plain.js";
 export * from "./client/client.js";
 export * from "./storage/storage.js";

package/esm/storage/storage.d.ts

@@ -1,5 +1,6 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { DC } from "../transport/transport_provider.js";
+import * as types from "../tl/2_types.js";
 export declare abstract class Storage {
     private _authKeyId;
     abstract init(): MaybePromise<void>;
@@ -20,4 +21,21 @@ export declare abstract class Storage {
     private readonly username__;
     updateUsernames(type: "user" | "channel", id: bigint, usernames: string[]): Promise<void>;
     getUsername(username: string): Promise<readonly ["channel" | "user", bigint, Date] | null>;
+    private readonly state__;
+    setState(state: types.UpdatesState): Promise<void>;
+    getState(): Promise<types.UpdatesState | null>;
+    private readonly channelPts__;
+    setChannelPts(channelId: bigint, pts: number): Promise<void>;
+    getChannelPts(channelId: bigint): Promise<number | null>;
+    private readonly peer__;
+    setEntity(peer: types.Channel): Promise<void>;
+    setEntity(peer: types.Chat): Promise<void>;
+    setEntity(peer: types.User): Promise<void>;
+    getEntity(type: "channel", id: bigint): Promise<types.Channel | null>;
+    getEntity(type: "chat", id: bigint): Promise<types.Chat | null>;
+    getEntity(type: "user", id: bigint): Promise<types.User | null>;
+    getEntity(type: "channel" | "chat" | "user", id: bigint): Promise<types.Channel | types.Chat | types.User | null>;
+    private readonly accountType__;
+    setAccountType(type: "user" | "bot"): Promise<void>;
+    getAccountType(): Promise<"bot" | "user">;
 }

package/esm/storage/storage.js

@@ -1,5 +1,10 @@
+import { base64Decode, base64Encode } from "../deps.js";
+import { UNREACHABLE } from "../utilities/0_control.js";
 import { sha1 } from "../utilities/0_hash.js";
 import { bigIntFromBuffer } from "../utilities/0_bigint.js";
+import { serialize } from "../tl/1_tl_object.js";
+import * as types from "../tl/2_types.js";
+import { TLReader } from "../tl/3_tl_reader.js";
 export class Storage {
     constructor() {
         Object.defineProperty(this, "_authKeyId", {
@@ -26,6 +31,30 @@ export class Storage {
             writable: true,
             value: "username__"
         });
+        Object.defineProperty(this, "state__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "state__"
+        });
+        Object.defineProperty(this, "channelPts__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "channelPts__"
+        });
+        Object.defineProperty(this, "peer__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "peer__"
+        });
+        Object.defineProperty(this, "accountType__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "accountType__"
+        });
     }
     setDc(dc) {
         return this.set("dc", dc);
@@ -95,4 +124,78 @@ export class Storage {
             return null;
         }
     }
+    async setState(state) {
+        await this.set(this.state__, JSON.stringify({
+            date: state.date,
+            pts: state.pts,
+            qts: state.qts,
+            seq: state.seq,
+            unreadCount: state.unreadCount,
+        }));
+    }
+    async getState() {
+        const state__ = await this.get(this.state__);
+        if (state__ != null) {
+            const state_ = JSON.parse(state__);
+            return new types.UpdatesState({
+                date: state_.date,
+                pts: state_.pts,
+                qts: state_.qts,
+                seq: state_.seq,
+                unreadCount: state_.unreadCount,
+            });
+        }
+        else {
+            return null;
+        }
+    }
+    async setChannelPts(channelId, pts) {
+        await this.set(`${this.channelPts__}${channelId}`, String(pts));
+    }
+    async getChannelPts(channelId) {
+        const pts = await this.get(`${this.channelPts__}${channelId}`);
+        if (pts != null) {
+            return Number(pts);
+        }
+        else {
+            return null;
+        }
+    }
+    async setEntity(peer) {
+        const type = peer instanceof types.Channel ? "channel" : peer instanceof types.Chat ? "chat" : peer instanceof types.User ? "user" : UNREACHABLE();
+        await this.set(`${this.peer__}${type}${peer.id}`, base64Encode(peer[serialize]()));
+    }
+    async getEntity(type, id) {
+        const peer_ = await this.get(`${this.peer__}${type}${id}`);
+        if (peer_ != null) {
+            const reader = new TLReader(base64Decode(peer_));
+            return reader.readObject();
+        }
+        else {
+            return null;
+        }
+    }
+    async setAccountType(type) {
+        try {
+            await this.getAccountType();
+            UNREACHABLE();
+        }
+        catch (err) {
+            if (!(err instanceof Error) || !(err.message == "Unreachable")) {
+                throw err;
+            }
+            else {
+                await this.set(this.accountType__, type);
+            }
+        }
+    }
+    async getAccountType() {
+        const accountType = await this.get(this.accountType__);
+        if (accountType != null) {
+            return accountType;
+        }
+        else {
+            UNREACHABLE();
+        }
+    }
 }

package/esm/storage/storage_local_storage.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { Storage } from "./storage.js";
 export declare class StorageLocalStorage extends Storage implements Storage {
     private readonly prefix;

package/esm/storage/storage_memory.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { Storage } from "./storage.js";
 export declare class StorageMemory extends Storage implements Storage {
     protected map: Map<string, string>;

package/esm/storage/storage_session_storage.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { Storage } from "./storage.js";
 export declare class StorageSessionStorage extends Storage implements Storage {
     private readonly prefix;

package/esm/tl/1_tl_object.d.ts

@@ -31,7 +31,6 @@ export declare abstract class TLObject {
     [serialize](): Uint8Array;
     [as]<T extends TLObjectConstructor<InstanceType<T>>>(constructor: T): InstanceType<T>;
 }
-export type MaybeVectorTLObject = TLObject | Array<MaybeVectorTLObject | TLObject>;
 export interface TLObjectConstructor<T = TLObject> {
     new (params: any): T;
     [paramDesc]: ParamDesc;

package/esm/tl/1_tl_object.js

@@ -28,7 +28,7 @@ function serializeSingleParam(writer, value, type, ntype) {
             return;
         }
         else {
-            throw new TypeError(`Expected ${type.name}`);
+            throw new TypeError(`Expected ${type.name} but received ${value == null ? null : value.constructor.name}`);
         }
     }
     if (type == Uint8Array) {

package/esm/tl/4_tl_writer.d.ts

@@ -0,0 +1,5 @@
+import { TLRawWriter } from "./0_tl_raw_writer.js";
+import { ReadObject } from "./3_tl_reader.js";
+export declare class TLWriter extends TLRawWriter {
+    writeObject(object: ReadObject): this;
+}

package/esm/tl/5_rpc_result.d.ts

@@ -0,0 +1,9 @@
+import { id } from "./1_tl_object.js";
+import { ReadObject } from "./3_tl_reader.js";
+export declare class RPCResult {
+    readonly messageId: bigint;
+    readonly result: ReadObject;
+    static get [id](): number;
+    constructor(messageId: bigint, result: ReadObject);
+    static deserialize(buffer: Uint8Array): RPCResult;
+}

package/esm/tl/6_message.d.ts

@@ -0,0 +1,10 @@
+import { ReadObject, TLReader } from "./3_tl_reader.js";
+import { RPCResult } from "./5_rpc_result.js";
+export declare class Message {
+    readonly id: bigint;
+    readonly seqNo: number;
+    readonly body: ReadObject | RPCResult;
+    constructor(id: bigint, seqNo: number, body: ReadObject | RPCResult);
+    serialize(): Uint8Array;
+    static deserialize(reader: TLReader): Message;
+}

package/esm/tl/{5_message.js → 6_message.js}

@@ -1,7 +1,7 @@
 import { id, serialize } from "./1_tl_object.js";
 import { TLReader } from "./3_tl_reader.js";
-import { TLWriter } from "./3_tl_writer.js";
-import { RPCResult } from "./4_rpc_result.js";
+import { TLWriter } from "./4_tl_writer.js";
+import { RPCResult } from "./5_rpc_result.js";
 // TODO: test
 function calculateLength(object) {
     let length = 0;

package/esm/tl/{6_message_container.d.ts → 7_message_container.d.ts}

@@ -1,5 +1,5 @@
 import { id } from "./1_tl_object.js";
-import { Message } from "./5_message.js";
+import { Message } from "./6_message.js";
 export declare class MessageContainer {
     messages: Message[];
     static get [id](): number;

package/esm/tl/{6_message_container.js → 7_message_container.js}

@@ -1,7 +1,7 @@
 import { id } from "./1_tl_object.js";
 import { TLReader } from "./3_tl_reader.js";
-import { TLWriter } from "./3_tl_writer.js";
-import { Message } from "./5_message.js";
+import { TLWriter } from "./4_tl_writer.js";
+import { Message } from "./6_message.js";
 export class MessageContainer {
     static get [id]() {
         return 0x73F1F8DC;

package/esm/transport/transport.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { CTR } from "../utilities/0_crypto.js";
 export declare abstract class Transport {
     protected initialized: boolean;

package/esm/types/0_chat_administrator_rights.d.ts

@@ -0,0 +1,17 @@
+import * as types from "../tl/2_types.js";
+export interface ChatAdministratorRights {
+    isAnonymous: boolean;
+    canManageChat: boolean;
+    canDeleteMessages: boolean;
+    canManageVideoChats: boolean;
+    canRestrictMembers: boolean;
+    canPromoteMembers: boolean;
+    canChangeInfo: boolean;
+    canInviteUsers: boolean;
+    canPostMessages?: boolean;
+    canEditMessages?: boolean;
+    canPinMessages?: boolean;
+    canManageTopics?: boolean;
+}
+export declare function constructChatAdministratorRights(rights_: types.ChatAdminRights): ChatAdministratorRights;
+export declare function chatAdministratorRightsToTlObject(rights: ChatAdministratorRights): types.ChatAdminRights;

package/esm/types/0_chat_administrator_rights.js

@@ -0,0 +1,38 @@
+import * as types from "../tl/2_types.js";
+export function constructChatAdministratorRights(rights_) {
+    const rights = {
+        isAnonymous: rights_.anonymous || false,
+        canManageChat: rights_.other || false,
+        canDeleteMessages: rights_.deleteMessages || false,
+        canManageVideoChats: rights_.manageCall || false,
+        canRestrictMembers: rights_.banUsers || false,
+        canPromoteMembers: rights_.addAdmins || false,
+        canChangeInfo: rights_.changeInfo || false,
+        canInviteUsers: rights_.inviteUsers || false,
+    };
+    if (rights_.postMessages) {
+        rights.canPostMessages = rights_.postMessages;
+    }
+    if (rights_.editMessages) {
+        rights.canEditMessages = rights_.editMessages;
+    }
+    if (rights_.pinMessages) {
+        rights.canPinMessages = rights_.pinMessages;
+    }
+    if (rights_.manageTopics) {
+        rights.canManageTopics = rights_.manageTopics;
+    }
+    return rights;
+}
+export function chatAdministratorRightsToTlObject(rights) {
+    return new types.ChatAdminRights({
+        anonymous: rights.isAnonymous || undefined,
+        other: rights.canManageChat || undefined,
+        deleteMessages: rights.canDeleteMessages || undefined,
+        manageCall: rights.canManageChat || undefined,
+        banUsers: rights.canRestrictMembers || undefined,
+        addAdmins: rights.canPromoteMembers || undefined,
+        changeInfo: rights.canChangeInfo || undefined,
+        inviteUsers: rights.canInviteUsers || undefined,
+    });
+}

package/esm/types/0_chat_photo.d.ts

@@ -0,0 +1,24 @@
+import * as types from "../tl/2_types.js";
+export declare enum ChatPhotoType {
+    Chat = "chat",
+    User = "user"
+}
+export declare namespace ChatPhoto {
+    interface Base {
+        type: ChatPhotoType;
+        hasVideo: boolean;
+        photoId: bigint;
+        strippedThumb?: Uint8Array;
+        dcId: number;
+    }
+    interface User extends Base {
+        type: ChatPhotoType;
+        personal: boolean;
+    }
+    interface Chat extends Base {
+        type: ChatPhotoType;
+    }
+}
+export type ChatPhoto = ChatPhoto.User | ChatPhoto.Chat;
+export declare function constructChatPhoto(photo: types.ChatPhoto): ChatPhoto.Chat;
+export declare function constructChatPhoto(photo: types.UserProfilePhoto): ChatPhoto.User;