index.js

var emvTagsConfig = require('./tags');
var emvTagsMap = emvTagsConfig.map;
var emvLongTags = emvTagsConfig.longTags;
var emvDolNumericTypes = emvTagsConfig.dolNumericTypes;

function emvEncodeMapTags() {
    emvTagsConfig.map.encode = Object.keys(emvTagsConfig.map.decode)
        .map((e) => {
            let o = {};
            o[emvTagsConfig.map.decode[e]] = e;
            return o;
        })
        .reduce((accum, cur) => Object.assign(accum, cur), {});
}

function translateTagEncode(tag = '') {
    // if the tag has 'emv' prepended, returns input value with 'emv' removed
    if (tag.startsWith('emv')) {
        return tag.substr(3);
    }
    return emvTagsMap.encode[tag];
}

function translateTagDecode(tag = '') {
    // if the tag is unknown, returns 'emv' prepended input value
    return emvTagsMap.decode[tag.toUpperCase()] || `emv${tag}`;
}

function getNumVal(val, len, dolLenDiff, compressedNumeric) {
    if (dolLenDiff < 0) { // left truncated
        return val.slice(len * -2);
    } else {
        if (!compressedNumeric) {
            return ((new Array(len)).fill('00').join('') + val).slice(len * -2);
        }
        return (val + (new Array(dolLenDiff)).fill('FF').join(''));
    }
};
function getNonNumVal(val, len, dolLenDiff) {
    if (dolLenDiff < 0) { // right truncated
        return val.slice(len * 2);
    } else {
        return (val + (new Array(len)).fill('00').join('')).slice(len * 2);
    }
};

/**
 * @param {Object} tagObj decoded emv tag
 * @param {string} tagObj.val decoded emv tag value
 * @param {string} tagObj.len decoded emv tag value bytes length (/2)
 */
function getValueHexLength(tagObj) {
    let len;
    if (!tagObj || (!tagObj.len && !tagObj.val)) {
        len = 0;
    } else {
        if (!tagObj.val || !tagObj.val.length) {
            len = tagObj.len || 0;
        } else {
            len = (tagObj.val.length / 2);
        }
    }
    len = len.toString(16).toUpperCase();

    return (len.length % 2) ? `0${len}` : len;
}

/**
 * @param {string} emvString emv input string
 * @param {Object} result object to store results in
 * @param {number=} dolIdx value position in data object list
 */
function tagsDecode(emvString, result, dolIdx) {
    let tag;
    let len;
    let val;
    let isDol = false;
    emvString = emvString.toUpperCase();
    if (emvLongTags.includes(emvString.substr(0, 2).toLowerCase())) { // 2 bytes tag
        tag = emvString.substr(0, 4);
        emvString = emvString.substr(4);
    } else {
        tag = emvString.substr(0, 2);
        emvString = emvString.substr(2);
    }
    let tagTranslated = translateTagDecode(tag);
    result[tagTranslated] = {tag};
    if (tagTranslated.includes('DOL')) {
        isDol = true;
    }
    if (dolIdx) {
        result[tagTranslated].idx = dolIdx - 1;
    }
    let lenStr = emvString.substr(0, 2);
    len = (lenStr === '') ? 0 : parseInt(emvString.substr(0, 2), 16);
    emvString = emvString.substr(2);
    if (len >= 128) { // size is big
        let byteNumSize = 0;
        let cur = 128;
        while (cur >= 1) { // calculate big size
            cur = cur >> 1;
            if ((len & cur) === cur) {
                byteNumSize = byteNumSize | cur;
            }
        }
        len = parseInt(emvString.substr(0, byteNumSize * 2), 16);
        emvString = emvString.substr(byteNumSize * 2);
    }
    if (!dolIdx && len > emvString.length / 2) {
        throw new Error('Data integrity error');
    }
    result[tagTranslated].len = len;
    if (!len) {
        len = 0;
        val = '';
    } else {
        if (dolIdx) {
            val = '';
        } else {
            val = emvString.substr(0, len * 2);
            emvString = emvString.substr(len * 2);
        }
    }
    let constructedTagByte = (Buffer.from(tag, 'hex')).slice(0, 1)[0];
    if ((constructedTagByte & 32) === 32) {
        result[tagTranslated].val = (isDol ? tagsDecode(val, {}, 1) : tagsDecode(val, {}, (dolIdx ? dolIdx + 1 : dolIdx)));
    } else {
        result[tagTranslated].val = (isDol ? tagsDecode(val, {}, 1) : val);
    }
    if (emvString.length) {
        return tagsDecode(emvString, result, (dolIdx ? dolIdx + 1 : dolIdx));
    }
    return result;
};

/**
 * EMV 4.3 Book 3                              5 Data Elements and Files
 * Application Specification                   5.4 Rules for Using a Data Object List (DOL)
 * @param {Object} emvTags decoded emv tags map
 */
