af-consul/dist/esm/src/lib/utils.js

A highly specialized function library

import * as fs from 'fs';
export const removeAroundQuotas = (str) => {
    if (!str) {
        return str;
    }
    const re = /^(["'])([^\r\n]+)(\1)$/;
    while (re.test(str)) {
        str = str.replace(re, '$2');
    }
    return str;
};
export const parseBoolean = (bv) => {
    if (typeof bv === 'boolean' || typeof bv === 'number') {
        return !!bv;
    }
    if (typeof bv !== 'string') {
        bv = String(bv);
    }
    return !/^(false|no|0)$/i.test(bv.trim().toLowerCase());
};
export const substitutePercentBracket = (v, data) => {
    const re = /%?{([^}]+)}/g;
    let result = v;
    const matches = [...v.matchAll(re)];
    matches.forEach(([found, propName]) => {
        const substitution = String(data[propName] || '');
        result = result.replace(found, substitution);
    });
    return result;
};
export const substitute = (meta, data) => {
    Object.entries(meta).forEach(([k, v]) => {
        if (typeof v === 'string') {
            meta[k] = substitutePercentBracket(v, data);
        }
    });
};
export const parseMeta = (m, data) => {
    const metaData = {};
    if (!m) {
        return metaData;
    }
    const fillMetaData = (o) => {
        Object.entries(o).forEach(([k, v]) => {
            if (!['string', 'number'].includes(typeof v)) {
                v = String(v);
            }
            if (/^[A-Z][A-Z_\d]+$/i.test(k)) {
                metaData[k] = v;
            }
        });
    };
    if (typeof m === 'string') {
        m = removeAroundQuotas(m);
        if (m.startsWith('{')) {
            try {
                fillMetaData(JSON.parse(m));
            }
            catch (e) { //
            }
        }
        else if (m.includes('=')) {
            m.split(/;/g).forEach((pair) => {
                const i = pair.indexOf('=');
                if (i < 0) {
                    return;
                }
                const k = pair.substring(0, i).trim();
                const v = pair.substring(i + 1).trim();
                if (k) {
                    metaData[k] = v;
                }
            });
        }
    }
    else if (typeof m === 'object' && !Array.isArray(m)) {
        fillMetaData(m);
    }
    substitute(metaData, data);
    return metaData;
};
export const parseTags = (t) => {
    if (typeof t === 'string') {
        t = removeAroundQuotas(t);
        return t.split(/;/g).map((v) => v.trim()).filter((v) => v);
    }
    if (typeof t === 'number') {
        return [String(t)];
    }
    if (Array.isArray(t)) {
        return t.map((v) => String(v).trim()).filter((v) => v);
    }
    return [];
};
export const serviceConfigDiff = (registerConfig, serviceInfo) => {
    if (!serviceInfo) {
        return ['id', registerConfig.id, 'ID', undefined];
    }
    const mastBeEquals = [['id', 'ID'], ['name', 'Service'], ['port', 'Port'], ['address', 'Address']];
    let diff = [];
    mastBeEquals.some(([p1, p2]) => {
        if (registerConfig[p1] !== serviceInfo[p2]) {
            diff = [p1, registerConfig[p1], p2, serviceInfo[p2]];
            return true;
        }
        return false;
    });
    if (!diff.length) {
        const { meta } = registerConfig;
        const { Meta = {} } = serviceInfo;
        Object.entries(meta).some(([p, v]) => {
            if (v !== Meta[p]) {
                diff = [`meta.${p}`, v, `Meta.${p}`, Meta[p]];
                return true;
            }
            return false;
        });
    }
    return diff;
};
export const minimizeCache = (cache, maxItems) => {
    const len = Object.keys(cache).length;
    if (len >= maxItems) {
        const sortedDesc = Object.entries(cache)
            .sort((a, b) => b[1].created - a[1].created);
        sortedDesc.splice(0, maxItems - 1);
        sortedDesc.map(([h]) => h).forEach((h) => {
            delete cache[h];
        });
    }
};
/**
 * String in format \d+(s|m) in milliseconds
 */
export const toMills = (timeStr = '') => {
    const re = /^(\d+)([sm])$/;
    const matches = re.exec(timeStr);
    if (!matches) {
        return 0;
    }
    return Number(matches[1]) * 1000 * (matches[2] === 's' ? 1 : 60);
};
export const getPackageJson = (relPathToProjRoot = '') => {
    try {
        const rootDir = process.cwd();
        const packageJson = `${rootDir}${relPathToProjRoot}/package.json`;
        if (fs.existsSync(packageJson)) {
            return JSON.parse(fs.readFileSync(packageJson, { encoding: 'utf8' }));
        }
    }
    catch (err) {
        //
    }
};
export const sleep = async (timeOut) => new Promise((resolve) => {
    setTimeout(resolve, timeOut);
});
export const isObject = (v) => v != null
    && typeof v === 'object'
    && !Array.isArray(v)
    && !(v instanceof Date)
    && !(v instanceof Set)
    && !(v instanceof Map);
//# sourceMappingURL=utils.js.map