@evolplus/evo-utils/dist/naming.js

Simple utilities solution.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createConverter = exports.convertObject = exports.convertName = exports.NamingConvention = void 0;
var NamingConvention;
(function (NamingConvention) {
    NamingConvention["CamelCase"] = "camelCase";
    NamingConvention["SnakeCase"] = "snake_case";
    NamingConvention["KebabCase"] = "kebab-case";
    NamingConvention["PascalCase"] = "PascalCase";
    NamingConvention["UpperSnakeCase"] = "UPPER_SNAKE_CASE";
    NamingConvention["UpperKebabCase"] = "UPPER-KEBAB-CASE";
})(NamingConvention || (exports.NamingConvention = NamingConvention = {}));
const CONVERSIONS = {
    [NamingConvention.CamelCase]: (parts) => {
        return parts[0].toLowerCase() + parts.slice(1).map(p => p.charAt(0).toUpperCase() + p.slice(1)).join('');
    },
    [NamingConvention.SnakeCase]: (parts) => {
        return parts.join('_').toLowerCase();
    },
    [NamingConvention.KebabCase]: (parts) => {
        return parts.join('-').toLowerCase();
    },
    [NamingConvention.PascalCase]: (parts) => {
        return parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join('');
    },
    [NamingConvention.UpperSnakeCase]: (parts) => {
        return parts.join('_').toUpperCase();
    },
    [NamingConvention.UpperKebabCase]: (parts) => {
        return parts.join('-').toUpperCase();
    }
};
const BUILD_PARTS = {
    [NamingConvention.CamelCase]: (name) => {
        return name.split(/(?=[A-Z])/).map(p => p.toLowerCase());
    },
    [NamingConvention.SnakeCase]: (name) => {
        return name.split('_');
    },
    [NamingConvention.KebabCase]: (name) => {
        return name.split('-');
    },
    [NamingConvention.PascalCase]: (name) => {
        return name.split(/(?=[A-Z])/);
    },
    [NamingConvention.UpperSnakeCase]: (name) => {
        return name.split('_');
    },
    [NamingConvention.UpperKebabCase]: (name) => {
        return name.split('-');
    }
};
function convertName(name, from, to) {
    return CONVERSIONS[to](BUILD_PARTS[from](name));
}
exports.convertName = convertName;
function convertObject(obj, from, to) {
    if (Array.isArray(obj)) {
        return obj.map(o => convertObject(o, from, to));
    }
    if (obj === null || obj === undefined || typeof obj !== 'object') {
        return obj;
    }
    let keys = Object.keys(obj), copy = {};
    for (let i = 0; i < keys.length; i++) {
        copy[convertName(keys[i], from, to)] = convertObject(obj[keys[i]], from, to);
    }
    return copy;
}
exports.convertObject = convertObject;
function createConverter(fields, from, to, reversed = false) {
    let mapping = {};
    fields.forEach(f => {
        if (reversed) {
            mapping[convertName(f, from, to)] = f;
        }
        else {
            mapping[f] = convertName(f, from, to);
        }
    });
    return (obj) => {
        let result = {};
        for (let key in mapping) {
            result[mapping[key]] = obj[key];
        }
        return result;
    };
}
exports.createConverter = createConverter;