@cloud-ru/ft-request-payload-transform/dist/esm/helpers.js

var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
import { ARRAY_REG, DELIMITER, MULTI_VALUE_CONDITIONS, PAGINATION_KEYS } from './constants';
const OBJECT_FORMAT_REGEX = /^[a-zA-Z\d]+:(,|[a-zA-Z\d]+).*/;
function isStringArray(str) {
    return ARRAY_REG.test(str);
}
function isObject(value) {
    return value !== null && typeof value === 'object' && !Array.isArray(value);
}
function parseStringToTypedValue(value) {
    const valueAsNumber = Number(value);
    const valueAsBooleanOrString = ['true', 'false'].includes(value) ? value === 'true' : value;
    return isNaN(valueAsNumber) ? valueAsBooleanOrString : valueAsNumber;
}
function stringifySortParams(sortParams) {
    if (sortParams.length === 0) {
        return '';
    }
    const formattedFields = sortParams.map(({ field, direction }) => `${direction}${field}`);
    return `[${formattedFields.join(',')}]`;
}
function stringifyFilterParams(filters) {
    return filters.reduce((acc, cur, ind) => {
        const delimiter = ind !== 0 && ind !== filters.length ? DELIMITER : '';
        const { field, condition, value } = cur;
        let formattedValue = value;
        if (MULTI_VALUE_CONDITIONS.includes(condition) && Array.isArray(value)) {
            formattedValue = `[${value.join(',')}]`;
        }
        if (isObject(value)) {
            formattedValue = Object.entries(value).reduce((acc, [key, value], ind, arr) => `${acc}${key}:${value}${ind === arr.length - 1 ? '' : ','}`, '');
        }
        return `${acc}${delimiter}${field}[${condition}]${formattedValue}`;
    }, '');
}
export function isValueNotEmpty(value) {
    if (typeof value === 'number') {
        return !isNaN(value);
    }
    if (typeof value === 'string' || Array.isArray(value)) {
        return value.length !== 0;
    }
    if (isObject(value)) {
        return Object.keys(value).length !== 0;
    }
    return value !== undefined && value !== null;
}
export function stringifyRequestParams(params, { encode = false }) {
    var _a, _b;
    const { pagination } = params, restParams = __rest(params, ["pagination"]);
    const result = Object.assign(Object.assign({}, pagination), restParams);
    if ((_a = params.filter) === null || _a === void 0 ? void 0 : _a.length) {
        result.filter = stringifyFilterParams(params.filter);
    }
    if ((_b = params.ordering) === null || _b === void 0 ? void 0 : _b.length) {
        result.ordering = stringifySortParams(params.ordering);
    }
    const returnString = Object.entries(result).reduce((acc, [key, value]) => {
        const delimiter = acc.length ? '&' : '';
        return `${acc}${delimiter}${key}=${value}`;
    }, '');
    return encode ? encodeURIComponent(returnString) : returnString;
}
export function isPaginationKey(key) {
    return Object.values(PAGINATION_KEYS).includes(key);
}
export function parseStringToValue(filterValue) {
    if (filterValue === undefined) {
        return undefined;
    }
    if (isStringArray(filterValue)) {
        try {
            return JSON.parse(filterValue);
        }
        catch (_a) {
            return filterValue
                .replace(/[[\]]/g, '')
                .split(',')
                .map(v => v.trim());
        }
    }
    // Check if value represents an object in format "key1:value1,key2:value2,..."
    const isObjectString = OBJECT_FORMAT_REGEX.test(filterValue);
    if (isObjectString) {
        const parsedValue = filterValue.split(',').reduce((acc, cur) => {
            const [key, value] = cur.split(':');
            if (key !== undefined && value !== undefined) {
                acc[key] = parseStringToTypedValue(value);
            }
            return acc;
        }, {});
        return Object.values(parsedValue).length ? parsedValue : undefined;
    }
    return parseStringToTypedValue(filterValue);
}
export function removeEmptyValuesFromObject(obj) {
    return Object.keys(obj).reduce((acc, cur) => {
        const key = cur;
        let value = obj[key];
        if (isValueNotEmpty(value)) {
            if (isObject(value)) {
                value = removeEmptyValuesFromObject(value);
            }
            if (Array.isArray(value)) {
                // Special handling for filter arrays - remove filters with empty values
                if (key === 'filter') {
                    value = value.filter((filterItem) => isValueNotEmpty(filterItem === null || filterItem === void 0 ? void 0 : filterItem.value));
                }
                else {
                    value = value.filter(isValueNotEmpty);
                }
                if (value.length > 0) {
                    acc[key] = value;
                }
            }
            else {
                acc[key] = value;
            }
        }
        return acc;
    }, {});
}