@azteam/util/src/index.js

N/A

import {execSync} from 'child_process';
import _ from 'lodash';

export function timeout(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
}

export function toSlug(text) {
    let slug = text.toLowerCase();
    slug = slug.replace(/(à|á|ạ|ả|ã|â|ầ|ấ|ậ|ẩ|ẫ|ă|ằ|ắ|ặ|ẳ|ẵ)/gu, 'a');
    slug = slug.replace(/(è|é|ẹ|ẻ|ẽ|ê|ề|ế|ệ|ể|ễ)/gu, 'e');
    slug = slug.replace(/(ì|í|ị|ỉ|ĩ)/gu, 'i');
    slug = slug.replace(/(ò|ó|ọ|ỏ|õ|ô|ồ|ố|ộ|ổ|ỗ|ơ|ờ|ớ|ợ|ở|ỡ)/gu, 'o');
    slug = slug.replace(/(ù|ú|ụ|ủ|ũ|ư|ừ|ứ|ự|ử|ữ)/gu, 'u');
    slug = slug.replace(/(ỳ|ý|ỵ|ỷ|ỹ)/gu, 'y');
    slug = slug.replace(/(đ)/gu, 'd');
    slug = slug.replace(/([.])/gu, '-');
    slug = slug.replace(/([^0-9a-z-\s])/gu, '');
    slug = slug.replace(/(\s+)/gu, '-');
    slug = slug.replace(/-+/gu, '-');
    slug = slug.replace(/^-+/gu, '');
    slug = slug.replace(/-+$/gu, '');
    return slug;
}

export function genCharArray(charStart = 'a', charEnd = 'z') {
    const array = 'ABCDEFGHiIJKLMNOPQRARUVWXYZ'.split('');
    return array.slice(array.indexOf(charStart.toUpperCase()), array.indexOf(charEnd.toUpperCase()) + 1);
}

export function increasePercent(number, percent) {
    return number + number / (100 / percent);
}

export function decreasePercent(number, percent) {
    return number - number / (100 / percent);
}

export function omitItem(item, guard = [], allow = []) {
    if (allow === '*') {
        return item;
    }

    let guardFields = _.cloneDeep(guard);
    let itemFields = _.cloneDeep(item);

    if (_.isArray(guardFields)) {
        guardFields = _.difference(guardFields, allow);
    }

    if (itemFields.toJSON) {
        itemFields = item.toJSON();
    }
    if (_.isObject(itemFields)) {
        if (guardFields === '*') {
            return _.pick(itemFields, allow);
        }
        return _.omit(itemFields, guardFields);
    }
    return itemFields;
}

export function omitArrayItem(arrayItem, guard, allow) {
    return _.map(arrayItem, (item) => {
        return omitItem(item, guard, allow);
    });
}

export function differenceObject(obj1, obj2) {
    return _.omitBy(
        _.mapValues(obj1, (value1, key) => {
            const value2 = obj2[key];
            const type1 = typeof value1;
            const type2 = typeof value2;

            if (typeof type2 !== 'undefined' && type1 === type2) {
                if (type1 === 'object') {
                    if (Array.isArray(value1)) {
                        return _.differenceWith(value1, value2, _.isEqual);
                    }
                    return differenceObject(value1, value2);
                }

                if (!_.isEqual(value1, value2)) {
                    return value1;
                }
                return null;
            }
            return value1;
        }),
        (val) => {
            return (_.isEmpty(val) && !_.isNumber(val)) || _.isNaN(val);
        }
    );
}

export async function promiseAllLimit(data, limit, asyncFunction) {
    const isArray = Array.isArray(data);

    const entries = isArray ? data.map((v, i) => [i, v]) : Object.entries(data);

    const results = new Array(entries.length);

    let index = 0;

    async function worker() {
        while (true) {
            const currentIndex = index++;
            if (currentIndex >= entries.length) return;

            const [key, value] = entries[currentIndex];

            // ❗ nếu asyncFunction throw → Promise.all reject ngay
            const res = await asyncFunction(value, key);

            results[currentIndex] = [key, res];
        }
    }

    await Promise.all(Array.from({length: Math.min(limit, entries.length)}, worker));

    return isArray ? results.map(([, v]) => v) : Object.fromEntries(results);
}

export async function asyncLoop(data, asyncFunction, options = {}) {
    const {isLogProcessing, reverse} = options;

    let entries = [];
    const isArray = Array.isArray(data);

    if (isArray) {
        entries = data.map((v, i) => [i, v]);
    } else {
        entries = Object.entries(data);
    }

    const {length} = entries;

    if (!length) {
        return false;
    }

    if (reverse) {
        for (let i = length - 1; i >= 0; i -= 1) {
            const key = entries[i][0];
            const value = entries[i][1];

            if (isLogProcessing) {
                console.log('run reverse', `(${i + 1}/${length})`);
            }

            const result = await asyncFunction(value, key);

            if (typeof result !== 'undefined') {
                return result;
            }

            if (isLogProcessing) {
                console.log('done', `(${i + 1}/${length})`);
            }

            await timeout(1);
        }
    } else {
        for (let i = 0; i < length; i += 1) {
            const key = entries[i][0];
            const value = entries[i][1];

            if (isLogProcessing) {
                console.log('run', `(${i + 1}/${length})`);
            }

            const result = await asyncFunction(value, key);

            if (typeof result !== 'undefined') {
                return result;
            }

            if (isLogProcessing) {
                console.log('done', `(${i + 1}/${length})`);
            }

            await timeout(1);
        }
    }

    return true;
}

export async function retryExec(command, countRetry = 5, opts = {}) {
    let errorString = '';
    do {
        try {
            const result = execSync(command, opts).toString();
            return result.trim();
        } catch (e) {
            errorString = e.toString();
            // eslint-disable-next-line no-param-reassign
            countRetry -= 1;
        }
    } while (countRetry > 0);

    throw new Error(errorString);
}

export async function retryFunc(asyncFunc, limit = 5) {
    let retry = limit;
    let errorString = null;
    do {
        try {
            const result = await asyncFunc();
            retry = 0;
            return {
                status: true,
                result,
            };
        } catch (err) {
            retry -= 1;
            errorString = err.toString();
            await timeout(1000);
        }
    } while (retry);

    return {
        status: false,
        error: errorString,
    };
}

export function getMime(filePath) {
    return execSync(`file -b --mime-type "${filePath}"`).toString().trim();
}

export function checkMime(filePath, fileType) {
    return getMime(filePath).includes(fileType);
}

export function setIntervalImmediately(func, interval) {
    func();
    return setInterval(func, interval);
}

export function calculatePercentTwoNumber(number1, number2) {
    if (number1 === 0) {
        return 0;
    }
    if (number2 === 0) {
        return 100;
    }
    return Number(((number1 / (number1 + number2)) * 100).toFixed(2));
}

export function getPercentDifference(a, b) {
    if (b === 0) return a * 100;
    return _.round((a / b) * 100 - 100, 2);
}