@mtkruto/node 0.0.830 → 0.0.832

package/esm/client/client.d.ts

@@ -4,7 +4,12 @@ import * as functions from "../tl/3_functions.js";
 import { ClientAbstract } from "./client_abstract.js";
 import { Storage } from "../storage/storage.js";
 import { DC, TransportProvider } from "../transport/transport_provider.js";
+import { MessageEntity } from "../types/0_message_entity.js";
 export declare const restartAuth: unique symbol;
+export declare enum ParseMode {
+    None = "none",
+    HTML = "html"
+}
 export interface AuthorizeUserParams<S = string> {
     phone: S | (() => MaybePromise<S>);
     code: S | (() => MaybePromise<S>);
@@ -12,6 +17,10 @@ export interface AuthorizeUserParams<S = string> {
 }
 export type UpdatesHandler = null | ((client: Client, update: types.Updates) => MaybePromise<void>);
 export interface ClientParams {
+    /**
+     * Default parse mode. Defauls to `ParseMode.None`.
+     */
+    parseMode?: ParseMode;
     /**
      * The transport provider to use. Defaults to `defaultTransportProvider`.
      */
@@ -51,6 +60,7 @@ export declare class Client extends ClientAbstract {
     private promises;
     private toAcknowledge;
     updatesHandler: UpdatesHandler;
+    readonly parseMode: ParseMode;
     readonly appVersion: string;
     readonly deviceModel: string;
     readonly langCode: string;
@@ -113,4 +123,18 @@ export declare class Client extends ClientAbstract {
      * Alias for `invoke` with its second parameter being `true`.
      */
     send<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<void>;
+    private processChats;
+    private processUsers;
+    private processUpdates;
+    getInputPeer(id: string | number): Promise<types.InputPeerChat | types.InputPeerUser | types.InputPeerChannel>;
+    sendMessage(chatId: number | string, text: string, params?: {
+        parseMode?: ParseMode;
+        entities?: MessageEntity[];
+        disableWebPagePreview?: boolean;
+        disableNotification?: boolean;
+        protectContent?: boolean;
+        replyToMessageId?: number;
+        messageThreadId?: number;
+        sendAs?: number | string;
+    }): Promise<types.TypeUpdates>;
 }

package/esm/client/client.js

@@ -1,8 +1,10 @@
 import { gunzip } from "../deps.js";
-import { ackThreshold, DEFAULT_APP_VERSION, DEFAULT_DEVICE_MODEL, DEFAULT_INITIAL_DC, DEFAULT_LANG_CODE, DEFAULT_LANG_PACK, DEFAULT_SYSTEM_LANG_CODE, DEFAULT_SYSTEM_VERSION, LAYER } from "../constants.js";
-import { bigIntFromBuffer, getRandomBigInt } from "../utilities/0_bigint.js";
+import { ackThreshold, DEFAULT_APP_VERSION, DEFAULT_DEVICE_MODEL, DEFAULT_INITIAL_DC, DEFAULT_LANG_CODE, DEFAULT_LANG_PACK, DEFAULT_SYSTEM_LANG_CODE, DEFAULT_SYSTEM_VERSION, LAYER, MAX_CHANNEL_ID, MAX_CHAT_ID, USERNAME_TTL, ZERO_CHANNEL_ID } from "../constants.js";
+import { bigIntFromBuffer, getRandomBigInt, getRandomId } from "../utilities/0_bigint.js";
+import { parseHtml } from "../utilities/0_html.js";
 import { decryptMessage, encryptMessage, getMessageId } from "../utilities/1_message.js";
 import { checkPassword } from "../utilities/1_password.js";
+import { as } from "../tl/1_tl_object.js";
 import * as types from "../tl/2_types.js";
 import * as functions from "../tl/3_functions.js";
 import { TLReader } from "../tl/3_tl_reader.js";
@@ -13,7 +15,13 @@ import { ClientAbstract } from "./client_abstract.js";
 import { ClientPlain } from "./client_plain.js";
 import { StorageMemory } from "../storage/storage_memory.js";
 import { sha1 } from "../utilities/0_hash.js";
+import { messageEntityToTlObject } from "../types/0_message_entity.js";
 export const restartAuth = Symbol();
+export var ParseMode;
+(function (ParseMode) {
+    ParseMode["None"] = "none";
+    ParseMode["HTML"] = "html";
+})(ParseMode || (ParseMode = {}));
 export class Client extends ClientAbstract {
     /**
      * Constructs the client.
@@ -79,6 +87,12 @@ export class Client extends ClientAbstract {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "parseMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "appVersion", {
             enumerable: true,
             configurable: true,
@@ -121,6 +135,7 @@ export class Client extends ClientAbstract {
             writable: true,
             value: false
         });
+        this.parseMode = params?.parseMode ?? ParseMode.None;
         this.appVersion = params?.appVersion ?? DEFAULT_APP_VERSION;
         this.deviceModel = params?.deviceModel ?? DEFAULT_DEVICE_MODEL;
         this.langCode = params?.langCode ?? DEFAULT_LANG_CODE;
@@ -391,7 +406,7 @@ export class Client extends ClientAbstract {
                 }
                 // logger().debug(`Received ${body.constructor.name}`);
                 if (body instanceof types.Updates) {
-                    this.updatesHandler?.(this, body);
+                    this.processUpdates(body);
                 }
                 else if (message.body instanceof RPCResult) {
                     let result = message.body.result;
@@ -404,6 +419,10 @@ export class Client extends ClientAbstract {
                             promise.reject(result);
                         }
                         else {
+                            if (result instanceof types.Updates) {
+                                await this.processChats(result.chats);
+                                await this.processUsers(result.users);
+                            }
                             promise.resolve(result);
                         }
                         this.promises.delete(message.body.messageId);
@@ -472,4 +491,148 @@ export class Client extends ClientAbstract {
     send(function_) {
         return this.invoke(function_, true);
     }
+    async processChats(chats) {
+        for (const chat of chats) {
+            if (chat instanceof types.Channel && chat.accessHash) {
+                await this.storage.setChannelAccessHash(chat.id, chat.accessHash);
+                if (chat.username) {
+                    await this.storage.updateUsernames("channel", chat.id, [chat.username]);
+                }
+                if (chat.usernames) {
+                    await this.storage.updateUsernames("channel", chat.id, chat.usernames.map((v) => v[as](types.Username)).map((v) => v.username));
+                }
+            }
+        }
+    }
+    async processUsers(users) {
+        for (const user of users) {
+            if (user instanceof types.User && user.accessHash) {
+                await this.storage.setUserAccessHash(user.id, user.accessHash);
+                if (user.username) {
+                    await this.storage.updateUsernames("user", user.id, [user.username]);
+                }
+                if (user.usernames) {
+                    await this.storage.updateUsernames("user", user.id, user.usernames.map((v) => v[as](types.Username)).map((v) => v.username));
+                }
+            }
+        }
+    }
+    async processUpdates(updates) {
+        try {
+            await this.processChats(updates.chats);
+            await this.processUsers(updates.users);
+            for (const update of updates.updates) {
+                if (update instanceof types.UpdateUserName) {
+                    await this.storage.updateUsernames("user", update.userId, update.usernames.map((v) => v[as](types.Username)).map((v) => v.username));
+                }
+            }
+            await this.updatesHandler?.(this, updates);
+        }
+        catch (err) {
+            console.error("Error processing updates:", err);
+        }
+    }
+    async getInputPeer(id) {
+        if (typeof id === "string") {
+            if (!id.startsWith("@")) {
+                throw new Error("Expected username to start with @");
+            }
+            else {
+                id = id.slice(1);
+                if (!id) {
+                    throw new Error("Empty username");
+                }
+                let userId = 0n;
+                let channelId = 0n;
+                const maybeUsername = await this.storage.getUsername(id);
+                if (maybeUsername != null && Date.now() - maybeUsername[2].getTime() < USERNAME_TTL) {
+                    const [type, id] = maybeUsername;
+                    if (type == "user") {
+                        userId = id;
+                    }
+                    else {
+                        channelId = id;
+                    }
+                }
+                else {
+                    const resolved = await this.invoke(new functions.ContactsResolveUsername({ username: id }));
+                    await this.processChats(resolved.chats);
+                    await this.processUsers(resolved.users);
+                    if (resolved.peer instanceof types.PeerUser) {
+                        userId = resolved.peer.userId;
+                    }
+                    else if (resolved.peer instanceof types.PeerChannel) {
+                        channelId = resolved.peer.channelId;
+                    }
+                    else {
+                        throw new Error("Unreachable");
+                    }
+                }
+                if (userId) {
+                    const accessHash = await this.storage.getUserAccessHash(userId);
+                    return new types.InputPeerUser({ userId, accessHash: accessHash ?? 0n });
+                }
+                else if (channelId) {
+                    const accessHash = await this.storage.getChannelAccessHash(channelId);
+                    return new types.InputPeerChannel({ channelId, accessHash: accessHash ?? 0n });
+                }
+                else {
+                    throw new Error("Unreachable");
+                }
+            }
+        }
+        else if (id > 0) {
+            const id_ = BigInt(id);
+            const accessHash = await this.storage.getUserAccessHash(id_);
+            return new types.InputPeerUser({ userId: id_, accessHash: accessHash ?? 0n });
+        }
+        else if (-MAX_CHAT_ID <= id) {
+            return new types.InputPeerChat({ chatId: BigInt(Math.abs(id)) });
+        }
+        else if (ZERO_CHANNEL_ID - MAX_CHANNEL_ID <= id && id != ZERO_CHANNEL_ID) {
+            const id_ = BigInt(Math.abs(id - ZERO_CHANNEL_ID));
+            const accessHash = await this.storage.getChannelAccessHash(id_);
+            return new types.InputPeerChannel({ channelId: id_, accessHash: accessHash ?? 0n });
+        }
+        else {
+            throw new Error("ID format unknown or not implemented");
+        }
+    }
+    async sendMessage(chatId, text, params) {
+        const entities_ = params?.entities ?? [];
+        const parseMode = params?.parseMode ?? this.parseMode;
+        switch (parseMode) {
+            case ParseMode.None:
+                break;
+            case ParseMode.HTML: {
+                const [newText, entitiesToPush] = parseHtml(text);
+                text = newText;
+                for (const entity of entitiesToPush) {
+                    entities_.push(entity);
+                }
+            }
+        }
+        const peer = await this.getInputPeer(chatId);
+        const randomId = getRandomId();
+        const message = text;
+        const noWebpage = params?.disableWebPagePreview ? true : undefined;
+        const silent = params?.disableNotification ? true : undefined;
+        const noforwards = params?.protectContent ? true : undefined;
+        const replyToMsgId = params?.replyToMessageId;
+        const topMsgId = params?.messageThreadId;
+        const sendAs = params?.sendAs ? await this.getInputPeer(params.sendAs) : undefined;
+        const entities = entities_?.length > 0 ? entities_.map((v) => messageEntityToTlObject(v)) : undefined;
+        return await this.invoke(new functions.MessagesSendMessage({
+            peer,
+            randomId,
+            message,
+            noWebpage,
+            silent,
+            noforwards,
+            replyToMsgId,
+            topMsgId,
+            sendAs,
+            entities,
+        }));
+    }
 }

package/esm/constants.d.ts

@@ -10,3 +10,7 @@ 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";
+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;

package/esm/constants.js

@@ -68,3 +68,7 @@ export const DEFAULT_LANG_CODE = "en";
 export const DEFAULT_LANG_PACK = "";
 export const DEFAULT_SYSTEM_LANG_CODE = "en";
 export const DEFAULT_SYSTEM_VERSION = "1.0";
+export const USERNAME_TTL = 86400;
+export const MAX_CHAT_ID = 999999999999;
+export const MAX_CHANNEL_ID = 997852516352;
+export const ZERO_CHANNEL_ID = -1000000000000;

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/DomHandler.d.ts

@@ -0,0 +1,83 @@
+import { Node, Element, Document, NodeWithChildren, DataNode } from './Node.js';
+export interface DomHandlerOptions {
+    /**
+     * Add a `startIndex` property to nodes.
+     * When the parser is used in a non-streaming fashion, `startIndex` is an integer
+     * indicating the position of the start of the node in the document.
+     *
+     * @default false
+     */
+    withStartIndices?: boolean;
+    /**
+     * Add an `endIndex` property to nodes.
+     * When the parser is used in a non-streaming fashion, `endIndex` is an integer
+     * indicating the position of the end of the node in the document.
+     *
+     * @default false
+     */
+    withEndIndices?: boolean;
+    /**
+     * Replace all whitespace with single spaces.
+     *
+     * **Note:** Enabling this might break your markup.
+     *
+     * @default false
+     * @deprecated
+     */
+    normalizeWhitespace?: boolean;
+    /**
+     * Treat the markup as XML.
+     *
+     * @default false
+     */
+    xmlMode?: boolean;
+}
+interface ParserInterface {
+    startIndex: number | null;
+    endIndex: number | null;
+}
+type Callback = (error: Error | null, dom: Node[]) => void;
+type ElementCallback = (element: Element) => void;
+export declare class DomHandler {
+    /** The elements of the DOM */
+    dom: Node[];
+    /** The root element for the DOM */
+    root: Document;
+    /** Called once parsing has completed. */
+    private readonly callback;
+    /** Settings for the handler. */
+    private readonly options;
+    /** Callback whenever a tag is closed. */
+    private readonly elementCB;
+    /** Indicated whether parsing has been completed. */
+    private done;
+    /** Stack of open tags. */
+    protected tagStack: NodeWithChildren[];
+    /** A data node that is still being written to. */
+    protected lastNode: DataNode | null;
+    /** Reference to the parser instance. Used for location information. */
+    private parser;
+    /**
+     * @param callback Called once parsing has completed.
+     * @param options Settings for the handler.
+     * @param elementCB Callback whenever a tag is closed.
+     */
+    constructor(callback?: Callback | null, options?: DomHandlerOptions | null, elementCB?: ElementCallback);
+    onparserinit(parser: ParserInterface): void;
+    onreset(): void;
+    onend(): void;
+    onerror(error: Error): void;
+    onclosetag(): void;
+    onopentag(name: string, attribs: {
+        [key: string]: string;
+    }): void;
+    ontext(data: string): void;
+    oncomment(data: string): void;
+    oncommentend(): void;
+    oncdatastart(): void;
+    oncdataend(): void;
+    onprocessinginstruction(name: string, data: string): void;
+    protected handleCallback(error: Error | null): void;
+    protected addNode(node: Node): void;
+}
+export default DomHandler;

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/DomHandler.js

@@ -0,0 +1,203 @@
+import { Element, Document, NodeWithChildren, Comment, Text, ProcessingInstruction, } from './Node.js';
+import { ElementType } from './ElementType.js';
+const reWhitespace = /\s+/g;
+// Default options
+const defaultOpts = {
+    normalizeWhitespace: false,
+    withStartIndices: false,
+    withEndIndices: false,
+};
+export class DomHandler {
+    /**
+     * @param callback Called once parsing has completed.
+     * @param options Settings for the handler.
+     * @param elementCB Callback whenever a tag is closed.
+     */
+    constructor(callback, options, elementCB) {
+        /** The elements of the DOM */
+        Object.defineProperty(this, "dom", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        /** The root element for the DOM */
+        Object.defineProperty(this, "root", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Document(this.dom)
+        });
+        /** Called once parsing has completed. */
+        Object.defineProperty(this, "callback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Settings for the handler. */
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Callback whenever a tag is closed. */
+        Object.defineProperty(this, "elementCB", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Indicated whether parsing has been completed. */
+        Object.defineProperty(this, "done", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** Stack of open tags. */
+        Object.defineProperty(this, "tagStack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [this.root]
+        });
+        /** A data node that is still being written to. */
+        Object.defineProperty(this, "lastNode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** Reference to the parser instance. Used for location information. */
+        Object.defineProperty(this, "parser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Make it possible to skip arguments, for backwards-compatibility
+        if (typeof options === 'function') {
+            elementCB = options;
+            options = defaultOpts;
+        }
+        if (typeof callback === 'object') {
+            options = callback;
+            callback = undefined;
+        }
+        this.callback = callback ?? null;
+        this.options = options ?? defaultOpts;
+        this.elementCB = elementCB ?? null;
+    }
+    onparserinit(parser) {
+        this.parser = parser;
+    }
+    // Resets the handler back to starting state
+    onreset() {
+        this.dom = [];
+        this.root = new Document(this.dom);
+        this.done = false;
+        this.tagStack = [this.root];
+        this.lastNode = null;
+        this.parser = this.parser ?? null;
+    }
+    // Signals the handler that parsing is done
+    onend() {
+        if (this.done)
+            return;
+        this.done = true;
+        this.parser = null;
+        this.handleCallback(null);
+    }
+    onerror(error) {
+        this.handleCallback(error);
+    }
+    onclosetag() {
+        this.lastNode = null;
+        const elem = this.tagStack.pop();
+        if (this.options.withEndIndices) {
+            elem.endIndex = this.parser.endIndex;
+        }
+        if (this.elementCB)
+            this.elementCB(elem);
+    }
+    onopentag(name, attribs) {
+        const type = this.options.xmlMode ? ElementType.Tag : undefined;
+        const element = new Element(name, attribs, undefined, type);
+        this.addNode(element);
+        this.tagStack.push(element);
+    }
+    ontext(data) {
+        const { normalizeWhitespace } = this.options;
+        const { lastNode } = this;
+        if (lastNode && lastNode.type === ElementType.Text) {
+            if (normalizeWhitespace) {
+                lastNode.data = (lastNode.data + data).replace(reWhitespace, ' ');
+            }
+            else {
+                lastNode.data += data;
+            }
+        }
+        else {
+            if (normalizeWhitespace) {
+                data = data.replace(reWhitespace, ' ');
+            }
+            const node = new Text(data);
+            this.addNode(node);
+            this.lastNode = node;
+        }
+    }
+    oncomment(data) {
+        if (this.lastNode && this.lastNode.type === ElementType.Comment) {
+            this.lastNode.data += data;
+            return;
+        }
+        const node = new Comment(data);
+        this.addNode(node);
+        this.lastNode = node;
+    }
+    oncommentend() {
+        this.lastNode = null;
+    }
+    oncdatastart() {
+        const text = new Text('');
+        const node = new NodeWithChildren(ElementType.CDATA, [text]);
+        this.addNode(node);
+        text.parent = node;
+        this.lastNode = text;
+    }
+    oncdataend() {
+        this.lastNode = null;
+    }
+    onprocessinginstruction(name, data) {
+        const node = new ProcessingInstruction(name, data);
+        this.addNode(node);
+    }
+    handleCallback(error) {
+        if (typeof this.callback === 'function') {
+            this.callback(error, this.dom);
+        }
+        else if (error) {
+            throw error;
+        }
+    }
+    addNode(node) {
+        const parent = this.tagStack[this.tagStack.length - 1];
+        const previousSibling = parent.children[parent.children.length - 1];
+        if (this.options.withStartIndices) {
+            node.startIndex = this.parser.startIndex;
+        }
+        if (this.options.withEndIndices) {
+            node.endIndex = this.parser.endIndex;
+        }
+        parent.children.push(node);
+        if (previousSibling) {
+            node.prev = previousSibling;
+            previousSibling.next = node;
+        }
+        node.parent = parent;
+        this.lastNode = null;
+    }
+}
+export default DomHandler;

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/DomSerializer.d.ts

@@ -0,0 +1,50 @@
+import type { Node } from './Node.js';
+/**
+ * Mixed-case SVG and MathML tags & attributes
+ * recognized by the HTML parser.
+ *
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign
+ */
+export declare const elementNames: Map<string, string>;
+export declare const attributeNames: Map<string, string>;
+export interface DomSerializerOptions {
+    /**
+     * Print an empty attribute's value.
+     *
+     * @default xmlMode
+     * @example With <code>emptyAttrs: false</code>: <code>&lt;input checked&gt;</code>
+     * @example With <code>emptyAttrs: true</code>: <code>&lt;input checked=""&gt;</code>
+     */
+    emptyAttrs?: boolean;
+    /**
+     * Print self-closing tags for tags without contents.
+     *
+     * @default xmlMode
+     * @example With <code>selfClosingTags: false</code>: <code>&lt;foo&gt;&lt;/foo&gt;</code>
+     * @example With <code>selfClosingTags: true</code>: <code>&lt;foo /&gt;</code>
+     */
+    selfClosingTags?: boolean;
+    /**
+     * Treat the input as an XML document; enables the `emptyAttrs` and `selfClosingTags` options.
+     *
+     * If the value is `"foreign"`, it will try to correct mixed-case attribute names.
+     *
+     * @default false
+     */
+    xmlMode?: boolean | 'foreign';
+    /**
+     * Encode characters that are either reserved in HTML or XML, or are outside of the ASCII range.
+     *
+     * @default true
+     */
+    decodeEntities?: boolean;
+}
+/**
+ * Renders a DOM node or an array of DOM nodes to a string.
+ *
+ * Can be thought of as the equivalent of the `outerHTML` of the passed node(s).
+ *
+ * @param node Node to be rendered.
+ * @param options Changes serialization behavior
+ */
+export default function render(node: Node | ArrayLike<Node>, options?: DomSerializerOptions): string;