rubjs 1.1.0 → 2.2.3

package/rubjs/network/index.js

@@ -51,6 +51,7 @@ const crypto_1 = __importDefault(require("../crypto"));
 const https_1 = __importDefault(require("https"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const types_1 = require("../types");
 class Network {
     constructor(client) {
         this.heartbeatInterval = null;
@@ -76,8 +77,8 @@ class Network {
             httpsAgent: this.agent,
         };
         this.session = axios_1.default.create(axiosConfig);
-        this.api_url = null;
-        this.wss_url = null;
+        this.apiUrl = null;
+        this.wssUrl = null;
         this.ws = null;
     }
     getDcs() {
@@ -89,8 +90,8 @@ class Network {
                     });
                     if (response.status === 200) {
                         const data = response.data.data;
-                        this.api_url = data.API[data.default_api] + "/";
-                        this.wss_url = data.socket[data.default_socket];
+                        this.apiUrl = data.API[data.default_api] + "/";
+                        this.wssUrl = data.socket[data.default_socket];
                         return true;
                     }
                 }
@@ -123,9 +124,9 @@ class Network {
             let api_version = this.client.apiVersion;
             let auth = this.client.auth;
             let client = this.client.defaultPlatform;
-            if (!this.api_url)
+            if (!this.apiUrl)
                 yield this.getDcs();
-            let url = this.api_url;
+            let url = this.apiUrl;
             let data = { api_version };
             data[tmp_session ? "tmp_session" : "auth"] = tmp_session
                 ? auth
@@ -146,9 +147,9 @@ class Network {
     }
     getUpdates() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.wss_url)
+            if (!this.wssUrl)
                 yield this.getDcs();
-            this.ws = new ws_1.default(this.wss_url);
+            this.ws = new ws_1.default(this.wssUrl);
             this.ws.on("open", () => __awaiter(this, void 0, void 0, function* () { return yield this.handleConnect(); }));
             this.ws.on("message", (message) => __awaiter(this, void 0, void 0, function* () { return yield this.handleMessage(message); }));
             this.ws.on("error", () => __awaiter(this, void 0, void 0, function* () { return yield this.resetConnection(); }));
@@ -193,8 +194,9 @@ class Network {
                         return;
                     const isValid = filters.length === 0 ||
                         filters.every((filter) => filter(messageData));
+                    const dataMessage = new types_1.Message(this.client, messageData);
                     if (isValid) {
-                        yield callback(messageData);
+                        yield callback(dataMessage);
                     }
                 }));
             }
@@ -203,7 +205,7 @@ class Network {
             }
         });
     }
