gramjs/gramjs/extensions/MessagePacker.js

const Helpers = require("../utils/Helpers");
const MessageContainer = require("../tl/core/MessageContainer");
const TLMessage = require("../tl/core/TLMessage");
const {TLRequest} = require("../tl/tlobject");
const BinaryWriter = require("../extensions/BinaryWriter");


class MessagePacker {
    constructor(state, logger) {
        this._state = state;
        this._queue = [];
        this._ready = false;
        this._log = logger;
    }

    append(state) {
        this._queue.push(state);
        this._ready = true;
    }

    extend(states) {
        for (let state of states) {
            this._queue.push(state);
        }
        this._ready = true;
    }

    async get() {
        if (!this._queue.length) {
            this._ready = false;
            while (!this._ready) {
                await Helpers.sleep(100);
            }
        }
        let data;
        let buffer = new BinaryWriter(Buffer.alloc(0));

        let batch = [];
        let size = 0;

        while (this._queue.length && batch.length <= MessageContainer.MAXIMUM_LENGTH) {
            let state = this._queue.shift();
            size += state.data.length + TLMessage.SIZE_OVERHEAD;
            if (size <= MessageContainer.MAXIMUM_SIZE) {
                let afterId;
                if (state.after) {
                    afterId = state.after.msgId;
                }
                state.msgId = await this._state.writeDataAsMessage(
                    buffer, state.data, state.request instanceof TLRequest,
                    afterId
                );

                this._log.debug(`Assigned msgId = ${state.msgId} to ${state.request.constructor.name}`);
                batch.push(state);
                continue;
            }
            if (batch.length) {
                this._queue.unshift(state);
                break;
            }
            this._log.warning(`Message payload for ${state.request.constructor.name} is too long ${state.data.length} and cannot be sent`);
            state.promise.reject("Request Payload is too big");
            size = 0;
            continue
        }
        if (!batch.length) {
            return null;
        }
        if (batch.length > 1) {
            data = Buffer.concat([struct.pack(
                '<Ii', MessageContainer.CONSTRUCTOR_ID, batch.length
            ), buffer.getValue()]);

            let containerId = await this._state.writeDataAsMessage(
                buffer, data, false
            );
            for (let s of batch) {
                s.containerId = containerId;
            }
        }

        data = buffer.getValue();
        return {batch, data}
    }
}

module.exports = MessagePacker;