hamok/lib/common/HamokCodec.js

Lightweight Distributed Object Storage on RAFT consensus algorithm

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.FacadedHamokCodec = void 0;
exports.createHamokCodec = createHamokCodec;
exports.createHamokJsonBinaryCodec = createHamokJsonBinaryCodec;
exports.createHamokJsonStringCodec = createHamokJsonStringCodec;
exports.encodeCollection = encodeCollection;
exports.decodeCollection = decodeCollection;
exports.encodeSet = encodeSet;
exports.decodeSet = decodeSet;
exports.encodeMap = encodeMap;
exports.decodeMap = decodeMap;
exports.encodeNumber = encodeNumber;
exports.createStrToUint8ArrayCodec = createStrToUint8ArrayCodec;
const EMPTY_MAP = new Map();
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const EMPTY_SET = new Set();
function createHamokCodec(encode, decode) {
    return {
        encode,
        decode,
    };
}
function createHamokJsonBinaryCodec() {
    const encoder = new TextEncoder();
    const decoder = new TextDecoder();
    return {
        encode: (data) => {
            const jsonString = JSON.stringify(data);
            const encoded = encoder.encode(jsonString);
            return encoded;
        },
        decode: (data) => {
            const jsonString = decoder.decode(data);
            const decoded = JSON.parse(jsonString);
            return decoded;
        },
    };
}
function createHamokJsonStringCodec() {
    return {
        encode: (data) => JSON.stringify(data),
        decode: (data) => JSON.parse(data),
    };
}
/* eslint-disable @typescript-eslint/no-explicit-any */
class FacadedHamokCodec {
    /* eslint-disable @typescript-eslint/no-explicit-any */
    static wrap(codec) {
        const facadedCodec = new FacadedHamokCodec(codec);
        return facadedCodec;
    }
    _codec;
    constructor(firstEncoder) {
        this._codec = firstEncoder;
    }
    encode(data) {
        return this._codec.encode(data);
    }
    decode(data) {
        return this._codec.decode(data);
    }
    then(nextCodec) {
        const actualCodec = this._codec;
        return FacadedHamokCodec.wrap({
            encode(data) {
                const encodedValue = actualCodec.encode(data);
                return nextCodec.encode(encodedValue);
            },
            decode(data) {
                const decodedValue = nextCodec.decode(data);
                return actualCodec.decode(decodedValue);
            },
        });
    }
}
exports.FacadedHamokCodec = FacadedHamokCodec;
function encodeCollection(keys, keyCodec) {
    const result = [];
    for (const key of keys) {
        const encodedKey = keyCodec.encode(key);
        result.push(encodedKey);
    }
    return result;
}
function decodeCollection(keys, keyCodec) {
    const result = [];
    for (const key of keys) {
        const decodedKey = keyCodec.decode(key);
        result.push(decodedKey);
    }
    return result;
}
function encodeSet(keys, keyCodec) {
    if (keys.size < 1) {
        return [];
    }
    return encodeCollection(keys.values(), keyCodec);
}
function decodeSet(keys, keyCodec) {
    if (keys.length < 1) {
        return EMPTY_SET;
    }
    return new Set(decodeCollection(keys.values(), keyCodec));
}
function encodeMap(entries, keyCodec, valueCodec) {
    if (entries.size < 1) {
        return [[], []];
    }
    const encodedKeys = [];
    const encodedValues = [];
    for (const [key, value] of entries) {
        const encodedKey = keyCodec.encode(key);
        const encodedValue = valueCodec.encode(value);
        encodedKeys.push(encodedKey);
        encodedValues.push(encodedValue);
    }
    return [encodedKeys, encodedValues];
}
function decodeMap(keys, values, keyCodec, valueCodec) {
    if (keys.length < 1 || values.length < 1) {
        return EMPTY_MAP;
    }
    const result = new Map();
    const length = Math.min(keys.length, values.length);
    for (let i = 0; i < length; ++i) {
        const key = keys[i];
        const value = values[i];
        const decodedKey = keyCodec.decode(key);
        const decodedValue = valueCodec.decode(value);
        result.set(decodedKey, decodedValue);
    }
    return result;
}
function encodeNumber(value) {
    const buffer = new ArrayBuffer(4);
    const view = new DataView(buffer);
    view.setInt32(0, value);
    return new Uint8Array(buffer);
}
function createStrToUint8ArrayCodec(encoding = 'utf-8') {
    return {
        encode: (data) => Buffer.from(data, encoding),
        decode: (data) => Buffer.from(data).toString(encoding),
    };
}