ROBO24 - chunk descriptor

function generateOffset(start = 0) {
    let counter = start;
    return function (size) {
        const offset = counter;
        counter += number;
        return {
            offset,
            size,
        };
    }
}

const createStaticDescription = function (dataViewType) {
    const getterName = `get${dataViewType}`;
    const setterName = `set${dataViewType}`;
    return function (offset) {
        offset = parseInt(offset);
        if (isNaN(offset)) {
            throw new Error("Static descriptor must have valid offset");
        }
        return {
            get: function () {
                return this['dataView'][getterName](offset);
            },
            set: function (value) {
                this['dataView'][setterName](offset, value);
            },
            writable: true,
        }
    }
};

const mapper = {
    "s16": "Int16",
    "u16": "Uint16",
};

const createVectorDescription = function (fields, size, dataViewType) {
    return function (offset) {
        offset = parseInt(offset);
        if (isNaN(offset)) {
            throw new Error("Vector descriptor must have valid offset");
        }
        const object = {};
        for (let [key, field] of fields.entries()) {
            let subOffset = offset + (size * key);
            Object.defineProperty(object, key, createStaticDescription(dataViewType, subOffset));
            Object.defineProperty(object, field, createStaticDescription(dataViewType, subOffset));
        }
        return {
            value: object,
            writable: false,
        };
    }
};

const types = Object.create(null);

const numberTypes = [];
for (let signed of ["s", "u"]) {
    for (let i = 0; i < 4; i++) {
        const size = 2 ** i;
        const name = `${signed}${size * 8}`;
        const numberType = {
            name,
            size,
            define: createStaticDescription(type),
        };
        numberTypes.push(numberType);
        types[name] = numberType;
    }
}

const vectorDirections = [
    ["x", "y"],
    ["x", "y", "z"],
    ["x", "y", "z", "w"],
];

for (let directions of vectorDirections) {
    for (let {name: numberTypeName, size: numberTypeSize} of numberTypes) {
        const name = `vec${directions.length}<${numberTypeName}>`;
        const size = directions.length * numberTypeSize;
        types[name] = {
            name,
            size,
            define: createVectorDescription(directions, numberTypeSize, numberTypeName)
        }
    }
}

types['blob'] = {
    name: 'blob',
    size: undefined,
};

const regex = new RegExp(`(?<mainType>\\w+)(?:<(?<subtype>\\w+)>)?(?:\\[(?<count>\\w*)\\])?`);

const defineDecors = function () {
    let offset = 0;
    for (let decoder of this['decoder'].fields) {
        const {type, field} = decoder;
        const match = regex.exec(type);
        const {type, subtype, count} = match.groups;
        const key = `${type}<${subtype}>`;
        const typeDefinition = types[key];
        const descriptor = typeDefinition.define(offset);
        const next = parseInt(typeDefinition.size);
        if (isNaN(next)) {

        }

        offset += typeDefinition.size;
            Object.defineProperty(this, field, descriptor);
    }
};

export default class Chunk {

    constructor(options) {
        this.dataView = options['dataView'];
        defineDecors.call(this);
    }
}

const size = generateOffset();

const generateBlob = (key) => ({
    field: key,
    type: "blob",
    offset: function () {
        return this[`${key}Offset`];
    },
    size: function () {
        return this[`${key}Size`];
    }
});

const generateBlob = (key) => ({
    type: "blob",
    field: key,
    offset: function () {
        return this[`${key}Offset`];
    },
    size: function () {
        return this[`${key}Size`];
    }
});

Chunk.prototype['decoder'] = {
    fields: [
        {type: "u8", field: "type"},
        {type: "u8", field: "blockBitWidth"},
        {type: "vec3<u16>", field: "position"},
        {type: "u16", field: "blockDataOffset"},
        {type: "u16", field: "blockIndexDataOffset"},
        {type: "u16", field: "terrainDataOffset"},
        {type: "u16", field: "additionalDataOffset"},
        {type: "u16", field: "overrideDataOffset"},
        {type: "u16", field: "blockDataSize"},
        {type: "u16", field: "blockIndexDataSize"},
        {type: "u16", field: "terrainDataSize"},
        {type: "u16", field: "additionalDataSize"},
        {type: "u16", field: "overrideDataSize"},
        generateBlob('blockData'),
        generateBlob('blockIndexData'),
        generateBlob('terrainData'),
        generateBlob('additionalData'),
        generateBlob('overrideData'),
    ],
};

const buffer = new ArrayBuffer(4096);
const dataView = new DataView(buffer, 2048);
dataView.setInt16(0, 5);

const chunk = new Chunk(dataView);