@dstanesc/o-o-o-o-o-o-o/dist/codecs.js

O-O-O-O-O-O-O is a collection of content addressed persistent data structures

import { CID } from 'multiformats/cid';
import * as Raw from 'multiformats/codecs/raw';
import { sha256 } from 'multiformats/hashes/sha2';
import { pack, unpack } from 'msgpackr';
import { chunkyStore } from '@dstanesc/store-chunky-bytes';
const { create, readAll } = chunkyStore();
const CID_VERSION = 1;
const CODEC_CODE = Raw.code;
const valueCodecFactory = () => {
    const encode = (value) => {
        return pack(value);
    };
    const decode = (valueBytes) => {
        return unpack(valueBytes);
    };
    return { encode, decode };
};
const linkCodecFactory = () => {
    const encode = async (blockBytes) => {
        const hash = await sha256.digest(blockBytes);
        return CID.create(CID_VERSION, CODEC_CODE, hash);
    };
    const decode = (linkBytes) => {
        return CID.decode(linkBytes);
    };
    const parseString = (encodedString) => {
        return CID.parse(encodedString);
    };
    const encodeString = (link) => {
        return link.toString();
    };
    return { encode, decode, encodeString, parseString };
};
const blockCodecFactory = () => {
    const { encode: linkEncode, decode: linkDecode } = linkCodecFactory();
    const encode = async (json, blockPut) => {
        const bytes = pack(json);
        const link = await linkEncode(bytes);
        await blockPut({ cid: link, bytes });
        return link;
    };
    const decode = async (link, blockGet) => {
        const blockBytes = await blockGet(link);
        return unpack(blockBytes);
    };
    return { encode, decode };
};
const multiBlockCodecFactory = (chunk) => {
    const { encode: linkEncode, decode: linkDecode } = linkCodecFactory();
    const encode = async (json, blockPut) => {
        const buf = pack(json);
        const { root, index, blocks } = await create({
            buf,
            chunk,
            encode: linkEncode,
        });
        for (const block of blocks)
            await blockPut(block);
        return root;
    };
    const decode = async (link, blockGet) => {
        const bytes = await readAll({
            root: link,
            decode: linkDecode,
            get: blockGet,
        });
        return unpack(bytes);
    };
    return { encode, decode };
};
export { valueCodecFactory, linkCodecFactory, blockCodecFactory, multiBlockCodecFactory, };
//# sourceMappingURL=codecs.js.map