function dolDecode(emvTags) {
    let data = Object.assign({}, emvTags);
    let mainTags = Object.keys(data);
    let dolTags = mainTags.filter((t) => (t.includes('DOL')));
    if (dolTags.length) {
        data = dolTags
            .map((t) => ({tag: t, data: data[t].val, internalTags: Object.keys(data[t].val)}))
            .reduce((allTags, dol) => {
                allTags[dol.tag].val = dol.internalTags.reduce((dolTags, dolInt) => {
                    let extTag = allTags[dolInt];
                    let dolTag = dolTags[dolInt];
                    if (!extTag) { // no tag found in root tags list
                        dolTags[dolInt].val = (new Array(dolTags[dolInt].len)).fill('00').join('');
                    } else if (extTag.len === dolTag.len) {
                        dolTags[dolInt].val = extTag.val;
                    } else {
                        let extNumType = emvDolNumericTypes[dolTag.tag];
                        if (extNumType === 'n') { // non numeric value
                            dolTags[dolInt].val = getNonNumVal(extTag.val, dolTag.len, dolTag.len - extTag.len, false);
                        } else if (extNumType === 'nc') { // non numeric value
                            dolTags[dolInt].val = getNonNumVal(extTag.val, dolTag.len, dolTag.len - extTag.len, true);
                        } else { // numeric value
                            dolTags[dolInt].val = getNumVal(extTag.val, dolTag.len, dolTag.len - extTag.len);
                        }
                    }
                    return dolTags;
                }, dol.data);
                return allTags;
            }, data);
    }
    return data;
};

/**
 * @param {Object} emvTags decoded emv tags map
 */
function tagsEncode(emvTags) {
    let data = Object.assign({}, emvTags);
    let dolOrder = ['CDOL1', 'CDOL2', 'TDOL', 'PDOL', 'DDOL'];
    let result = '';
    let allTags = Object.keys(data)
        .sort((a, b) => {
            if ((!data[a].idx && data[a].idx !== 0) || (!data[b].idx && data[b].idx !== 0)) {
                return 0;
            }
            return data[a].idx - data[b].idx;
        });
    // transform data in dols
    data = allTags
        .filter((k) => (k.includes('DOL')))
        .map((k) => {
            let dol = data[k];
            return {
                tag: dol.tag,
                data: Object.keys(dol.val)
                    .sort((a, b) => {
                        return dol.val[a].idx > dol.val[b].idx;
                    })
                    .map((k) => {
                        let tagObj = dol.val[k];
                        let tagTranslated = translateTagEncode(k);
                        let tagLength = getValueHexLength(tagObj);

                        return [tagTranslated, tagLength].join('');
                    })
            };
        })
        .reduce((data, dol) => {
            data[dol.tag] = dol.data.join('');
            return data;
        }, data);
    // make sure that dols are constructed in order
    let allDols = dolOrder
        .map((dol) => (allTags.includes(dol) ? dol : 0))
        .filter((e) => e);
    // append dols to result
    result = allDols
        .reduce((r, dol) => {
            let tagTranslated = translateTagEncode(dol);
            let d = Object.assign({}, data[dol], {val: data[tagTranslated]});
            let tagLength = getValueHexLength(d);

            return `${r}${tagTranslated}${tagLength}${d.val}`;
        }, '');
    // cleanup dols
    data = allDols
        .reduce((r, dol) => {
            let tagTranslated = translateTagEncode(dol);
            delete r[dol];
            delete r[tagTranslated];
            return r;
        }, data);
    // append all fields left to result
    return result + Object.keys(data)
        .sort((a, b) => data[a].idx - data[b].idx)
        .map((e) => {
            let tagTranslated = translateTagEncode(e);
            let tagObj = data[e];
            let tagLength = getValueHexLength(tagObj);
            let tagValue = tagObj.val;

            let constructedTagByte = (Buffer.from(tagTranslated, 'hex')).slice(0, 1)[0];
            if ((constructedTagByte & 32) === 32) {
                tagValue = tagsEncode(tagObj.val);
            }

            return `${tagTranslated}${tagLength}${tagValue}`;
        }).join('');
}
/**
 * Reduce emv to {{key: value}, ...}
 */
function flatten(emv = {}) {
    return Object.keys(emv)
        .reduce((acc, key) => {
            acc[key] = emv[key].val;
            return acc;
        }, {});
}
/**
 * Expand emv from {{key: value}, ...} to {{tag, len, val}, ...}
 */
function unflatten(emv = {}) {
    return Object.keys(emv)
        .reduce((acc, key) => {
            let entity = {
                tag: translateTagEncode(key),
                val: emv[key]
            };
            acc[key] = {
                ...entity,
                len: getValueHexLength(entity)
            };
            return acc;
        }, {});
}

module.exports = (function emv() {
    if (!emvTagsConfig.map.encode) {
        emvEncodeMapTags();
    }

    return {
        tagsDecode,
        dolDecode,
        tagsEncode,
        flatten,
        unflatten
    };
})();