-    upload_file(file_1) {
+    uploadFile(file_1) {
         return __awaiter(this, arguments, void 0, function* (file, mime = null, fileName = null, chunk = 1048576, callback = null) {
             if (typeof file === "string") {
                 if (!fs.existsSync(file))
@@ -218,7 +220,7 @@ class Network {
                 throw new Error("File name is not set");
             if (!mime)
                 mime = fileName.split(".").pop() || "";
-            let result = yield this.client.request_send_file(fileName, file.length, mime);
+            let result = yield this.client.requestSendFile(fileName, file.length, mime);
             let response;
             let id = result.id;
             let index = 0;
@@ -241,7 +243,7 @@ class Network {
                     });
                     if (response.data.status === "ERROR_TRY_AGAIN") {
                         console.log("Retrying upload...");
-                        result = yield this.client.request_send_file(fileName, file.length, mime);
+                        result = yield this.client.requestSendFile(fileName, file.length, mime);
                         id = result.id;
                         index = 0;
                         dc_id = result.dc_id;

package/rubjs/parser/index.d.ts

@@ -0,0 +1,25 @@
+type MarkdownEntity = {
+    type: string;
+    from_index: number;
+    length: number;
+    language?: string;
+    mention_text_object_guid?: string;
+    mention_text_object_type?: string;
+    link?: {
+        type: string;
+        hyperlink_data: {
+            url: string;
+        };
+    };
+};
+declare class Markdown {
+    static markdownRegExp: RegExp;
+    static markdownEntities: Record<string, string>;
+    static toMetadata(text: string): {
+        text: string;
+        metadata?: {
+            meta_data_parts: MarkdownEntity[];
+        };
+    };
+}
+export default Markdown;

package/rubjs/parser/index.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Markdown {
+    static toMetadata(text) {
+        let entities = [];
+        let match;
+        let remainingText = text;
+        let parsedTextParts = [];
+        let offset = 0;
+        while ((match = remainingText.match(this.markdownRegExp))) {
+            const matchIndex = offset + (match.index || 0);
+            parsedTextParts.push(remainingText.substring(0, match.index));
+            let matchedContent = match[3] || match[8] || match[11] || match[13];
+            if (matchedContent) {
+                offset -= matchedContent.length;
+                matchedContent = matchedContent.trim();
+                offset += matchedContent.length;
+                if (/^`*$/.test(matchedContent)) {
+                    parsedTextParts.push(match[0]);
+                }
+                else if (match[3]) {
+                    if (match[5] === "\n") {
+                        match[5] = "";
+                        offset -= 1;
+                    }
+                    parsedTextParts.push(match[1] + matchedContent + match[5]);
+                    entities.push({
+                        type: "Pre",
+                        language: "",
+                        from_index: matchIndex + match[1].length,
+                        length: matchedContent.length,
+                    });
+                    offset -= match[2].length + match[4].length;
+                }
+                else if (match[7]) {
+                    parsedTextParts.push(match[6] + matchedContent + match[9]);
+                    entities.push({
+                        type: this.markdownEntities[match[7]],
+                        from_index: matchIndex + match[6].length,
+                        length: matchedContent.length,
+                    });
+                    offset -= 2 * match[7].length;
+                }
+                else if (match[11]) {
+                    parsedTextParts.push(matchedContent);
+                    entities.push({
+                        type: "MentionText",
+                        mention_text_object_guid: match[10],
+                        from_index: matchIndex,
+                        length: matchedContent.length,
+                        mention_text_object_type: "User",
+                    });
+                    offset -= match[0].length - matchedContent.length;
+                }
+                else if (match[12]) {
+                    const [label, url] = [match[12], match[13]];
+                    let mentionType;
+                    if (url.length === 32) {
+                        if (url.startsWith("u"))
+                            mentionType = "User";
+                        else if (url.startsWith("g"))
+                            mentionType = "Group";
+                        else if (url.startsWith("c"))
+                            mentionType = "Channel";
+                    }
+                    parsedTextParts.push(label);
+                    const metaDataPart = {
+                        type: mentionType ? "MentionText" : "Link",
+                        from_index: matchIndex,
+                        length: label.length,
+                    };
+                    if (mentionType) {
+                        metaDataPart.mention_text_object_guid = url;
+                        metaDataPart.mention_text_object_type = mentionType;
+                    }
+                    else {
+                        metaDataPart.link = { type: "hyperlink", hyperlink_data: { url } };
+                    }
+                    entities.push(metaDataPart);
+                    offset -= match[0].length - label.length;
+                }
+                remainingText = remainingText.substring(match.index + match[0].length);
+                offset += match.index + match[0].length;
+            }
+        }
+        parsedTextParts.push(remainingText);
+        let resultText = parsedTextParts.join("");
+        if (!resultText.replace(/\s+/g, "").length) {
+            resultText = text;
+            entities.splice(0, entities.length);
+        }
+        if (!entities.length) {
+            resultText = resultText.trim();
+        }
+        return {
+            text: resultText,
+            metadata: { meta_data_parts: entities },
+        };
+    }
+}
+Markdown.markdownRegExp = /(^|\s|\n)(````?)([\s\S]+?)(````?)([\s\n\.,:?!;]|$)|(^|\s)(`|\*\*|__|~~|--|\|\|)([^\n]+?)\7([\s\.,:?!;]|$)|@([a-zA-Z0-9]+)\s*\((.+?)\)|\[(.+?)\]\((.+?)\)/m;
+Markdown.markdownEntities = {
+    "`": "Mono",
+    "**": "Bold",
+    __: "Italic",
+    "||": "Spoiler",
+    "~~": "Strike",
+    "--": "Underline",
+};
+exports.default = Markdown;

package/rubjs/session/index.js

@@ -8,7 +8,6 @@ class SQLiteSession {
     constructor(sessionName) {
         this.dbFile = sessionName.endsWith(".rp") ? sessionName : `${sessionName}.rp`;
         this.db = new better_sqlite3_1.default(this.dbFile);
-        this.db.pragma("journal_mode = WAL");
         this.initializeDB();
     }
     handleError(operation, callback) {
@@ -22,6 +21,7 @@ class SQLiteSession {
     }
     initializeDB() {
         this.handleError("initializeDB", () => {
+            this.db.pragma("journal_mode = DELETE");
             const sessionTable = this.db
                 .prepare("SELECT name FROM sqlite_master WHERE type=? AND name=?")
                 .get("table", "session");

package/rubjs/{methods/auth/types/sign_in.d.ts → types/auth.d.ts}

@@ -1,3 +1,12 @@
+interface SendCode {
+    phone_code_hash: string;
+    status: string;
+    code_digits_count: number;
+    has_confirmed_recovery_email: boolean;
+    no_recovery_alert: string;
+    send_type: string;
+    hint_pass_key: string;
+}
 interface AvatarThumbnail {
     file_id: string;
     mime: string;
@@ -27,4 +36,5 @@ interface SignIn {
     user: User;
     timestamp: number;
 }
-export default SignIn;
+export { SignIn, SendCode };
+export default SendCode;

package/rubjs/types/chats.d.ts

@@ -0,0 +1,79 @@
+import MessageUpdate, { ChatUpdates } from "./decorators";
+interface Avatar {
+    file_id: string;
+    mime: string;
+    dc_id: string;
+    access_hash_rec: string;
+}
+interface getTopChatUsers {
+    abs_users: {
+        object_guid: string;
+        type: string;
+        first_name: string;
+        avatar_thumbnail: Avatar;
+        is_verified: boolean;
+        is_deleted: boolean;
+    }[];
+    timestamp: string;
+}
+interface GetObjectInfoByUsername {
+    exist: boolean;
+    type: string;
+    channel: {
+        channel_guid: string;
+        channel_title: string;
+        avatar_thumbnail: Avatar;
+        count_members: number;
+        description: string;
+        username: string;
+        is_deleted: boolean;
+        is_verified: boolean;
+        share_url: string;
+        channel_type: string;
+        sign_messages: boolean;
+        chat_reaction_setting: {
+            reaction_type: string;
+            selected_reactions: string[];
+        };
+        is_restricted_content: boolean;
+    };
+    chat: {
+        object_guid: string;
+        access: string[];
+        count_unseen: number;
+        is_mute: boolean;
+        is_pinned: boolean;
+        time_string: string;
+        last_message: {
+            message_id: string;
+            type: string;
+            text: string;
+            is_mine: boolean;
+        };
+        last_seen_my_mid: string;
+        last_seen_peer_mid: string;
+        status: string;
+        time: number;
+        pinned_message_id: string;
+        abs_object: {
+            object_guid: string;
+            type: string;
+            title: string;
+            avatar_thumbnail: [Object];
+            is_verified: boolean;
+            is_deleted: boolean;
+        };
+        is_blocked: boolean;
+        last_message_id: string;
+        last_deleted_mid: string;
+        pinned_message_ids: string[];
+    };
+    timestamp: string;
+}
+interface SendLive {
+    message_update: MessageUpdate;
+    chat_update: ChatUpdates;
+    status: string;
+    publish_text: string;
+}
+export { getTopChatUsers, GetObjectInfoByUsername, SendLive };

package/rubjs/{methods/types/message_update.d.ts → types/decorators.d.ts}

@@ -74,6 +74,16 @@ interface PollData {
     type: string;
     allows_multiple_answers: boolean;
 }
+interface MetaData {
+    meta_data_parts: {
+        from_index: number;
+        length: number;
+        type: string;
+        link?: {
+            url: string;
+        };
+    }[];
+}
 interface Message {
     message_id: string;
     text?: string;
@@ -95,6 +105,7 @@ interface Message {
         message_id: string;
         object_guid: string;
     };
+    metadata?: MetaData;
     count_seen?: string;
     thumb_inline?: string;
 }
@@ -109,4 +120,49 @@ interface MessageUpdate {
     type: string;
     state: string;
 }
+interface ChatUpdates {
+    object_guid: string;
+    action: string;
+    chat: {
+        time_string: string;
+        last_message: {
+            message_id: string;
+            type: string;
+            text: string;
+            author_object_guid?: string;
+            is_mine: boolean;
+            author_title?: string;
+            author_type?: string;
+        };
+        last_seen_peer_mid?: string;
+        last_seen_my_mid?: string;
+        status?: string;
+        time: number;
+        last_message_id: string;
+        group_voice_chat_id?: string;
+    };
+    updated_parameters: string[];
+    timestamp: string;
+    type: string;
+}
+interface ShowActivities {
+    type: string;
+    object_guid: string;
+    object_type: string;
+    user_activity_guid: string;
+}
+interface ShowNotifications {
+    notification_id: string;
+    type: string;
+    title: string;
+    text: string;
+    image_file_id?: number;
+    message_data: {
+        object_guid: string;
+        object_type: string;
+        message_id: number;
+        sender_guid?: string;
+    };
+}
+export { MessageUpdate, ChatUpdates, ShowActivities, ShowNotifications, Message, FileInline };
 export default MessageUpdate;

package/rubjs/types/groups.d.ts

@@ -0,0 +1,129 @@
+import MessageUpdate, { ChatUpdates } from "./decorators";
+interface ChatReactionSetting {
+    reaction_type: string;
+}
+interface Group {
+    group_guid: string;
+    group_title: string;
+    count_members: number;
+    is_deleted: boolean;
+    is_verified: boolean;
+    slow_mode: number;
+    chat_history_for_new_members: string;
+    event_messages: boolean;
+    chat_reaction_setting: ChatReactionSetting;
+    is_restricted_content: boolean;
+}
+interface Chat {
+    object_guid: string;
+    access: string[];
+    count_unseen: number;
+    is_mute: boolean;
+    is_pinned: boolean;
+    time_string: string;
+    last_message: {
+        message_id: string;
+        type: string;
+        text: string;
+    };
+    last_seen_my_mid: string;
+    last_seen_peer_mid: string;
+    status: string;
+    time: number;
+    abs_object: {
+        object_guid: string;
+        type: string;
+        title: string;
+        is_verified: boolean;
+        is_deleted: boolean;
+    };
+    is_blocked: boolean;
+    last_message_id: string;
+    last_deleted_mid: string;
+    slow_mode_duration: number;
+}
+interface ChatUpdate {
+    object_guid: string;
+    action: string;
+    updated_parameters: [];
+    timestamp: string;
+    type: string;
+    chat?: Chat;
+}
+interface GroupVoiceChat {
+    voice_chat_id: string;
+    state: string;
+    join_muted: boolean;
+    participant_count: number;
+    title: string;
+    version: number;
+}
+interface GroupVoiceChatUpdate {
+    voice_chat_id: string;
+    group_guid: string;
+    action: string;
+    group_voice_chat: GroupVoiceChat;
+    updated_parameters: [];
+    timestamp: string;
+    chat_guid_type: {
+        type: string;
+        object_guid: string;
+    };
+}
+interface GroupMember {
+    member_type: string;
+    member_guid: string;
+    first_name: string;
+    last_name: string;
+    avatar_thumbnail: {
+        file_id: string;
+        mime: string;
+        dc_id: string;
+        access_hash_rec: string;
+    };
+    is_verified: boolean;
+    is_deleted: boolean;
+    last_online: number;
+    join_type: string;
+    username: string;
+    online_time: {
+        type: string;
+        exact_time: number;
+    };
+}
+interface AddGroup {
+    group: Group;
+    chat_update: ChatUpdate;
+    message_update: MessageUpdate;
+    timestamp: string;
+}
+interface DeleteNoAccessGroupChat {
+    chat_update: ChatUpdate;
+    status: string;
+}
+interface CreateGroupVoiceChat {
+    status: string;
+    chat_update: ChatUpdates;
+    message_update: MessageUpdate;
+    group_voice_chat_update: GroupVoiceChatUpdate;
+}
+interface AddGroupMembers {
+    chat_update: ChatUpdates;
+    message_update: MessageUpdate;
+    added_in_chat_members: GroupMember[];
+    timestamp: string;
+    group: Group;
+}
+interface BanGroupMember {
+    chat_update: ChatUpdates;
+    message_update: MessageUpdate;
+    timestamp: string;
+    group: Group;
+}
+interface GetBannedGroupMembers {
+    in_chat_members: GroupMember[];
+    next_start_id: "67b0e8bc1b50d7bec6fc950b";
+    has_continue: false;
+    timestamp: "1739888215";
+}
+export { AddGroup, DeleteNoAccessGroupChat, CreateGroupVoiceChat, AddGroupMembers, BanGroupMember, GetBannedGroupMembers };

package/rubjs/types/index.d.ts

@@ -0,0 +1,8 @@
+import * as DecoratorsTypes from "./decorators";
+import * as UserTypes from "./users";
+import * as AuthTypes from "./auth";
+import * as MessagesTypes from "./messages";
+import * as GroupTypes from "./groups";
+import * as ChatTypes from "./chats";
+import Message from "./message";
+export { DecoratorsTypes, UserTypes, MessagesTypes, AuthTypes, GroupTypes, ChatTypes, Message, };

package/rubjs/types/index.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = exports.ChatTypes = exports.GroupTypes = exports.AuthTypes = exports.MessagesTypes = exports.UserTypes = exports.DecoratorsTypes = void 0;
+const DecoratorsTypes = __importStar(require("./decorators"));
+exports.DecoratorsTypes = DecoratorsTypes;
+const UserTypes = __importStar(require("./users"));
+exports.UserTypes = UserTypes;
+const AuthTypes = __importStar(require("./auth"));
+exports.AuthTypes = AuthTypes;
+const MessagesTypes = __importStar(require("./messages"));
+exports.MessagesTypes = MessagesTypes;
+const GroupTypes = __importStar(require("./groups"));
+exports.GroupTypes = GroupTypes;
+const ChatTypes = __importStar(require("./chats"));
+exports.ChatTypes = ChatTypes;
+const message_1 = __importDefault(require("./message"));
+exports.Message = message_1.default;

package/rubjs/types/message.d.ts

@@ -0,0 +1,18 @@
+import Client from "..";
+import { MessageUpdate, Message as MessageType } from "./decorators";
+declare class Message implements MessageUpdate {
+    message_id: string;
+    action: string;
+    message: MessageType;
+    updated_parameters: any[];
+    timestamp: string;
+    prev_message_id: string;
+    object_guid: string;
+    type: string;
+    state: string;
+    client: Client;
+    constructor(client: Client, update: MessageUpdate);
+    log(): void;
+    reply(text: string, object_guid?: string, message_id?: string): Promise<import("./messages").SendMessageResult>;
+}
+export default Message;

package/rubjs/types/message.js

@@ -0,0 +1,31 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class Message {
+    constructor(client, update) {
+        Object.assign(this, update);
+        Object.defineProperty(this, "client", {
+            value: client,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+    }
+    log() {
+        console.log(Object.assign({}, this));
+    }
+    reply(text, object_guid, message_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.sendMessage(object_guid || this.object_guid, text, message_id || this.message_id);
+        });
+    }
+}
+exports.default = Message;