json-light/application/useCases/decompress.js

Allow to extend yaml or json files configuration

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Decompress = void 0;
const typ3s_1 = require("typ3s");
class Decompress {
    // eslint-disable-next-line no-useless-constructor
    constructor(service) {
        this.service = service;
    }
    decompress(data, options) {
        const type = options && options.type ? typ3s_1.Type.parse(options.type) : undefined;
        const mapping = data.__map ? data.__map : undefined;
        return this._decompress(data, type, mapping);
    }
    getKey(name, mapping) {
        if (mapping === undefined) {
            return name;
        }
        const entry = Object.entries(mapping).find(p => p[1] === name);
        if (entry !== undefined) {
            return entry[0];
        }
        return name;
    }
    _decompress(data, type, mapping) {
        let _type;
        let _data;
        let result;
        if (type !== undefined && type.primitive !== typ3s_1.Primitive.any) {
            _type = type;
            _data = data;
        }
        else if (data._schema !== undefined) {
            _type = typ3s_1.Type.parse(data._schema);
            _data = data._data;
        }
        else {
            throw new Error('cannot resolve type');
        }
        if (typ3s_1.Type.isPrimitive(_type)) {
            result = data;
        }
        if (_type.primitive === typ3s_1.Primitive.obj && _type.obj !== undefined) {
            result = {};
            let index = 0;
            for (const property of _type.obj.properties) {
                if (property.type !== undefined) {
                    if (typ3s_1.Type.isPrimitive(property.type)) {
                        const value = _data._ ? _data._[index] : _data[index];
                        if (value === '<N/D>') {
                            result[property.name] = undefined;
                        }
                        else {
                            result[property.name] = value;
                        }
                        index = index + 1;
                    }
                    else {
                        const key = this.getKey(property.name, mapping);
                        const value = _data[key];
                        if (value === '<N/D>') {
                            result[property.name] = undefined;
                        }
                        else if (_data[property.name] === null || value === undefined) {
                            result[property.name] = null;
                        }
                        else if (property.type.primitive === typ3s_1.Primitive.any) {
                            result[property.name] = value;
                        }
                        else {
                            result[property.name] = this._decompress(value, property.type, mapping);
                        }
                    }
                }
            }
        }
        else if (_type.primitive === typ3s_1.Primitive.list && _type.list !== undefined) {
            result = [];
            for (const item of _data) {
                if (typ3s_1.Type.isPrimitive(_type.list.items) || _type.list.items.primitive === typ3s_1.Primitive.any) {
                    result.push(item);
                }
                else {
                    const value = this._decompress(item, _type.list.items, mapping);
                    result.push(value);
                }
            }
        }
        else {
            const input = this.service.json(_data);
            if (input) {
                throw new Error(`cannot resolve type ${_type.primitive} for : ${JSON.stringify(input)}`);
            }
            else {
                throw new Error(`cannot resolve type ${_type.primitive} for : ${_data}`);
            }
        }
        return result;
    }
}
exports.Decompress = Decompress;
//# sourceMappingURL=decompress.js.map