@mrhiden/cstruct/lib/write-buffer.js

For packing and unpacking bytes (C like structures) in/from Buffer based on Object/Array type for parsing.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.WriteBuffer = void 0;
const base_buffer_1 = require("./base-buffer");
class WriteBuffer extends base_buffer_1.BaseBuffer {
    u8(val = 0) {
        const buffer = Buffer.allocUnsafe(1);
        buffer.writeUInt8(val);
        this.moveOffset(buffer);
    }
    i8(val = 0) {
        const buffer = Buffer.allocUnsafe(1);
        buffer.writeInt8(val);
        this.moveOffset(buffer);
    }
    s(val = '', size) {
        if (typeof val !== 'string') {
            throw new Error(`Invalid string value ${val}`);
        }
        if (size === undefined) {
            size = val.length;
        }
        else {
            if (size < 0) {
                throw new Error(`Invalid string size ${size}`);
            }
            if (size === 0) {
                size = val.length + 1;
            }
        }
        const buffer = Buffer.alloc(size);
        buffer.write(val, 0, size, 'utf8');
        this.moveOffset(buffer);
    }
    ws(val = '', size) {
        if (typeof val !== 'string') {
            throw new Error(`Invalid string value ${val}`);
        }
        if (size === undefined) {
            size = val.length;
        }
        else {
            if (size < 0) {
                throw new Error(`Invalid string size ${size}`);
            }
            if (size === 0) {
                size = val.length + 1;
            }
        }
        size *= 2; // utf16le 2 bytes per character
        const buffer = Buffer.alloc(size);
        buffer.write(val, 0, size, 'utf16le');
        this.moveOffset(buffer);
    }
    buf(val = Buffer.alloc(0), size) {
        if (!(val instanceof Buffer)) {
            throw new Error(`Invalid buffer value ${val}`);
        }
        let buffer;
        if (size === undefined) {
            buffer = val;
        }
        else {
            buffer = Buffer.alloc(size);
            val.copy(buffer, 0, 0, size);
        }
        this.moveOffset(buffer);
    }
    constructor() {
        super();
        this._buffers = [];
        this._offset = 0;
        this._atomFunctions = new Map([
            ['b8', (val) => this.i8(+Boolean(val))],
            ['u8', (val) => this.u8(val)],
            ['i8', (val) => this.i8(val)],
            ['s', (val, size) => this.s(val, size)],
            ['ws', (val, size) => this.ws(val, size)],
            ['buf', (val, size) => this.buf(val, size)],
            ['j', (val, size) => this.s(val, size)],
        ]);
    }
    write(type, val, size) {
        if (size === undefined) {
            const groups = type.match(this._stringOrBufferAtomOrJsonGroups)?.groups;
            if (groups) {
                type = groups.type;
                size = +groups.size;
            }
        }
        if (this._atomFunctions.has(type)) {
            const writer = this._atomFunctions.get(type);
            writer(val, size);
        }
        else {
            throw new Error(`Unknown type ${type}`);
        }
    }
    get buffer() {
        return this.toBuffer();
    }
    toBuffer() {
        return Buffer.concat(this._buffers);
    }
    get size() {
        return this._offset;
    }
    get offset() {
        return this._offset;
    }
    moveOffset(buffer) {
        this._buffers.push(buffer);
        this._offset += buffer.length;
    }
}
exports.WriteBuffer = WriteBuffer;