flexbuf/dist/cjs/objects.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ObjectEncoding = void 0;
const low_level_1 = require("low-level");
class ObjectEncoding {
    static encode(object, keyConfigs, forHash) {
        try {
            const hexData = [];
            for (const keyConfig of keyConfigs) {
                if (forHash && keyConfig.hashRemove)
                    continue;
                const value = object[keyConfig.key];
                const rawData = keyConfig.encode(value);
                if (!rawData) {
                    return { err: new Error(`Failed to encode for key: ${keyConfig.key}`), data: low_level_1.Uint.empty() };
                }
                hexData.push(...rawData);
            }
            return { data: low_level_1.Uint.concat(hexData) };
        }
        catch (err) {
            return { err, data: low_level_1.Uint.empty() };
        }
    }
    static decode(hexData, keyConfigs, returnLength = false) {
        try {
            const final_data = {};
            let current_length = 0;
            for (const keyConfig of keyConfigs) {
                const currentPart = hexData.slice(current_length);
                const decoded = keyConfig.decode(currentPart);
                if (!decoded) {
                    return { err: new Error(`Failed to decode for key: ${keyConfig.key}. Could be due to an Buffer underflow`) };
                }
                final_data[keyConfig.key] = decoded.data;
                current_length += decoded.length;
            }
            if (returnLength) {
                return { data: final_data, length: current_length };
            }
            if (hexData.getLen() !== current_length) {
                return { err: new Error("Buffer underflow or overflow") };
            }
            return { data: final_data };
        }
        catch (err) {
            return { err };
        }
    }
}
exports.ObjectEncoding = ObjectEncoding;
//# sourceMappingURL=objects.js.map