@cognigy/rest-api-client/dist/esm/shared/helper/rest/query-string/index.js

Cognigy REST-Client

import { decodeComponent } from "./decode-uri-component";
import { splitOnFirst } from "./splitOnFirst";
import { strictUriEncode } from "./strictUriEncode";
const isNullOrUndefined = value => value === null || value === undefined;
export function encoderForArrayFormat(options) {
    switch (options.arrayFormat) {
        case 'index':
            return key => (result, value) => {
                const index = result.length;
                if (value === undefined ||
                    (options.skipNull && value === null) ||
                    (options.skipEmptyString && value === '')) {
                    return result;
                }
                if (value === null) {
                    return [...result, [encode(key, options), '[', index, ']'].join('')];
                }
                return [
                    ...result,
                    [encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')
                ];
            };
        case 'bracket':
            return key => (result, value) => {
                if (value === undefined ||
                    (options.skipNull && value === null) ||
                    (options.skipEmptyString && value === '')) {
                    return result;
                }
                if (value === null) {
                    return [...result, [encode(key, options), '[]'].join('')];
                }
                return [...result, [encode(key, options), '[]=', encode(value, options)].join('')];
            };
        case 'comma':
        case 'separator':
            return key => (result, value) => {
                if (value === null || value === undefined || value.length === 0) {
                    return result;
                }
                if (result.length === 0) {
                    return [[encode(key, options), '=', encode(value, options)].join('')];
                }
                return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
            };
        default:
            return key => (result, value) => {
                if (value === undefined ||
                    (options.skipNull && value === null) ||
                    (options.skipEmptyString && value === '')) {
                    return result;
                }
                if (value === null) {
                    return [...result, encode(key, options)];
                }
                return [...result, [encode(key, options), '=', encode(value, options)].join('')];
            };
    }
}
export function parserForArrayFormat(options) {
    let result;
    switch (options.arrayFormat) {
        case 'index':
            return (key, value, accumulator) => {
                result = /\[(\d*)\]$/.exec(key);
                key = key.replace(/\[\d*\]$/, '');
                if (!result) {
                    accumulator[key] = value;
                    return;
                }
                if (accumulator[key] === undefined) {
                    accumulator[key] = {};
                }
                accumulator[key][result[1]] = value;
            };
        case 'bracket':
            return (key, value, accumulator) => {
                result = /(\[\])$/.exec(key);
                key = key.replace(/\[\]$/, '');
                if (!result) {
                    accumulator[key] = value;
                    return;
                }
                if (accumulator[key] === undefined) {
                    accumulator[key] = [value];
                    return;
                }
                accumulator[key] = [].concat(accumulator[key], value);
            };
        case 'comma':
        case 'separator':
            return (key, value, accumulator) => {
                const isArray = typeof value === 'string' && value.includes(options.arrayFormatSeparator);
                const isEncodedArray = (typeof value === 'string' && !isArray && decode(value, options).includes(options.arrayFormatSeparator));
                value = isEncodedArray ? decode(value, options) : value;
                const newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map(item => decode(item, options)) : value === null ? value : decode(value, options);
                accumulator[key] = newValue;
            };
        default:
            return (key, value, accumulator) => {
                if (accumulator[key] === undefined) {
                    accumulator[key] = value;
                    return;
                }
                accumulator[key] = [].concat(accumulator[key], value);
            };
    }
}
export function validateArrayFormatSeparator(value) {
    if (typeof value !== 'string' || value.length !== 1) {
        throw new TypeError('arrayFormatSeparator must be single character string');
    }
}
export function encode(value, options) {
    if (options.encode) {
        return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
    }
    return value;
}
export function decode(value, options) {
    if (options.decode) {
        return decodeComponent(value);
    }
    return value;
}
export function keysSorter(input) {
    if (Array.isArray(input)) {
        return input.sort();
    }
    if (typeof input === 'object') {
        return keysSorter(Object.keys(input))
            .sort((a, b) => Number(a) - Number(b))
            .map(key => input[key]);
    }
    return input;
}
export function removeHash(input) {
    const hashStart = input.indexOf('#');
    if (hashStart !== -1) {
        input = input.slice(0, hashStart);
    }
    return input;
}
export function getHash(url) {
    let hash = '';
    const hashStart = url.indexOf('#');
    if (hashStart !== -1) {
        hash = url.slice(hashStart);
    }
    return hash;
}
export function extract(input) {
    input = removeHash(input);
    const queryStart = input.indexOf('?');
    if (queryStart === -1) {
        return '';
    }
    return input.slice(queryStart + 1);
}
export function parseValue(value, options) {
    if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {
        value = Number(value);
    }
    else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
        value = value.toLowerCase() === 'true';
    }
    return value;
}
export function parse(query, options) {
    options = Object.assign({
        decode: true,
        sort: true,
        arrayFormat: 'none',
        arrayFormatSeparator: ',',
        parseNumbers: false,
        parseBooleans: false
    }, options);
    validateArrayFormatSeparator(options.arrayFormatSeparator);
    const formatter = parserForArrayFormat(options);
    // Create an object with no prototype
    const ret = Object.create(null);
    if (typeof query !== 'string') {
        return ret;
    }
    query = query.trim().replace(/^[?#&]/, '');
    if (!query) {
        return ret;
    }
    for (const param of query.split('&')) {
        let [key, value] = splitOnFirst(options.decode ? param.replace(/\+/g, ' ') : param, '=');
        // Missing `=` should be `null`:
        // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
        value = value === undefined ? null : ['comma', 'separator'].includes(options.arrayFormat) ? value : decode(value, options);
        formatter(decode(key, options), value, ret);
    }
    for (const key of Object.keys(ret)) {
        const value = ret[key];
        if (typeof value === 'object' && value !== null) {
            for (const k of Object.keys(value)) {
                value[k] = parseValue(value[k], options);
            }
        }
        else {
            ret[key] = parseValue(value, options);
        }
    }
    if (options.sort === false) {
        return ret;
    }
    return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
        const value = ret[key];
        if (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {
            // Sort object keys, not values
            result[key] = keysSorter(value);
        }
        else {
            result[key] = value;
        }
        return result;
    }, Object.create(null));
}
export const stringify = (object, options) => {
    if (!object) {
        return '';
    }
    options = Object.assign({
        encode: true,
        strict: true,
        arrayFormat: 'none',
        arrayFormatSeparator: ','
    }, options);
    validateArrayFormatSeparator(options.arrayFormatSeparator);
    const shouldFilter = key => ((options.skipNull && isNullOrUndefined(object[key])) ||
        (options.skipEmptyString && object[key] === ''));
    const formatter = encoderForArrayFormat(options);
    const objectCopy = {};
    for (const key of Object.keys(object)) {
        if (!shouldFilter(key)) {
            objectCopy[key] = object[key];
        }
    }
    const keys = Object.keys(objectCopy);
    if (options.sort !== false) {
        keys.sort(options.sort);
    }
    return keys.map(key => {
        const value = object[key];
        if (value === undefined) {
            return '';
        }
        if (value === null) {
            return encode(key, options);
        }
        if (Array.isArray(value)) {
            return value
                .reduce(formatter(key), [])
                .join('&');
        }
        return encode(key, options) + '=' + encode(value, options);
    }).filter(x => x.length > 0).join('&');
};
export const parseUrl = (url, options) => {
    options = Object.assign({
        decode: true
    }, options);
    const [url_, hash] = splitOnFirst(url, '#');
    return Object.assign({
        url: url_.split('?')[0] || '',
        query: parse(extract(url), options)
    }, options && options.parseFragmentIdentifier && hash ? { fragmentIdentifier: decode(hash, options) } : {});
};
export const stringifyUrl = (object, options) => {
    options = Object.assign({
        encode: true,
        strict: true
    }, options);
    const url = removeHash(object.url).split('?')[0] || '';
    const queryFromUrl = extract(object.url);
    const parsedQueryFromUrl = parse(queryFromUrl, { sort: false });
    const query = Object.assign(parsedQueryFromUrl, object.query);
    let queryString = stringify(query, options);
    if (queryString) {
        queryString = `?${queryString}`;
    }
    let hash = getHash(object.url);
    if (object.fragmentIdentifier) {
        hash = `#${encode(object.fragmentIdentifier, options)}`;
    }
    return `${url}${queryString}${hash}`;
};
//# sourceMappingURL=index.js.map